effect 4.0.0-beta.70 → 4.0.0-beta.72

package/src/unstable/workflow/DurableClock.ts

@@ -1,17 +1,29 @@
 /**
- * Durable workflow clocks provide workflow-safe timers and sleep operations.
+ * Workflow-safe sleeps that can be replayed, suspended, and resumed by a
+ * workflow engine.
  *
- * Use this module when a workflow needs to pause until a timeout, reminder,
- * deadline, retry delay, or other scheduled wake-up. Short sleeps can run as
- * in-memory activities, while longer sleeps are scheduled with the workflow
- * engine and resumed through a durable deferred signal when the timer fires.
+ * Use this module when a workflow needs to pause for a timeout, reminder,
+ * deadline, retry delay, or scheduled wake-up. `sleep` keeps very short delays
+ * in the current process as an activity, and turns longer delays into durable
+ * clocks that the engine can schedule and resume through a durable deferred.
  *
- * Because workflows may be replayed, timer names and durations should be
- * deterministic and stable for a given workflow path. Avoid deriving them from
- * ambient wall-clock state, and give distinct sleeps distinct names so replayed
- * executions can be matched with the correct scheduled wake-up. Lower the
- * in-memory threshold when a delay must be handled by the workflow engine
- * rather than the current process.
+ * **Mental model**
+ *
+ * A `DurableClock` is a stable timer name, a normalized duration, and the
+ * deferred completed when the timer wakes. `sleep` is the workflow-facing
+ * helper: zero durations complete immediately, durations at or below the
+ * in-memory threshold run with `Effect.sleep` inside an activity, and longer
+ * durations are scheduled with the `WorkflowEngine` before awaiting the
+ * clock's deferred.
+ *
+ * **Gotchas**
+ *
+ * Timer names, durations, and thresholds are part of workflow behavior. Keep
+ * them deterministic for a given workflow path, avoid deriving them from
+ * ambient wall-clock state, and give distinct logical waits distinct names so
+ * replayed executions match the correct scheduled wake-up. Lower the in-memory
+ * threshold when a delay must survive the current process rather than relying
+ * on an in-process sleep.
  *
  * @since 4.0.0
  */
@@ -68,10 +80,10 @@ const InstanceTag = Context.Service<
 )
 
 /**
- * Sleeps inside a workflow, using an in-memory activity for durations at or
+ * Waits inside a workflow, using an in-memory activity for durations at or
  * below the threshold and scheduling a durable clock for longer durations.
  *
- * @category Sleeping
+ * @category sleeping
  * @since 4.0.0
  */
 export const sleep: (

package/src/unstable/workflow/DurableDeferred.ts

@@ -168,7 +168,7 @@ const await_: <Success extends Schema.Top, Error extends Schema.Top>(
 
 export {
   /**
-   * Awaits the durable deferred, suspending the current workflow when no
+   * Waits for the durable deferred, suspending the current workflow when no
    * persisted completion is available.
    *
    * @category combinators
@@ -333,7 +333,7 @@ export type TokenTypeId = typeof TokenTypeId
  * Branded string token identifying a durable deferred for a workflow
  * execution.
  *
- * @category Token
+ * @category token
  * @since 4.0.0
  */
 export type Token = Brand.Branded<string, TokenTypeId>
@@ -341,16 +341,16 @@ export type Token = Brand.Branded<string, TokenTypeId>
 /**
  * Schema for branded durable deferred tokens.
  *
- * @category Token
+ * @category token
  * @since 4.0.0
  */
 export const Token: Schema.brand<Schema.String, TokenTypeId> = Schema.String.pipe(Schema.brand(TokenTypeId))
 
 /**
- * Decoded representation of a durable deferred token containing the workflow
+ * Schema for a decoded durable deferred token containing the workflow
  * name, execution ID, and deferred name.
  *
- * @category Token
+ * @category token
  * @since 4.0.0
  */
 export class TokenParsed extends Schema.Class<TokenParsed>(
@@ -425,7 +425,7 @@ export class TokenParsed extends Schema.Class<TokenParsed>(
  * Creates a token for a durable deferred using the current workflow instance's
  * workflow name and execution ID.
  *
- * @category Token
+ * @category token
  * @since 4.0.0
  */
 export const token: <Success extends Schema.Top, Error extends Schema.Top>(
@@ -443,7 +443,7 @@ export const token: <Success extends Schema.Top, Error extends Schema.Top>(
  * Creates a durable deferred token from an explicit workflow, execution ID,
  * and deferred name.
  *
- * @category Token
+ * @category token
  * @since 4.0.0
  */
 export const tokenFromExecutionId: {
@@ -451,7 +451,7 @@ export const tokenFromExecutionId: {
    * Creates a durable deferred token from an explicit workflow, execution ID,
    * and deferred name.
    *
-   * @category Token
+   * @category token
    * @since 4.0.0
    */
   (
@@ -466,7 +466,7 @@ export const tokenFromExecutionId: {
    * Creates a durable deferred token from an explicit workflow, execution ID,
    * and deferred name.
    *
-   * @category Token
+   * @category token
    * @since 4.0.0
    */
   <Success extends Schema.Top, Error extends Schema.Top>(
@@ -493,7 +493,7 @@ export const tokenFromExecutionId: {
  * Creates a durable deferred token by deriving the workflow execution ID from
  * the supplied workflow payload.
  *
- * @category Token
+ * @category token
  * @since 4.0.0
  */
 export const tokenFromPayload: {
@@ -501,7 +501,7 @@ export const tokenFromPayload: {
    * Creates a durable deferred token by deriving the workflow execution ID from
    * the supplied workflow payload.
    *
-   * @category Token
+   * @category token
    * @since 4.0.0
    */
   <W extends Workflow.Any>(
@@ -516,7 +516,7 @@ export const tokenFromPayload: {
    * Creates a durable deferred token by deriving the workflow execution ID from
    * the supplied workflow payload.
    *
-   * @category Token
+   * @category token
    * @since 4.0.0
    */
   <

package/src/unstable/workflow/DurableQueue.ts

@@ -1,19 +1,37 @@
 /**
- * Durable queues bridge workflow executions with persisted background workers.
- * A workflow calls `process` to enqueue a schema-encoded payload in a named
- * `PersistedQueue`, attach a durable deferred token, and suspend until a worker
- * records the handler's `Exit` back through that deferred.
+ * Durable workflow queues delegate work to persisted background workers and
+ * resume the waiting workflow with the worker result.
  *
- * Use this module for workflow steps that should be delegated to independent
- * workers: long-running side effects, rate-limited or concurrency-limited
- * integrations, fan-out jobs, API calls, and other work that must survive
- * workflow suspension, process restarts, or handoff to another service.
+ * A workflow calls `process` to encode a payload, offer it to a named
+ * `PersistedQueue`, attach a `DurableDeferred` token, and suspend. A worker
+ * created with `makeWorker` or `worker` takes the item, runs the handler, and
+ * records the handler's `Exit` through that token so the original workflow can
+ * continue with the typed success or error.
  *
- * Queue names, payload schemas, result schemas, and idempotency keys become
- * persisted coordination state. Keep them deterministic and stable across
- * deployments; changing them is a persistence migration. Delivery follows the
- * underlying `PersistedQueue` semantics, so handlers should be idempotent and
- * prepared for retries, duplicate observations, and worker restarts.
+ * **Mental model**
+ *
+ * A `DurableQueue` definition names the persisted queue and carries the payload,
+ * success, and error schemas shared by producers and workers. The
+ * `idempotencyKey` becomes the persisted queue item id, while `process` also
+ * stores trace context and a deferred token alongside the payload. Worker
+ * concurrency is local to the worker layer; delivery and retry behavior come
+ * from the underlying `PersistedQueue`.
+ *
+ * **Common tasks**
+ *
+ * Use `make` to define the queue once, call `process` from workflow code, and
+ * run `worker` in the service responsible for executing queued work. Tune
+ * `process` retries for transient persistence failures, and tune worker
+ * concurrency for the downstream system being called.
+ *
+ * **Gotchas**
+ *
+ * Queue names, schemas, result types, and idempotency keys are persisted
+ * coordination state. Keep them deterministic and stable across deployments;
+ * changing them is a persistence migration. Delivery is at least once according
+ * to the backing `PersistedQueue`, so handlers should be idempotent and prepared
+ * for retries, duplicate observations, worker restarts, and completions that are
+ * decoded by a later version of the queue definition.
  *
  * @since 4.0.0
  */
@@ -63,8 +81,8 @@ export interface DurableQueue<
 }
 
 /**
- * A `DurableQueue` wraps a `PersistedQueue`, providing a way to wait for items
- * to finish processing using a `DurableDeferred`.
+ * Creates a `DurableQueue` that waits for persisted items to finish processing
+ * using a `DurableDeferred`.
  *
  * **Example** (Defining a durable queue with workers)
  *
@@ -176,7 +194,7 @@ const getQueueSchema = <Payload extends Schema.Top>(
 }
 
 /**
- * Add an item to the queue and wait for a worker to process it.
+ * Adds an item to the queue and wait for a worker to process it.
  *
  * @category Processing
  * @since 4.0.0

package/src/unstable/workflow/Workflow.ts

@@ -447,7 +447,7 @@ const ResultTypeId = "~effect/workflow/Workflow/Result"
 /**
  * Returns `true` when a value is a workflow `Result`.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export const isResult = <A = unknown, E = unknown>(
@@ -458,7 +458,7 @@ export const isResult = <A = unknown, E = unknown>(
  * Result of a workflow execution, either a completed exit or a suspended
  * workflow state.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export type Result<A, E> = Complete<A, E> | Suspended
@@ -466,7 +466,7 @@ export type Result<A, E> = Complete<A, E> | Suspended
 /**
  * Encoded representation of a workflow `Result`.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export type ResultEncoded<A, E> =
@@ -477,7 +477,7 @@ export type ResultEncoded<A, E> =
  * Encoded representation of a completed workflow result containing an encoded
  * `Exit`.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export interface CompleteEncoded<A, E> {
@@ -507,10 +507,9 @@ export interface CompleteSchema<
 }
 
 /**
- * Workflow result representing a completed execution with its success or
- * failure `Exit`.
+ * Represents a completed workflow execution with its success or failure `Exit`.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export class Complete<A, E> extends Data.TaggedClass("Complete")<{
@@ -579,10 +578,10 @@ export class Complete<A, E> extends Data.TaggedClass("Complete")<{
 }
 
 /**
- * Workflow result representing a suspended execution, optionally carrying the
- * cause that triggered suspension.
+ * Represents a suspended workflow execution, optionally carrying the cause that
+ * triggered suspension.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export class Suspended extends Schema.Class<Suspended>(
@@ -603,7 +602,7 @@ export class Suspended extends Schema.Class<Suspended>(
  * Creates a schema for workflow results using the supplied success and error
  * schemas.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export const Result = <
@@ -617,9 +616,9 @@ export const Result = <
 const AnyOrVoid = Schema.Union([Schema.Any, Schema.Void])
 
 /**
- * Codec for encoded workflow results with generic success and error payloads.
+ * Schema for encoded workflow results with generic success and error payloads.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export const ResultEncoded: Schema.Codec<ResultEncoded<any, any>> = Schema.toEncoded(
@@ -636,7 +635,7 @@ export const ResultEncoded: Schema.Codec<ResultEncoded<any, any>> = Schema.toEnc
  * `Result`, handling suspension, defect capture, interruption, and workflow
  * scope finalization.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export const intoResult = <A, E, R>(
@@ -699,7 +698,7 @@ export const intoResult = <A, E, R>(
  * Wraps an activity-like effect so workflow suspension waits for currently
  * running activities to finish or suspend.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export const wrapActivityResult = <A, E, R>(
@@ -748,7 +747,7 @@ const waitForZero = Effect.fnUntraced(function*(instance: WorkflowInstance["Serv
 /**
  * Accesses the workflow scope, which is only closed when the workflow execution fully completes.
  *
- * @category Scope
+ * @category resource management
  * @since 4.0.0
  */
 export const scope: Effect.Effect<
@@ -763,7 +762,7 @@ export const scope: Effect.Effect<
 /**
  * Provides the workflow scope to the given effect, and closes the scope only when the workflow execution fully completes.
  *
- * @category Scope
+ * @category resource management
  * @since 4.0.0
  */
 export const provideScope = <A, E, R>(
@@ -775,7 +774,7 @@ export const provideScope = <A, E, R>(
  * Adds an exit finalizer to the current workflow scope, preserving the
  * services available when the finalizer is registered.
  *
- * @category Scope
+ * @category resource management
  * @since 4.0.0
  */
 export const addFinalizer: <R>(
@@ -793,7 +792,7 @@ export const addFinalizer: <R>(
 })
 
 /**
- * Add compensation logic to an effect inside a Workflow.
+ * Adds compensation logic to an effect inside a Workflow.
  *
  * **Details**
  *
@@ -808,7 +807,7 @@ export const addFinalizer: <R>(
  */
 export const withCompensation: {
   /**
-   * Add compensation logic to an effect inside a Workflow.
+   * Adds compensation logic to an effect inside a Workflow.
    *
    * **Details**
    *
@@ -827,7 +826,7 @@ export const withCompensation: {
     effect: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E, R | R2 | WorkflowInstance | Scope.Scope>
   /**
-   * Add compensation logic to an effect inside a Workflow.
+   * Adds compensation logic to an effect inside a Workflow.
    *
    * **Details**
    *
@@ -859,7 +858,7 @@ export const withCompensation: {
  * Marks a workflow instance as suspended and interrupts the current fiber to
  * stop execution until it is resumed.
  *
- * @category Result
+ * @category results
  * @since 4.0.0
  */
 export const suspend = (instance: WorkflowInstance["Service"]): Effect.Effect<never> =>
@@ -887,7 +886,7 @@ export const CaptureDefects = Context.Reference<boolean>(
 )
 
 /**
- * Causes a workflow to suspend when it encounters any error.
+ * Marks a workflow to suspend when it encounters any error.
  *
  * **Details**
  *

package/src/unstable/workflow/WorkflowEngine.ts

@@ -39,7 +39,7 @@ import type * as DurableDeferred from "./DurableDeferred.ts"
 import * as Workflow from "./Workflow.ts"
 
 /**
- * Service interface for workflow runtimes, responsible for registering and
+ * Service that represents workflow runtimes, responsible for registering and
  * executing workflows and coordinating activities, durable deferreds,
  * interrupts, resumes, and clocks.
  *
@@ -136,7 +136,7 @@ export class WorkflowEngine extends Context.Service<
     ) => Effect.Effect<void>
 
     /**
-     * Unsafely interrupt a registered workflow, potentially ignoring
+     * Interrupts a registered workflow unsafely, potentially ignoring
      * compensation finalizers and orphaning child workflows.
      */
     readonly interruptUnsafe: (
@@ -220,9 +220,19 @@ export class WorkflowEngine extends Context.Service<
 >()("effect/workflow/WorkflowEngine") {}
 
 /**
- * Per-execution workflow service containing the execution ID, workflow
- * definition, long-lived scope, suspension state, interruption state, and
- * activity coordination state.
+ * Service that contains workflow runtime state for one execution.
+ *
+ * **When to use**
+ *
+ * Use to read or update workflow execution, suspension, interruption,
+ * lifetime, failure, and activity coordination state inside workflow engine
+ * internals.
+ *
+ * **Details**
+ *
+ * The service stores the execution ID, workflow definition, long-lived scope,
+ * suspension and interruption flags, the stored failure cause, and activity
+ * coordination state for a single workflow run.
  *
  * @category services
  * @since 4.0.0
@@ -551,9 +561,17 @@ const defaultRetrySchedule = Schedule.exponential(200, 1.5).pipe(
 )
 
 /**
- * A in-memory implementation of the WorkflowEngine. This is useful for testing
- * and local development, but is not suitable for production use as it does not
- * provide durability guarantees.
+ * Layer that provides an in-memory `WorkflowEngine`.
+ *
+ * **When to use**
+ *
+ * Use to run tests and local development workflows where durability is not
+ * needed.
+ *
+ * **Gotchas**
+ *
+ * This layer keeps state only in memory and is not suitable for production
+ * workflows that require durability.
  *
  * @category layers
  * @since 4.0.0

package/src/unstable/workflow/index.ts

@@ -5,201 +5,41 @@
 // @barrel: Auto-generated exports. Do not edit manually.
 
 /**
- * The `Activity` module defines named, schema-backed effects that run at the
- * side-effect boundary of a durable workflow. Activities are executed through a
- * `WorkflowEngine`, encode their success and failure values with the provided
- * schemas, and can be replayed from persisted results instead of rerunning the
- * underlying effect.
- *
- * Use activities for work that should not be embedded directly in workflow
- * control flow, such as calling external services, writing to databases,
- * enqueueing durable jobs, short sleeps delegated by `DurableClock`, or racing
- * multiple external operations with `raceAll`. Keep activity names and schemas
- * stable because engines use them, together with the workflow execution and
- * retry attempt, to identify stored results.
- *
- * Activities can be interrupted and retried, and workflow resumes may observe a
- * completed encoded result or run the activity again depending on what the
- * engine has persisted. Make external side effects idempotent, use
- * `idempotencyKey` for stable request keys derived from the workflow execution,
- * and include the current attempt only when each retry must address a distinct
- * external operation.
- *
  * @since 4.0.0
  */
 export * as Activity from "./Activity.ts"
 
 /**
- * Durable workflow clocks provide workflow-safe timers and sleep operations.
- *
- * Use this module when a workflow needs to pause until a timeout, reminder,
- * deadline, retry delay, or other scheduled wake-up. Short sleeps can run as
- * in-memory activities, while longer sleeps are scheduled with the workflow
- * engine and resumed through a durable deferred signal when the timer fires.
- *
- * Because workflows may be replayed, timer names and durations should be
- * deterministic and stable for a given workflow path. Avoid deriving them from
- * ambient wall-clock state, and give distinct sleeps distinct names so replayed
- * executions can be matched with the correct scheduled wake-up. Lower the
- * in-memory threshold when a delay must be handled by the workflow engine
- * rather than the current process.
- *
  * @since 4.0.0
  */
 export * as DurableClock from "./DurableClock.ts"
 
 /**
- * Durable deferreds are named workflow wait points whose result is stored by
- * the workflow engine as an encoded `Exit`. A workflow can `await` one and
- * suspend until an activity, worker, timer, or external callback completes it
- * with `done`, `succeed`, `fail`, or `failCause`.
- *
- * Use this module to coordinate work that finishes outside the current
- * workflow turn: durable races, queues that report worker results, timers,
- * human approvals, webhooks, and other callback-style integrations. Tokens
- * encode the workflow name, execution ID, and deferred name so completion can
- * be routed back to the correct workflow execution without keeping an
- * in-memory handle.
- *
- * Deferred names are part of persisted workflow state, so keep them stable
- * across replays and unique for each logical wait. Completion is persisted as
- * an `Exit` and decoded through the success and error schemas when awaited
- * again; changing schemas or reusing a name for a different result type can
- * make old completions fail to decode or resume the wrong wait. Complete a
- * deferred once, and use `withActivityAttempt` when an activity retry needs an
- * attempt-scoped completion name.
- *
  * @since 4.0.0
  */
 export * as DurableDeferred from "./DurableDeferred.ts"
 
 /**
- * Durable queues bridge workflow executions with persisted background workers.
- * A workflow calls `process` to enqueue a schema-encoded payload in a named
- * `PersistedQueue`, attach a durable deferred token, and suspend until a worker
- * records the handler's `Exit` back through that deferred.
- *
- * Use this module for workflow steps that should be delegated to independent
- * workers: long-running side effects, rate-limited or concurrency-limited
- * integrations, fan-out jobs, API calls, and other work that must survive
- * workflow suspension, process restarts, or handoff to another service.
- *
- * Queue names, payload schemas, result schemas, and idempotency keys become
- * persisted coordination state. Keep them deterministic and stable across
- * deployments; changing them is a persistence migration. Delivery follows the
- * underlying `PersistedQueue` semantics, so handlers should be idempotent and
- * prepared for retries, duplicate observations, and worker restarts.
- *
  * @since 4.0.0
  */
 export * as DurableQueue from "./DurableQueue.ts"
 
 /**
- * The `Workflow` module defines typed durable workflow descriptions and the
- * helpers used to execute them through a `WorkflowEngine`. A workflow combines
- * a stable name, a struct payload schema, success and error schemas, and an
- * idempotency key so callers can derive deterministic execution IDs, execute or
- * discard runs, poll results, interrupt or resume suspended executions, and
- * register handlers with `toLayer`.
- *
- * Workflows are intended for long-running business processes that coordinate
- * activities, durable deferreds, durable clocks, retries, and compensation.
- * Keep external side effects at activity boundaries so engine implementations
- * can safely persist, suspend, and resume execution state. Running activities
- * can delay workflow suspension until they finish or suspend, and compensation
- * registered with `withCompensation` only applies to top-level workflow
- * effects, not nested activities.
- *
- * When exposing workflows through `WorkflowProxy`, remember that proxy APIs are
- * derived from the workflow name and schemas. Discard execution returns the
- * `executionId` instead of the workflow result, resume requires the persisted
- * `executionId`, and idempotency keys must remain stable for the same logical
- * request.
- *
  * @since 4.0.0
  */
 export * as Workflow from "./Workflow.ts"
 
 /**
- * Workflow engine service definitions and the default in-memory engine used to
- * run durable workflows.
- *
- * This module is the runtime boundary for `Workflow` values. It registers
- * workflow handlers, starts or polls executions by stable execution ID, links
- * child workflow interruption to parents, and coordinates activities, durable
- * deferred values, and durable clocks. Library users usually depend on the
- * typed `WorkflowEngine` service, while persistence backends implement the
- * lower-level `Encoded` contract and pass it to `makeUnsafe`.
- *
- * Durable execution requires engine implementations to make retries and resumes
- * idempotent. Reusing an execution ID should observe the existing execution
- * instead of starting duplicate work, suspended executions are retried according
- * to `suspendedRetrySchedule`, and concurrent deferred completions or clock
- * wake-ups must be serialized by the backend. Use `interrupt` when
- * compensation and child workflow cleanup matter; `interruptUnsafe` can stop
- * work more directly but may bypass those guarantees. The provided
- * `layerMemory` is useful for tests and local development, but it keeps state
- * in process memory and does not provide production durability.
- *
  * @since 4.0.0
  */
 export * as WorkflowEngine from "./WorkflowEngine.ts"
 
 /**
- * The `WorkflowProxy` module derives transport contracts from durable
- * `Workflow` definitions.
- *
- * Use it when workflows should be invoked through RPC or HTTP instead of by
- * importing the workflow implementation directly. `toRpcGroup` creates the
- * `RpcGroup` that RPC clients and servers share, while `toHttpApiGroup` creates
- * the `HttpApiGroup` that can be mounted in an HTTP API. Each workflow expands
- * into execute, discard, and resume operations so external callers can start a
- * workflow, start it through the discard path, or resume a suspended execution
- * by `executionId`.
- *
- * The generated names and schemas come from the workflow definitions, so keep
- * workflow names stable and pass the same workflow list to the matching
- * `WorkflowProxyServer` layer. RPC proxies may be prefixed, but the same prefix
- * must be used by the server handlers. HTTP endpoint paths are derived from the
- * lower-cased workflow name. Preserve workflow arrays as const tuples when you
- * want the generated RPC and HTTP API types to retain each workflow's literal
- * name, payload, success, and error types.
- *
- * Discard and resume are control operations rather than ordinary workflow
- * result reads. The discard proxy does not expose the normal success or error
- * schemas, and resume expects the persisted `executionId`; it cannot recreate
- * that boundary value from the original payload.
- *
  * @since 4.0.0
  */
 export * as WorkflowProxy from "./WorkflowProxy.ts"
 
 /**
- * The `WorkflowProxyServer` module provides server-side layers for exposing
- * workflows through the proxy APIs generated by `WorkflowProxy`. It connects
- * HTTP API endpoints or RPC handlers to the supplied workflow definitions,
- * routing execute, discard, and resume requests to the corresponding workflow
- * operation while keeping the `WorkflowEngine` and workflow implementation
- * services on the server side.
- *
- * **Common tasks**
- *
- * - Serve a workflow proxy over an HTTP API group with {@link layerHttpApi}
- * - Serve the RPC group produced by `WorkflowProxy.toRpcGroup` with
- *   {@link layerRpcHandlers}
- * - Expose durable workflow starts and explicit resume operations to clients
- *   without exposing the workflow implementation itself
- *
- * **Gotchas**
- *
- * - The workflows passed to these layers must match the group produced by
- *   `WorkflowProxy`; RPC prefixes must be the same on both sides
- * - Discard handlers use the workflow discard execution path, so callers should
- *   not rely on receiving the normal workflow success or error value
- * - Resume handlers expect a payload with the persisted `executionId`; clients
- *   must preserve that boundary value because it is not recomputed from the
- *   original workflow payload
- *
  * @since 4.0.0
  */
 export * as WorkflowProxyServer from "./WorkflowProxyServer.ts"