Temporal Feature Trails

Temporal Workflows are used to build resilient platform control planes by mapping resources to long-running Entity Workflows. This pattern leverages Updates, Signals, and Queries for message handling, serializes side effects in a main loop, and uses Continue-as-New for history rotation. It supports complex lifecycles, error handling, compensation, and integrates with external APIs via Activities. This post details how a durable egress-only connector for cloud-to-edge messaging was built using Temporal. The saga pattern provides a robust, modern solution for handling data consistency challenges in microservices by coordinating distributed transactions through sequences of local transactions with compensating actions. It can be implemented via choreography or orchestration and is beneficial for e-commerce, finance, and IoT systems. Best practices include designing for failure, ensuring idempotency, and defining compensation actions. Temporal's platform has been instrumental in enabling organizations to adopt the saga pattern effectively.

Temporal offers a layered approach to data security. This post details how to protect sensitive data in transit using TLS and at rest using application-level encryption via Payload Codecs. It explains the roles of Data Converters, Payload Converters, Failure Converters, and Payload Codecs in serializing, deserializing, and transforming data. The focus is on using Payload Codecs for encryption, ensuring that the Temporal Service only sees encrypted data, and that keys are managed externally.

Ignition is a Temporal-powered system for flashing firmware onto devices at scale. It manages distributed workflows for individual device flashing, handles device re-enumeration and retries, and provides detailed state tracking for each device. The system was used to flash 2,300 conference badges, demonstrating its ability to manage large-scale, time-sensitive hardware operations. This post details the development of a custom hardware badge for the Replay conference, including its hardware components (ESP32-S3, OLED, IR, joystick, buttons, haptic feedback, LED matrix, gyroscope), firmware development in C and MicroPython, and the use of generative AI (Claude, Codex) to assist in writing the firmware and tests. The project involved significant manufacturing coordination in Shenzhen and was inspired by DEF CON badges and Pimoroni's Badgeware.

Deputy is an open-source, CLI-first security toolchain for inventorying, scanning, triaging, and controlling dependencies across repositories, container images, VM disk images, SBOMs, and other targets. It provides a customizable policy layer using CEL for local development, CI, and download time enforcement. Key features include vulnerability analysis with exploitability enrichment (KEV, EPSS), SLA enforcement for advisories, and protection against lookalike packages. Deputy also offers sandboxed execution (`deputy exec`) and download-time policy enforcement (`deputy proxy`).

Serverless Workers are now in Pre-release, enabling Temporal Workers to run on serverless compute, starting with AWS Lambda. Temporal Cloud automatically invokes, scales, and gracefully shuts down workers based on workload volume and metrics, scaling to zero when appropriate. This reduces the time to get started and simplifies worker management.

Standalone Activities offer a durable abstraction for background job processing. This feature allows Temporal Activities to be invoked directly from a client without being part of a larger Workflow. Key capabilities include default durability with automatic retries and timeouts, full visibility and lifecycle control through stable IDs and UI/CLI/API access, and seamless integration with existing Activity code, enabling a unified platform for both standalone jobs and workflows. This post details how a PII-compliant data pipeline uses Standalone Activities to bridge Pub/Sub events to Temporal Workflows.

This post clarifies the distinction between Temporal Timers and Activity Timeouts, emphasizing that Timers are for implementing business logic and durable waiting, while Timeouts are for detecting failures. It details the four Activity timeout types (Start-to-Close, Schedule-to-Close, Schedule-to-Start, and Heartbeat) and their use cases, providing guidance on how to configure them for reliable workflow execution. The post also touches upon the underlying Temporal Service mechanisms for handling these time-based constructs.

Temporal Cloud now offers enhanced cost transparency through a new Billing API and the Billable Action Count metric. The Billing API provides namespace- and tag-level cost attribution with hourly granularity, accessible via the Cloud Ops API, CSV downloads, and integrations with Datadog and Vantage. The Billable Action Count metric offers granular usage information for namespaces and workflow types, available via the OpenMetrics endpoint, aiding in optimization, alerting, forecasting, and attribution. This post details practical ways to use the Billable Action Count metric for cost analysis, debugging, and alerting, including PromQL queries for identifying high-cost Workflow Types and Action Types, estimating total Actions over time, and setting up adaptive alerts for Action volume spikes.

Workflow Streams provides a durable abstraction for real-time, interactive communication within Temporal applications. It enables applications to publish ordered sequences of typed events to topics scoped to a Workflow, allowing both the Workflow itself and external clients to publish and subscribe. This feature leverages Temporal's core primitives (Workflows, Signals, Updates, Queries) to offer exactly-once semantics and seamless integration with AI agent frameworks and other streaming use cases. It addresses limitations of traditional pub/sub systems by providing built-in durability and deduplication, and supports advanced features like Continue-As-New handoff and integration with Server-Sent Events for UIs.

This post introduces a Docker Desktop extension that simplifies the local development setup for Temporal. It provides a one-click way to start a local Temporal server with persistent SQLite storage, exposes key endpoints (gRPC and Web UI), and offers basic workflow status visibility. The extension aims to make the initial experience of trying Temporal more immediate and familiar by integrating with a common developer tool.

Temporal Actor Workflows provide a pattern for modeling individual players as durable, independently-running processes. Each player is represented by a Workflow, identified by their customer ID, which holds their state (points balance, tier status, activity history) and executes business logic (purchases, redemptions, tier upgrades) synchronously via Signals, Updates, and Queries. This pattern ensures sessions survive server crashes, eliminates the need for complex reconnection logic, and automatically manages history growth with Continue-As-New. This approach addresses the challenges of running loyalty programs at scale by providing a dedicated, durable account for each customer that holds state, enforces business rules, responds to events in real time, and never needs a cron job to stay current.

Temporal MCP server provides AI assistants with read-only access to Temporal Cloud and self-hosted clusters, enabling natural language querying of workflow status, history, and infrastructure. This facilitates debugging by correlating runtime state with code, improving cross-team troubleshooting.

This post details the open-sourcing of an entire ecosystem for a custom hardware badge, including firmware, hardware design files, fabrication instructions, flashing tools, and community app infrastructure. It highlights the challenges and lessons learned in bridging software and hardware development, managing complex dependencies, and creating a platform for community extension.

Task Queue Priority and Fairness provide mechanisms to control task execution order and resource distribution within Temporal. Priority allows assigning integer levels (1-5) to Workflows and Activities to ensure higher-priority tasks are processed first. Fairness uses weighted round-robin scheduling based on Fairness Keys to ensure equitable resource distribution among tenants or logical groups, preventing monopolization of Workers. These features can be combined to support differentiated service levels. This post introduces a validated pattern for using separate Task Queues with rate limiting configuration to protect downstream APIs, leveraging `max_task_queue_activities_per_second`, `max_activities_per_second`, and `max_concurrent_activities` to prevent exceeding API rate limits.

Temporal Workflows are used for reliable email delivery at scale, handling large volumes with smart batching and resilient error handling. Event duplication is orchestrated using a two-phase approach: an atomic, rollback-safe main workflow for core operations and a subsequent asynchronous workflow for background tasks like notifications and integrations. This has led to significant improvements in success rates, processing times, and reduced manual intervention. This post introduces the Validated Pattern for recovering failed workflow steps without restarting, allowing for human or automated correction of permanent failures and resuming execution from the point of failure, rather than restarting the entire process.

Temporal Cloud now integrates with Datadog and Grafana Cloud, allowing users to ingest Temporal Cloud metrics into their respective dashboards. This provides real-time insights into Workflow execution, system behavior, and service performance, enabling detection of bottlenecks, retry storms, and tracking of Workflow throughput. The integrations utilize platform-specific mechanisms for easy setup and flexible configuration, offering pre-built dashboards, alerts, and anomaly detection capabilities. The Datadog integration specifically offers out-of-the-box dashboards, granular insights tagged with attributes like Namespace, operation type, Task type, Task Queue name, and Workflow type, and over 30 metrics including Signals like approximate Task Queue backlog, open Workflow counts, Workflow completion stats, action throttling, and poller rates.

Temporal Cloud metering has been updated to reflect new features and ensure consistent billing. This includes changes to how Schedules, Workflow Updates, Child Workflows, and Local Activities are counted as actions. The goal is to align metering with the value consumed by customers and prevent suboptimal implementation decisions driven by cost management. These changes are designed to be net-neutral for most customers, with minor fluctuations expected for some. This post details how to use Temporal Workflows to orchestrate temporary rate limit increases on Namespaces, involving a parent Workflow to raise capacity, a child Workflow with an abandon policy to revert it, and Activities for these actions.

Worker Affinity with Task Queues allows ensuring that multiple Activities within a workflow execute on the same Worker. This is achieved by using a combination of shared and unique task queues. The workflow first discovers an available worker via a shared queue and then routes all subsequent activities to that worker's unique queue, maintaining data locality for scenarios like file processing, ML model caching, and database connection pooling.

Temporal Workflows can now integrate with various sandbox providers (e.g., Modal, E2B, Daytona) to securely execute untrusted, agent-generated code. This "Sandbox Orchestration Harness" provides reference materials, patterns, and best practices for provisioning, managing the lifecycle, persisting state, and cleaning up these temporary compute environments, ensuring they align with the durable execution of AI agents.

Serverless Workers enable Temporal Workers to run on serverless compute platforms like AWS Lambda. Temporal Cloud automatically manages the invocation, scaling, and graceful shutdown of these workers based on workload volume and metrics, allowing them to scale to zero when not in use. This reduces the operational overhead of managing worker infrastructure and simplifies the process of getting started with Temporal. This pre-release feature supports AWS Lambda with Go, Python, and TypeScript SDKs, with plans to expand to Google Cloud Run and additional SDKs.

Temporal is being used to orchestrate complex AI/ML processes, including end-to-end ML pipelines and data engineering flows. This includes managing state machines, handling retries and rollbacks, and coordinating tasks across different infrastructure, such as GPU servers. The platform's durable execution model ensures reliability and allows for faster iteration by developers. Julep AI leverages Temporal to build multi-step AI workflows, enabling AI agents to remember past interactions and execute complex tasks. This integration with Google ADK further enhances Temporal's capabilities in orchestrating multi-agent AI systems by bringing Temporal's durable execution directly into the agentic loop, making each LLM and tool call a resilient Temporal Activity.

Worker Versioning is now Generally Available, allowing Workflows to be pinned to specific code versions or automatically upgraded. Upgrade on Continue-as-New is now in Public Preview, enabling long-running Workflows that use Continue-as-New to seamlessly upgrade to new worker versions at their checkpoint.

The Helm Charts for deploying the Temporal Service to Kubernetes have reached version 1.0.0, signifying a point of stability. This release removes bundled sub-charts for databases (Cassandra, PostgreSQL, MySQL) and optional components like Elasticsearch, Prometheus, and Grafana, requiring users to provide and configure these separately. The `values.yaml` structure has been updated, with changes to internal frontend configuration and `imagePullSecrets` format. New capabilities include configurable readiness probes, custom deployment strategies, `minReadySeconds` for rollout control, configurable log levels, and support for AWS IAM authentication and read-only filesystems for Temporal Docker images.

Temporal Workers can now be deployed to Amazon ECS with Fargate, offering a streamlined approach for long-running, task-based workloads. This includes guidance on container configuration, health checks, graceful shutdown, IAM roles, Fargate Spot utilization, and scaling strategies tailored for Temporal's unique operational model. Observability is enhanced through CloudWatch logs and container insights, with recommendations for when to choose ECS over EKS.

Worker auto-tuning has been introduced to simplify management by automatically adjusting available Task Slots based on CPU and Memory utilization targets. This feature aims to prevent out-of-memory issues and handle bursts of low-resource-usage activities. Users can configure target memory and CPU usage, or optionally set minimum/maximum slots and ramp throttle times for more granular control. Static slot allocation is also an alternative. Future work includes auto-tuning of pollers. This post provides specific examples of how EvenUp uses `temporal_worker_task_slots_used`, `temporal_workflow_task_schedule_to_start_latency`, and `temporal_activity_schedule_to_start_latency` metrics for slot-based and latency-based scaling. It also details the implementation of a Kubernetes liveness probe using `temporal_num_pollers`, `temporal_worker_task_slots_available`, and `temporal_request{operation="RespondWorkflowTaskCompleted"}` to automatically restart unhealthy workers, addressing issues like stuck workers due to synchronous CPU-intensive work in Workflow tasks and failed Workflow cache evictions.

This post provides practical tips for deploying and operating Temporal on Kubernetes to achieve predictable latency, safe upgrades, and efficient scale. It covers running the Temporal Service using Helm charts, deploying Temporal Workers, and autoscaling Workers based on Task Queue backlog and Schedule-to-Start latency. It also discusses planning capacity and tuning for production, including addressing CPU throttling and the importance of load testing. The post highlights the Temporal Worker Controller and Worker Versioning for advanced deployment management.

Temporal Nexus is now generally available, enabling the connection of Temporal Applications within and across isolated Namespaces. It provides Durable Execution benefits with improved modularity, security, debugging, and fault isolation. Nexus supports at-least-once and exactly-once execution guarantees, and in Temporal Cloud, offers multi-region connectivity across AWS and GCP, policy enforcement for Nexus Endpoints, and auditing capabilities. The roadmap includes expanding connectivity to non-Temporal services and enhancing its capabilities for cross-namespace and cross-cloud communication. This post further elaborates on Nexus as a 'durable promise' infrastructure, contrasting it with Kafka's broadcast model and Temporal's structured roads, highlighting its role in direct, guaranteed, long-duration operations between services.

Temporal's SDK ecosystem continues to expand with the announcement and initial release of the Swift SDK. This SDK leverages Swift's modern concurrency features like async/await and structured concurrency, integrating with the Temporal Core SDK for durable execution. It provides macros for defining Workflows and Activities, and supports core Temporal features like signals, queries, updates, child workflows, continue-as-new, local activities, and search attributes. Production-ready features like i

Temporal Cloud now offers Multi-region Namespaces (formerly Global Namespaces) in public preview, providing an active-standby setup for enhanced high availability and disaster recovery. This feature replicates workflows to a standby region, enabling seamless failover during outages to meet a 99.99% SLA against service errors. The system is managed by Temporal Cloud, requiring no manual configuration or code changes from users. This capability has been dogfooded internally for over a year.

Saved Views in the Temporal Web UI allow users to save and quickly access frequently used workflow queries. This feature includes System Views for common use cases and Custom Views that users can create and manage. The UI also features streamlined filtering and the ability to share views with teammates. Views are stored in browser localStorage with a limit of 20 custom views per namespace.

Temporal Cloud's authentication and authorization layer has been enhanced with the introduction of Just-In-Time (JIT) access provisioning for infrastructure, significantly reducing the attack surface by limiting user access to only what is requested, when it is requested, and for only as long as it is needed. This includes implementing access hours, reducing the percentage of time engineers have access to infrastructure from 100% to a calculated 23.8% of the week, and further reducing it based on specific security requirements. The open-source Temporal Server now supports OIDC-compliant identity providers for authentication and has a robust authorization system, with meticulous review of existing system APIs to ensure access control is enforced everywhere. Temporal has also undergone SOC2 compliance processes and penetration testing, with all identified issues resolved. A renowned security expert is advising the company part-time to ensure secure solutions.

This post details a client's ROI analysis for migrating to Temporal Cloud, highlighting significant cost savings in infrastructure, maintenance, and human capital. It quantifies benefits such as reduced incident management, faster feature development, improved system stability, and enhanced long-term scalability. The analysis compares the Total Cost of Ownership (TCO) of a homegrown Inventory Management System (IES) with Temporal Cloud, demonstrating substantial annual savings and improved opera. This post further quantifies these benefits through a Forrester Total Economic Impact™ study, detailing preserved revenue, protected operating profit, reduced manual reconciliation, faster feature delivery, and increased developer productivity. It also highlights the strategic advantages of Temporal Cloud for banking, including talent retention and enabling transformation initiatives, and provides a detailed financial model for potential customers.

Temporal is developing a new Core SDK in Rust to serve as a shared foundation for all language-specific SDKs. This aims to reduce duplicated logic, improve maintainability, and ensure high performance and reliability across languages. The Core SDK handles complex state reconciliation and event history processing, abstracting this logic away from individual language SDKs. Rust was chosen for its performance, safety, and ability to compile to WASM, enabling easier integration with various languages. This post details how Codex by OpenAI was used to improve the Java SDK, including fixing bugs, implementing missing features (like counting workflow executions using search attributes), and adding end-to-end tests, demonstrating the potential for AI agents to contribute to SDK development and readiness for agentic contributions.

Temporal's new Scheduler feature provides an improved experience for developers with a schedule-specific API, finer-grained configurations, improved visibility, and the ability to have overlapping runs. It was built as a Workflow within Temporal Server, reusing existing functionality. Challenges included managing namespaces, hiding internal scheduler Workflows from user visibility using search attributes, and handling signals vs. queries for state updates. This post details how to export workflo. This post extends the concept of managing complex deployment processes by illustrating how Temporal Workflows can be used to orchestrate multi-repository builds, blue-green deployments, and manual approval steps, effectively taming deployment complexity.

Temporal Cloud now offers migration tooling for seamless transitions from self-hosted Temporal instances. This pre-release feature automates the migration process with zero downtime for workflows, requiring minimal application code changes. It involves a migration server and proxies for secure communication, with a step-by-step guide for preparation, initiation, monitoring, validation, and finalization or abortion. The tooling currently supports self-hosted to Cloud migrations, with reverse migrations planned.

Eager Workflow Start (EWS) is an experimental latency optimization that reduces the time it takes to start a workflow by allowing the starter and worker to interact directly, bypassing some server operations. The start response with EWS includes the initial workflow task when there is a local worker ready to process it. This is particularly useful for short-lived workflows that interact with other services using local activities and are deployed close to the Temporal Server. The current implementation is experimental.

Workflow Updates provide a new mechanism for clients to send messages to Workflows, wait for their completion, and receive a result. This addresses limitations of existing Query and Signal messages by allowing the handler to perform arbitrary work, execute Activities and Child Workflows, and mutate Workflow state, while also returning a result. This enables lower-latency use cases and more efficient communication patterns compared to Signal+Query polling. Updates can also include validators to reject invalid messages before they are persisted to history, and can be combined with Local Activities for further latency optimization. Design patterns include mutating local state, executing Activities/Child Workflows, and waiting for specific Workflow states.

This post details the development of a live, multiplayer snake game using Temporal Workflows and Activities to showcase its resilience and ability to handle chaos. The game involved multiple independent Workflows for the game, rounds, and individual snakes. The demo simulated real-world failure scenarios by intentionally restarting Workers (via Activities) when apples were eaten and by physically unplugging network cables from tablets running Workers. Temporal's Durable Execution model ensured seamless recovery from these disruptions, demonstrating its robustness in handling unexpected outages. The post also touches on the use of Socket.io for low-latency UI integration and the performance benefits of the Go SDK for worker implementation in resource-constrained environments. It highlights how Temporal allows developers to focus on game logic rather than error handling.

Temporal Cloud's custom persistence layer, featuring enhanced sharding, a write-ahead log (WAL), and tiered storage of Workflow Event History, has been further validated through benchmarks demonstrating lower application-side latency compared to self-hosted Temporal. These architectural advancements, designed for high throughput and large scale, effectively offset increased network latency when using Temporal Cloud, making it the preferred choice for internet-scale and low-latency workloads.

The Workflow Execution UI has been significantly redesigned to provide a more intuitive and performant experience for understanding workflow states. Key improvements include the introduction of 'Event Groups' to simplify the event history, and three distinct views: Compact, Timeline, and Full History. The Timeline view visualizes event durations and timings, showing the flow of Events in time as your Workflow is executing. It leverages Event Groups to represent activities as spans, with color indicating outcome and position showing parallelism. Retries are indicated with an icon and attempt number. Users can navigate and filter the Timeline via scrolling, zooming, and event type filtering. The Timeline is built using the vis-timeline library and customized with Svelte.

The Terraform Provider for Temporal Cloud enables infrastructure as code automation for managing Temporal Cloud resources like Namespaces and Users. It allows for declarative definition, versioning, and automated lifecycle management of these resources, integrating Temporal Cloud into existing Terraform workflows. Initial support includes Namespace and User management, with plans for expanded resource support. The provider utilizes Temporal Cloud API Keys for authentication and supports importing. This post extends this by detailing how these automation features, including API Keys, the CLI, and the Terraform provider, facilitate centralized cloud operations, automated mTLS certificate rotation, user and access management synchronized with Enterprise Identity Providers, and streamlined team onboarding by encapsulating resource provisioning.

Temporal V1 marks the production-ready release of the Temporal platform, signifying a commitment to backward compatibility for publicly facing APIs. This release includes improvements to shard ID hashing, which may cause temporary resource usage increases during in-place upgrades. Features like Archival, Cross Data Center Replication, Batch Operations, Dynamic Config, and dynamic management of searchable attributes with Elasticsearch are designated as 'experimental' and will undergo further validation. Server version 1.23.0 has been released, introducing a proto library, new reserved search attributes, and some depreciations. A Terraform provider for Temporal Cloud is in Public Preview, aiding in the creation and management of Temporal Cloud Namespaces. Workflow History Export is now available as a Public Preview. The PHP SDK has been updated to 2.8 and 2.8.1, adding support for the experimental Workflow Update feature. The Go SDK 1.26 release includes support for Typed Search Attributes and some breaking changes related to gRPC protobuf serialization. The Java SDK 1.23 release offers bug fixes, improved defaults, and changes to use the new history JSON format.

Temporal Workflows can now be orchestrated across multiple programming languages. While a single Workflow definition must reside in one language, it can invoke Activities written in different languages. This requires separate Workers for each language and distinct task queue names to ensure proper routing. The Temporal SDKs handle automatic data type conversion between languages, enabling seamless interoperability. Example applications like Temporal Polyglot and Temporal Pendulum demonstrate this capability, showcasing how a primary language can orchestrate activities written in others.

Temporal Cloud now offers Workflow History Export, allowing users to export closed workflow histories to an AWS S3 bucket on a per-namespace basis. This feature addresses longer-term data storage needs beyond the default 30-day or extended 90-day retention, enabling compliance, auditing, and post-mortem analysis. The setup involves creating an S3 bucket in the same region as the namespace and granting Temporal permission via AWS CloudFormation. Exports occur hourly, with associated costs billed per namespace.

Temporal's SDK ecosystem has expanded to include .NET, allowing developers to write durable workflows and activities using C# and other .NET languages. This SDK offers high performance, good resource utilization, and type-safe APIs, addressing challenges related to workflow determinism through a custom TaskScheduler and runtime/compile-time checks.

Temporal has become a CVE Numbering Authority (CNA), enabling the company to assign CVE identifiers to vulnerabilities in its software. This initiative enhances transparency and security for users of Temporal Server and Temporal Cloud. A specific vulnerability (CVE-2023-3485) related to namespace protection in self-hosted Temporal Server was addressed in version 1.20.0, with a configuration option available in earlier versions to mitigate the risk.

Temporal Cloud now allows configuring a Codec Server endpoint per Namespace, enabling different encryption/decryption algorithms for different namespaces and simplifying the user experience for viewing unencrypted data locally. This enhances data security by ensuring Temporal never has access to user encryption keys.

The VS Code extension provides an improved debugging experience for TypeScript workflows by enabling replay debugging. Users can load Event Histories, set breakpoints on events, and interact with the workflow execution directly within VS Code. This enhances the ability to debug workflows locally and in production by replaying historical executions.

The Temporal CLI has been unified into a single `temporal` command-line tool, combining the functionality of `tctl` and `temporalite`. This new CLI simplifies development and testing by allowing users to run a local development server and interact with Temporal Servers. It offers features like installing via cURL or Homebrew, starting a development server with data persistence options, and interacting with workflows, activities, task queues, and schedules. The CLI also supports managing different output formats (tables, JSON, cards), piping output to other tools, and customizable timestamp formatting. This post details ongoing RFCs and community input for further CLI improvements.

Temporal's SDK ecosystem continues to expand with the announcement and initial release of the Python SDK. This SDK leverages Python's native asyncio constructs for durable workflows, integrating with the Temporal Core SDK for durable execution. It provides a natural fit for Python developers looking to write durable workflows, enabling them to use asyncio event loops for managing timers, async tasks, and coroutines. The SDK supports core Temporal features like signals, queries, and activities. This release includes installation instructions for the Temporal CLI and Python package, setup for a local development server, and a basic usage example with a 'hello world' workflow. It also points to further resources like sample applications, documentation, and the API reference.

Temporal Workflows can now be exposed as REST APIs with minimal boilerplate using the temporal-rest library. This library automatically generates ExpressJS middleware to handle starting workflows, querying their state, and signaling them, abstracting away the need for manual API implementation and reducing boilerplate code for developers.

Temporal's SDK ecosystem continues to expand with the announcement and initial release of the Swift SDK. This SDK leverages Swift's modern concurrency features like async/await and structured concurrency, integrating with the Temporal Core SDK for durable execution. It provides macros for defining Workflows and Activities, and supports core Temporal features like signals, queries, updates, child workflows, continue-as-new, local activities, and search attributes. Production-ready features like i