@workflow/core 4.3.1 → 4.5.0

package/dist/classify-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"classify-error.d.ts","sourceRoot":"","sources":["../src/classify-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,YAAY,EAIjB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAqB1B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAe5E;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAmB3D"}
+{"version":3,"file":"classify-error.d.ts","sourceRoot":"","sources":["../src/classify-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,YAAY,EAKjB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AA0B1B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAe5E;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAmB3D"}

package/dist/classify-error.js

@@ -1,4 +1,4 @@
-import { CorruptedEventLogError, ReplayDivergenceError, RUN_ERROR_CODES, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRuntimeError, WorkflowWorldError, } from '@workflow/errors';
+import { CorruptedEventLogError, ReplayDivergenceError, RUN_ERROR_CODES, RuntimeDecryptionError, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRuntimeError, WorkflowWorldError, } from '@workflow/errors';
 const WORLD_CONTRACT_ERROR_CODES = new Set([
     'PARSE_ERROR',
     'SCHEMA_VALIDATION',
@@ -15,6 +15,11 @@ const RUNTIME_ERROR_CHECKS = [
     WorkflowRuntimeError.is,
     StepNotRegisteredError.is,
     WorkflowNotRegisteredError.is,
+    // SDK-level encryption failures (most notably AES-GCM auth-tag
+    // mismatches surfacing as a native `OperationError` from
+    // `AESCipherJob.onDone`) are wrapped in `RuntimeDecryptionError` at
+    // the encryption module boundary.
+    RuntimeDecryptionError.is,
 ];
 /**
  * Classify an error that caused a workflow run to fail.
@@ -62,4 +67,4 @@ export function classifyRunError(err) {
     }
     return RUN_ERROR_CODES.USER_ERROR;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/create-hook.d.ts

@@ -24,6 +24,45 @@ export interface Hook<T = any> extends AsyncIterable<T>, Thenable<T> {
      * The token used to identify this hook.
      */
     token: string;
+    /**
+     * Returns a promise that resolves with `{ runId }` identifying the
+     * conflicting run if another active hook already owns this hook's
+     * token, or `null` once the hook has been registered and is ready to
+     * receive payloads.
+     *
+     * Calling `createHook()` alone does not register the hook — registration
+     * only happens when the workflow suspends. Awaiting `getConflict()`
+     * suspends the workflow to commit the hook registration, so it can be
+     * used to claim the token (and detect token conflicts early) without
+     * waiting for payload data.
+     *
+     * When a conflict is detected, the resolved `runId` identifies the run
+     * that currently owns the token. The workflow can decide how to handle
+     * the duplicate in code: return or log `conflict.runId`, or act on the
+     * owner — inspect its status, await its result, or cancel it — by
+     * passing `conflict.runId` to `getRun()` inside a step.
+     *
+     * Note that awaiting the hook's payload (`await hook`) when the token is
+     * already owned by another active hook still rejects with
+     * `HookConflictError`. In the rare case where the conflicting run cannot
+     * be identified (a `hook_conflict` event persisted by an old world that
+     * did not record the owning run's ID), `getConflict()` also rejects with
+     * `HookConflictError` rather than resolving with an incomplete value.
+     *
+     * @example
+     * ```ts
+     * using hook = createHook({ token: `order:${orderId}` });
+     * const conflict = await hook.getConflict();
+     * if (conflict) {
+     *   // another run already owns this token
+     *   return { dedupedTo: conflict.runId };
+     * }
+     * // token is now claimed, without waiting for payload data
+     * ```
+     */
+    getConflict(): Promise<{
+        runId: string;
+    } | null>;
     /**
      * Disposes the hook, releasing its token for reuse by other workflows.
      *

package/dist/create-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-hook.d.ts","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;GAEG;AACH,UAAU,QAAQ,CAAC,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IAClD,WAAW,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;;;;;;;;;;;OAYG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,SAAS,OAAO,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;IACzD;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC;IAChD;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAIlE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,GAAG;IAAE,WAAW,EAAE,QAAQ,CAAA;CAAE,GAClD,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC"}
+{"version":3,"file":"create-hook.d.ts","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;GAEG;AACH,UAAU,QAAQ,CAAC,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IAClD,WAAW,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,WAAW,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IAEjD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;;;;;;;;;;;OAYG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,SAAS,OAAO,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;IACzD;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC;IAChD;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAIlE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,GAAG;IAAE,WAAW,EAAE,QAAQ,CAAA;CAAE,GAClD,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC"}

package/dist/create-hook.js

@@ -29,4 +29,4 @@ export function createWebhook(
 options) {
     throw new Error('`createWebhook()` can only be called inside a workflow function');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-hook.js","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AA2JA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oDAAoD;AACpD,MAAM,UAAU,UAAU,CAAU,OAAqB;IACvD,MAAM,IAAI,KAAK,CACb,8DAA8D,CAC/D,CAAC;AACJ,CAAC;AAaD,MAAM,UAAU,aAAa;AAC3B,oDAAoD;AACpD,OAAwB;IAExB,MAAM,IAAI,KAAK,CACb,iEAAiE,CAClE,CAAC;AACJ,CAAC","sourcesContent":["import type { Serializable } from './schemas.js';\n\n/**\n * An object that can be awaited to receive a value.\n */\ninterface Thenable<T> {\n  then: Promise<T>['then'];\n}\n\n/**\n * A `Request` that can be responded to within a workflow\n * step function by calling the `respondWith()` method.\n */\nexport interface RequestWithResponse extends Request {\n  respondWith: (response: Response) => Promise<void>;\n}\n\n/**\n * A hook that can be awaited and/or iterated over to receive\n * a value within a workflow from an external system.\n *\n * Hooks implement the TC39 Explicit Resource Management proposal,\n * allowing them to be used with the `using` keyword for automatic disposal.\n */\nexport interface Hook<T = any> extends AsyncIterable<T>, Thenable<T> {\n  /**\n   * The token used to identify this hook.\n   */\n  token: string;\n\n  /**\n   * Disposes the hook, releasing its token for reuse by other workflows.\n   *\n   * After calling `dispose()`, the hook will no longer receive any events.\n   * This is useful when you want to explicitly release a hook token before\n   * the workflow completes, allowing another workflow to register a hook\n   * with the same token.\n   *\n   * @example\n   * ```ts\n   * const hook = createHook<{ message: string }>({ token: 'my-token' });\n   *\n   * for await (const payload of hook) {\n   *   if (payload.message === 'done') {\n   *     hook.dispose(); // Release the token early\n   *     break;\n   *   }\n   * }\n   * ```\n   */\n  dispose(): void;\n\n  /**\n   * Implements the TC39 Explicit Resource Management proposal.\n   * Called automatically when using the `using` keyword.\n   *\n   * @example\n   * ```ts\n   * {\n   *   using hook = createHook<{ message: string }>({ token: 'my-token' });\n   *   const payload = await hook;\n   *   // hook is automatically disposed when the block exits\n   * }\n   * ```\n   */\n  [Symbol.dispose](): void;\n}\n\n/**\n * A webhook that can be used to suspend and resume the workflow run\n * upon receiving an HTTP request to the specified URL.\n *\n * @see {@link createWebhook}\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Request\n */\nexport interface Webhook<T extends Request> extends Hook<T> {\n  /**\n   * The URL that external systems can call to send data to the workflow.\n   */\n  url: string;\n}\n\nexport interface HookOptions {\n  /**\n   * Unique token that is used to associate with the hook.\n   *\n   * When specifying an explicit token, the token should be constructed\n   * with information that the dispatching side can reliably reconstruct\n   * the token with the information it has available.\n   *\n   * Deterministic tokens are intended for use with `createHook()` and\n   * server-side `resumeHook()` only. For webhooks (`createWebhook()`),\n   * tokens are always randomly generated to prevent unauthorized access\n   * to the public webhook endpoint.\n   *\n   * If not provided, a randomly generated token will be assigned.\n   *\n   * @example\n   *\n   * ```ts\n   * // Explicit token for a Slack bot (one workflow run per channel)\n   * const hook = createHook<SlackMessage>({\n   *   token: `slack_webhook:${channelId}`,\n   * });\n   * ```\n   */\n  token?: string;\n\n  /**\n   * Additional user-defined data to include with the hook payload.\n   *\n   * @example\n   *\n   * ```ts\n   * const hook = createHook<{ name: string }>({\n   *   metadata: {\n   *     type: \"cat\",\n   *     color: \"orange\",\n   *   },\n   * });\n   * ```\n   */\n  metadata?: Serializable;\n\n  /**\n   * Whether this hook can be resumed via the public webhook endpoint.\n   *\n   * When `true`, the hook can be triggered by sending an HTTP request to the\n   * public `/.well-known/workflow/v1/webhook/{token}` URL. This is automatically\n   * set when using `createWebhook()`.\n   *\n   * When `false` (the default), the hook can only be resumed server-side\n   * via `resumeHook()`.\n   *\n   * @default false\n   */\n  isWebhook?: boolean;\n}\n\nexport interface WebhookOptions\n  extends Omit<HookOptions, 'token' | 'isWebhook'> {\n  /**\n   * If set to a `Response` object, the webhook will automatically\n   * respond with the specified response.\n   *\n   * If set to `\"manual\"`, each individual request will need to\n   * be responded to manually from within the workflow by calling the\n   * `respondWith()` method.\n   *\n   * If not set then the webhook will automatically respond with\n   * a `202 Accepted` response.\n   */\n  respondWith?: Response | 'manual';\n}\n\n/**\n * Creates a {@link Hook} that can be used to suspend and resume the workflow run with a payload.\n *\n * Hooks allow external systems to send arbitrary serializable data into a workflow.\n *\n * @param options - Configuration options for the hook.\n * @returns A `Hook` that can be awaited to receive one or more payloads.\n *\n * @example\n *\n * ```ts\n * export async function workflowWithHook() {\n *   \"use workflow\";\n *\n *   const hook = createHook<{ message: string }>();\n *   console.log('Hook token:', hook.token);\n *\n *   const payload = await hook;\n *   console.log('Received:', payload.message);\n * }\n * ```\n */\n// @ts-expect-error `options` is here for types/docs\nexport function createHook<T = any>(options?: HookOptions): Hook<T> {\n  throw new Error(\n    '`createHook()` can only be called inside a workflow function'\n  );\n}\n\n/**\n * Creates a {@link Webhook} that can be used to suspend and resume the workflow\n * run upon receiving an HTTP request to the specified URL.\n *\n * Webhooks will result in a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request} object\n * that can be interacted with in workflow functions.\n */\nexport function createWebhook(\n  options: WebhookOptions & { respondWith: 'manual' }\n): Webhook<RequestWithResponse>;\nexport function createWebhook(options?: WebhookOptions): Webhook<Request>;\nexport function createWebhook(\n  // @ts-expect-error `options` is here for types/docs\n  options?: WebhookOptions\n): Webhook<Request> | Webhook<RequestWithResponse> {\n  throw new Error(\n    '`createWebhook()` can only be called inside a workflow function'\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-hook.js","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AAiMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oDAAoD;AACpD,MAAM,UAAU,UAAU,CAAU,OAAqB;IACvD,MAAM,IAAI,KAAK,CACb,8DAA8D,CAC/D,CAAC;AACJ,CAAC;AAaD,MAAM,UAAU,aAAa;AAC3B,oDAAoD;AACpD,OAAwB;IAExB,MAAM,IAAI,KAAK,CACb,iEAAiE,CAClE,CAAC;AACJ,CAAC","sourcesContent":["import type { Serializable } from './schemas.js';\n\n/**\n * An object that can be awaited to receive a value.\n */\ninterface Thenable<T> {\n  then: Promise<T>['then'];\n}\n\n/**\n * A `Request` that can be responded to within a workflow\n * step function by calling the `respondWith()` method.\n */\nexport interface RequestWithResponse extends Request {\n  respondWith: (response: Response) => Promise<void>;\n}\n\n/**\n * A hook that can be awaited and/or iterated over to receive\n * a value within a workflow from an external system.\n *\n * Hooks implement the TC39 Explicit Resource Management proposal,\n * allowing them to be used with the `using` keyword for automatic disposal.\n */\nexport interface Hook<T = any> extends AsyncIterable<T>, Thenable<T> {\n  /**\n   * The token used to identify this hook.\n   */\n  token: string;\n\n  /**\n   * Returns a promise that resolves with `{ runId }` identifying the\n   * conflicting run if another active hook already owns this hook's\n   * token, or `null` once the hook has been registered and is ready to\n   * receive payloads.\n   *\n   * Calling `createHook()` alone does not register the hook — registration\n   * only happens when the workflow suspends. Awaiting `getConflict()`\n   * suspends the workflow to commit the hook registration, so it can be\n   * used to claim the token (and detect token conflicts early) without\n   * waiting for payload data.\n   *\n   * When a conflict is detected, the resolved `runId` identifies the run\n   * that currently owns the token. The workflow can decide how to handle\n   * the duplicate in code: return or log `conflict.runId`, or act on the\n   * owner — inspect its status, await its result, or cancel it — by\n   * passing `conflict.runId` to `getRun()` inside a step.\n   *\n   * Note that awaiting the hook's payload (`await hook`) when the token is\n   * already owned by another active hook still rejects with\n   * `HookConflictError`. In the rare case where the conflicting run cannot\n   * be identified (a `hook_conflict` event persisted by an old world that\n   * did not record the owning run's ID), `getConflict()` also rejects with\n   * `HookConflictError` rather than resolving with an incomplete value.\n   *\n   * @example\n   * ```ts\n   * using hook = createHook({ token: `order:${orderId}` });\n   * const conflict = await hook.getConflict();\n   * if (conflict) {\n   *   // another run already owns this token\n   *   return { dedupedTo: conflict.runId };\n   * }\n   * // token is now claimed, without waiting for payload data\n   * ```\n   */\n  getConflict(): Promise<{ runId: string } | null>;\n\n  /**\n   * Disposes the hook, releasing its token for reuse by other workflows.\n   *\n   * After calling `dispose()`, the hook will no longer receive any events.\n   * This is useful when you want to explicitly release a hook token before\n   * the workflow completes, allowing another workflow to register a hook\n   * with the same token.\n   *\n   * @example\n   * ```ts\n   * const hook = createHook<{ message: string }>({ token: 'my-token' });\n   *\n   * for await (const payload of hook) {\n   *   if (payload.message === 'done') {\n   *     hook.dispose(); // Release the token early\n   *     break;\n   *   }\n   * }\n   * ```\n   */\n  dispose(): void;\n\n  /**\n   * Implements the TC39 Explicit Resource Management proposal.\n   * Called automatically when using the `using` keyword.\n   *\n   * @example\n   * ```ts\n   * {\n   *   using hook = createHook<{ message: string }>({ token: 'my-token' });\n   *   const payload = await hook;\n   *   // hook is automatically disposed when the block exits\n   * }\n   * ```\n   */\n  [Symbol.dispose](): void;\n}\n\n/**\n * A webhook that can be used to suspend and resume the workflow run\n * upon receiving an HTTP request to the specified URL.\n *\n * @see {@link createWebhook}\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Request\n */\nexport interface Webhook<T extends Request> extends Hook<T> {\n  /**\n   * The URL that external systems can call to send data to the workflow.\n   */\n  url: string;\n}\n\nexport interface HookOptions {\n  /**\n   * Unique token that is used to associate with the hook.\n   *\n   * When specifying an explicit token, the token should be constructed\n   * with information that the dispatching side can reliably reconstruct\n   * the token with the information it has available.\n   *\n   * Deterministic tokens are intended for use with `createHook()` and\n   * server-side `resumeHook()` only. For webhooks (`createWebhook()`),\n   * tokens are always randomly generated to prevent unauthorized access\n   * to the public webhook endpoint.\n   *\n   * If not provided, a randomly generated token will be assigned.\n   *\n   * @example\n   *\n   * ```ts\n   * // Explicit token for a Slack bot (one workflow run per channel)\n   * const hook = createHook<SlackMessage>({\n   *   token: `slack_webhook:${channelId}`,\n   * });\n   * ```\n   */\n  token?: string;\n\n  /**\n   * Additional user-defined data to include with the hook payload.\n   *\n   * @example\n   *\n   * ```ts\n   * const hook = createHook<{ name: string }>({\n   *   metadata: {\n   *     type: \"cat\",\n   *     color: \"orange\",\n   *   },\n   * });\n   * ```\n   */\n  metadata?: Serializable;\n\n  /**\n   * Whether this hook can be resumed via the public webhook endpoint.\n   *\n   * When `true`, the hook can be triggered by sending an HTTP request to the\n   * public `/.well-known/workflow/v1/webhook/{token}` URL. This is automatically\n   * set when using `createWebhook()`.\n   *\n   * When `false` (the default), the hook can only be resumed server-side\n   * via `resumeHook()`.\n   *\n   * @default false\n   */\n  isWebhook?: boolean;\n}\n\nexport interface WebhookOptions\n  extends Omit<HookOptions, 'token' | 'isWebhook'> {\n  /**\n   * If set to a `Response` object, the webhook will automatically\n   * respond with the specified response.\n   *\n   * If set to `\"manual\"`, each individual request will need to\n   * be responded to manually from within the workflow by calling the\n   * `respondWith()` method.\n   *\n   * If not set then the webhook will automatically respond with\n   * a `202 Accepted` response.\n   */\n  respondWith?: Response | 'manual';\n}\n\n/**\n * Creates a {@link Hook} that can be used to suspend and resume the workflow run with a payload.\n *\n * Hooks allow external systems to send arbitrary serializable data into a workflow.\n *\n * @param options - Configuration options for the hook.\n * @returns A `Hook` that can be awaited to receive one or more payloads.\n *\n * @example\n *\n * ```ts\n * export async function workflowWithHook() {\n *   \"use workflow\";\n *\n *   const hook = createHook<{ message: string }>();\n *   console.log('Hook token:', hook.token);\n *\n *   const payload = await hook;\n *   console.log('Received:', payload.message);\n * }\n * ```\n */\n// @ts-expect-error `options` is here for types/docs\nexport function createHook<T = any>(options?: HookOptions): Hook<T> {\n  throw new Error(\n    '`createHook()` can only be called inside a workflow function'\n  );\n}\n\n/**\n * Creates a {@link Webhook} that can be used to suspend and resume the workflow\n * run upon receiving an HTTP request to the specified URL.\n *\n * Webhooks will result in a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request} object\n * that can be interacted with in workflow functions.\n */\nexport function createWebhook(\n  options: WebhookOptions & { respondWith: 'manual' }\n): Webhook<RequestWithResponse>;\nexport function createWebhook(options?: WebhookOptions): Webhook<Request>;\nexport function createWebhook(\n  // @ts-expect-error `options` is here for types/docs\n  options?: WebhookOptions\n): Webhook<Request> | Webhook<RequestWithResponse> {\n  throw new Error(\n    '`createWebhook()` can only be called inside a workflow function'\n  );\n}\n"]}

package/dist/encryption.d.ts

@@ -43,6 +43,21 @@ export declare function encrypt(key: CryptoKey, data: Uint8Array): Promise<Uint8
 /**
  * Decrypt data using AES-256-GCM.
  *
+ * Any failure inside the Web Crypto layer — most commonly an
+ * `OperationError: The operation failed for an operation-specific reason`
+ * raised by `AESCipherJob.onDone` when the GCM authentication tag does
+ * not verify — is rewrapped as {@link RuntimeDecryptionError}. The
+ * wrapped error carries the original DOMException as `cause`, plus a
+ * small diagnostic context (`operation`, input `byteLength`) to help
+ * disambiguate ciphertext corruption from key mismatch from truncated
+ * transport reads.
+ *
+ * Note: `data` is the raw AES payload (`[nonce][ciphertext + tag]`), not a
+ * format-prefixed envelope — callers strip the `encr` marker via
+ * `decodeFormatPrefix()` before reaching this function. The outer
+ * envelope's format prefix is therefore attached by the serialization
+ * layer (`serialization/encryption.ts`), which is the layer that has it.
+ *
  * @param key - CryptoKey from `importKey()`
  * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`
  * @returns Decrypted plaintext

package/dist/encryption.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,MAAM,SAAS,GAAG,OAAO,aAAa,EAAE,SAAS,CAAC,SAAS,CAAC;AAMlE;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,UAAU,EACf,MAAM,GAAE,aAAa,CAAC,SAAS,GAAG,SAAS,CAA0B,iDAiBtE;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAWrB;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAerB"}
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,MAAM,SAAS,GAAG,OAAO,aAAa,EAAE,SAAS,CAAC,SAAS,CAAC;AAMlE;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,UAAU,EACf,MAAM,GAAE,aAAa,CAAC,SAAS,GAAG,SAAS,CAA0B,iDAiBtE;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CA4BrB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CA0CrB"}

package/dist/encryption.js

@@ -1,20 +1,4 @@
-/**
- * Browser-compatible AES-256-GCM encryption module.
- *
- * Uses the Web Crypto API (`globalThis.crypto.subtle`) which works in
- * both modern browsers and Node.js 20+. This module is intentionally
- * free of Node.js-specific imports so it can be bundled for the browser.
- *
- * The World interface (`getEncryptionKeyForRun`) returns a raw 32-byte
- * AES-256 key. Callers should use `importKey()` once to convert it to a
- * `CryptoKey`, then pass that to `encrypt()`/`decrypt()` for all
- * operations within the same run. This avoids repeated `importKey()`
- * calls on every encrypt/decrypt invocation.
- *
- * Wire format: `[nonce (12 bytes)][ciphertext + auth tag]`
- * The `encr` format prefix is NOT part of this module — it's added/stripped
- * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.
- */
+import { RuntimeDecryptionError } from '@workflow/errors';
 const NONCE_LENGTH = 12;
 const TAG_LENGTH = 128; // bits
 const KEY_LENGTH = 32; // bytes (AES-256)
@@ -52,7 +36,22 @@ export async function importKey(raw, usages = ['encrypt', 'decrypt']) {
  */
 export async function encrypt(key, data) {
     const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));
-    const ciphertext = await globalThis.crypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH }, key, data);
+    let ciphertext;
+    try {
+        ciphertext = await globalThis.crypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH }, key, data);
+    }
+    catch (cause) {
+        // Re-wrap any Web Crypto failure (DOMException etc.) as a
+        // RuntimeDecryptionError. Failures here are rare — they happen e.g.
+        // when a CryptoKey was imported with `usages: ['decrypt']` only.
+        throw new RuntimeDecryptionError(`AES-256-GCM encryption failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
+            cause,
+            context: {
+                operation: 'encrypt',
+                byteLength: data.byteLength,
+            },
+        });
+    }
     const result = new Uint8Array(NONCE_LENGTH + ciphertext.byteLength);
     result.set(nonce, 0);
     result.set(new Uint8Array(ciphertext), NONCE_LENGTH);
@@ -61,6 +60,21 @@ export async function encrypt(key, data) {
 /**
  * Decrypt data using AES-256-GCM.
  *
+ * Any failure inside the Web Crypto layer — most commonly an
+ * `OperationError: The operation failed for an operation-specific reason`
+ * raised by `AESCipherJob.onDone` when the GCM authentication tag does
+ * not verify — is rewrapped as {@link RuntimeDecryptionError}. The
+ * wrapped error carries the original DOMException as `cause`, plus a
+ * small diagnostic context (`operation`, input `byteLength`) to help
+ * disambiguate ciphertext corruption from key mismatch from truncated
+ * transport reads.
+ *
+ * Note: `data` is the raw AES payload (`[nonce][ciphertext + tag]`), not a
+ * format-prefixed envelope — callers strip the `encr` marker via
+ * `decodeFormatPrefix()` before reaching this function. The outer
+ * envelope's format prefix is therefore attached by the serialization
+ * layer (`serialization/encryption.ts`), which is the layer that has it.
+ *
  * @param key - CryptoKey from `importKey()`
  * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`
  * @returns Decrypted plaintext
@@ -68,11 +82,35 @@ export async function encrypt(key, data) {
 export async function decrypt(key, data) {
     const minLength = NONCE_LENGTH + TAG_LENGTH / 8; // nonce + auth tag
     if (data.byteLength < minLength) {
-        throw new Error(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`);
+        throw new RuntimeDecryptionError(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`, {
+            context: {
+                operation: 'decrypt',
+                byteLength: data.byteLength,
+            },
+        });
     }
     const nonce = data.subarray(0, NONCE_LENGTH);
     const ciphertext = data.subarray(NONCE_LENGTH);
-    const plaintext = await globalThis.crypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH }, key, ciphertext);
+    let plaintext;
+    try {
+        plaintext = await globalThis.crypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH }, key, ciphertext);
+    }
+    catch (cause) {
+        // The most common shape we see in the wild is a DOMException with
+        // `name: 'OperationError'` and message "The operation failed for
+        // an operation-specific reason" — this is what Web Crypto throws
+        // when the GCM auth tag does not verify. Re-throw as
+        // RuntimeDecryptionError, attaching diagnostic context (byte length)
+        // that the bare DOMException lacks.
+        const causeMsg = cause instanceof Error ? cause.message : String(cause);
+        throw new RuntimeDecryptionError(`AES-256-GCM decryption failed: ${causeMsg}`, {
+            cause,
+            context: {
+                operation: 'decrypt',
+                byteLength: data.byteLength,
+            },
+        });
+    }
     return new Uint8Array(plaintext);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.js","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"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","sourcesContent":["import { RuntimeDecryptionError } from '@workflow/errors';\n\n/**\n * Browser-compatible AES-256-GCM encryption module.\n *\n * Uses the Web Crypto API (`globalThis.crypto.subtle`) which works in\n * both modern browsers and Node.js 20+. This module is intentionally\n * free of Node.js-specific imports so it can be bundled for the browser.\n *\n * The World interface (`getEncryptionKeyForRun`) returns a raw 32-byte\n * AES-256 key. Callers should use `importKey()` once to convert it to a\n * `CryptoKey`, then pass that to `encrypt()`/`decrypt()` for all\n * operations within the same run. This avoids repeated `importKey()`\n * calls on every encrypt/decrypt invocation.\n *\n * Wire format: `[nonce (12 bytes)][ciphertext + auth tag]`\n * The `encr` format prefix is NOT part of this module — it's added/stripped\n * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.\n */\n\n// CryptoKey is a global type in browsers and Node.js 20+, but TypeScript's\n// `es2022` lib doesn't include it. Re-export it from the node:crypto types\n// so consumers can reference it without adding `dom` lib.\nexport type CryptoKey = import('node:crypto').webcrypto.CryptoKey;\n\nconst NONCE_LENGTH = 12;\nconst TAG_LENGTH = 128; // bits\nconst KEY_LENGTH = 32; // bytes (AES-256)\n\n/**\n * Import a raw AES-256 key as a `CryptoKey` for use with `encrypt()`/`decrypt()`.\n *\n * Callers should call this once per run (after `getEncryptionKeyForRun()`)\n * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.\n *\n * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios\n * where the caller should not be able to perform the inverse operation\n * with the key — for example a child workflow writing into a parent\n * run's forwarded WritableStream only needs to encrypt, never decrypt.\n *\n * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)\n * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.\n * @returns CryptoKey ready for AES-GCM operations\n */\nexport async function importKey(\n  raw: Uint8Array,\n  usages: ReadonlyArray<'encrypt' | 'decrypt'> = ['encrypt', 'decrypt']\n) {\n  if (raw.byteLength !== KEY_LENGTH) {\n    throw new Error(\n      `Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`\n    );\n  }\n  return globalThis.crypto.subtle.importKey(\n    'raw',\n    raw,\n    'AES-GCM',\n    false,\n    // `KeyUsage` is a DOM-lib type that's not in scope under `es2022`.\n    // The `ReadonlyArray<'encrypt' | 'decrypt'>` parameter type matches\n    // a strict subset of `KeyUsage[]`, so this cast is sound.\n    usages as ('encrypt' | 'decrypt')[]\n  );\n}\n\n/**\n * Encrypt data using AES-256-GCM.\n *\n * @param key - CryptoKey from `importKey()`\n * @param data - Plaintext to encrypt\n * @returns `[nonce (12 bytes)][ciphertext + GCM auth tag]`\n */\nexport async function encrypt(\n  key: CryptoKey,\n  data: Uint8Array\n): Promise<Uint8Array> {\n  const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));\n  let ciphertext: ArrayBuffer;\n  try {\n    ciphertext = await globalThis.crypto.subtle.encrypt(\n      { name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH },\n      key,\n      data\n    );\n  } catch (cause) {\n    // Re-wrap any Web Crypto failure (DOMException etc.) as a\n    // RuntimeDecryptionError. Failures here are rare — they happen e.g.\n    // when a CryptoKey was imported with `usages: ['decrypt']` only.\n    throw new RuntimeDecryptionError(\n      `AES-256-GCM encryption failed: ${cause instanceof Error ? cause.message : String(cause)}`,\n      {\n        cause,\n        context: {\n          operation: 'encrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  const result = new Uint8Array(NONCE_LENGTH + ciphertext.byteLength);\n  result.set(nonce, 0);\n  result.set(new Uint8Array(ciphertext), NONCE_LENGTH);\n  return result;\n}\n\n/**\n * Decrypt data using AES-256-GCM.\n *\n * Any failure inside the Web Crypto layer — most commonly an\n * `OperationError: The operation failed for an operation-specific reason`\n * raised by `AESCipherJob.onDone` when the GCM authentication tag does\n * not verify — is rewrapped as {@link RuntimeDecryptionError}. The\n * wrapped error carries the original DOMException as `cause`, plus a\n * small diagnostic context (`operation`, input `byteLength`) to help\n * disambiguate ciphertext corruption from key mismatch from truncated\n * transport reads.\n *\n * Note: `data` is the raw AES payload (`[nonce][ciphertext + tag]`), not a\n * format-prefixed envelope — callers strip the `encr` marker via\n * `decodeFormatPrefix()` before reaching this function. The outer\n * envelope's format prefix is therefore attached by the serialization\n * layer (`serialization/encryption.ts`), which is the layer that has it.\n *\n * @param key - CryptoKey from `importKey()`\n * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`\n * @returns Decrypted plaintext\n */\nexport async function decrypt(\n  key: CryptoKey,\n  data: Uint8Array\n): Promise<Uint8Array> {\n  const minLength = NONCE_LENGTH + TAG_LENGTH / 8; // nonce + auth tag\n  if (data.byteLength < minLength) {\n    throw new RuntimeDecryptionError(\n      `Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`,\n      {\n        context: {\n          operation: 'decrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  const nonce = data.subarray(0, NONCE_LENGTH);\n  const ciphertext = data.subarray(NONCE_LENGTH);\n  let plaintext: ArrayBuffer;\n  try {\n    plaintext = await globalThis.crypto.subtle.decrypt(\n      { name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH },\n      key,\n      ciphertext\n    );\n  } catch (cause) {\n    // The most common shape we see in the wild is a DOMException with\n    // `name: 'OperationError'` and message \"The operation failed for\n    // an operation-specific reason\" — this is what Web Crypto throws\n    // when the GCM auth tag does not verify. Re-throw as\n    // RuntimeDecryptionError, attaching diagnostic context (byte length)\n    // that the bare DOMException lacks.\n    const causeMsg = cause instanceof Error ? cause.message : String(cause);\n    throw new RuntimeDecryptionError(\n      `AES-256-GCM decryption failed: ${causeMsg}`,\n      {\n        cause,\n        context: {\n          operation: 'decrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  return new Uint8Array(plaintext);\n}\n"]}

package/dist/global.d.ts

@@ -14,6 +14,8 @@ export interface HookInvocationQueueItem {
     token: string;
     metadata?: Serializable;
     hasCreatedEvent?: boolean;
+    /** Whether the workflow is awaiting `hook.getConflict()` for this hook */
+    hasConflictAwaiter?: boolean;
     disposed?: boolean;
     isWebhook?: boolean;
 }

package/dist/global.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,IAAI,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,MAAM,SAAS,GACjB,uBAAuB,GACvB,uBAAuB,GACvB,uBAAuB,CAAC;AAE5B;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;gBAEd,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,UAAU;IAwEzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB;CAGvD;AAED,wBAAgB,OAAO,IAAI,KAAK,CAE/B"}
+{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,0EAA0E;IAC1E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,IAAI,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,MAAM,SAAS,GACjB,uBAAuB,GACvB,uBAAuB,GACvB,uBAAuB,CAAC;AAE5B;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;gBAEd,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,UAAU;IAwEzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB;CAGvD;AAED,wBAAgB,OAAO,IAAI,KAAK,CAE/B"}

package/dist/global.js

@@ -92,4 +92,4 @@ export class WorkflowSuspension extends Error {
 export function ENOTSUP() {
     throw new Error('Not supported in workflow functions');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global.js","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"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","sourcesContent":["import { pluralize } from '@workflow/utils';\nimport type { Serializable } from './schemas.js';\n\nexport interface StepInvocationQueueItem {\n  type: 'step';\n  correlationId: string;\n  stepName: string;\n  args: Serializable[];\n  closureVars?: Record<string, Serializable>;\n  thisVal?: Serializable;\n  hasCreatedEvent?: boolean;\n}\n\nexport interface HookInvocationQueueItem {\n  type: 'hook';\n  correlationId: string;\n  token: string;\n  metadata?: Serializable;\n  hasCreatedEvent?: boolean;\n  disposed?: boolean;\n  isWebhook?: boolean;\n}\n\nexport interface WaitInvocationQueueItem {\n  type: 'wait';\n  correlationId: string;\n  resumeAt: Date;\n  hasCreatedEvent?: boolean;\n}\n\nexport type QueueItem =\n  | StepInvocationQueueItem\n  | HookInvocationQueueItem\n  | WaitInvocationQueueItem;\n\n/**\n * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do\n * not yet have corresponding entries in the event log. The workflow\n * dispatcher will catch this error and push the operations\n * onto the queue.\n */\nexport class WorkflowSuspension extends Error {\n  steps: QueueItem[];\n  globalThis: typeof globalThis;\n  stepCount: number;\n  hookCount: number;\n  waitCount: number;\n  hookDisposedCount: number;\n\n  constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis) {\n    // Convert Map to array for iteration and storage\n    const steps = [...stepsInput.values()];\n\n    // Single-pass counting for efficiency\n    let stepCount = 0;\n    let hookCount = 0;\n    let waitCount = 0;\n    let hookDisposedCount = 0;\n    for (const item of steps) {\n      if (item.type === 'step') stepCount++;\n      else if (item.type === 'hook') {\n        if (item.disposed) hookDisposedCount++;\n        else hookCount++;\n      } else if (item.type === 'wait') waitCount++;\n    }\n\n    // Build description parts\n    const parts: string[] = [];\n    if (stepCount > 0) {\n      parts.push(`${stepCount} ${pluralize('step', 'steps', stepCount)}`);\n    }\n    if (hookCount > 0) {\n      parts.push(`${hookCount} ${pluralize('hook', 'hooks', hookCount)}`);\n    }\n    if (waitCount > 0) {\n      parts.push(`${waitCount} ${pluralize('wait', 'waits', waitCount)}`);\n    }\n    if (hookDisposedCount > 0) {\n      parts.push(\n        `${hookDisposedCount} hook ${pluralize('disposal', 'disposals', hookDisposedCount)}`\n      );\n    }\n\n    // Determine verb (has/have) and action (run/created/received)\n    const totalCount = stepCount + hookCount + waitCount + hookDisposedCount;\n    const hasOrHave = pluralize('has', 'have', totalCount);\n    // Pick action verb: use \"processed\" when mixed types are present\n    const typeCount =\n      (stepCount > 0 ? 1 : 0) +\n      (hookCount > 0 ? 1 : 0) +\n      (waitCount > 0 ? 1 : 0) +\n      (hookDisposedCount > 0 ? 1 : 0);\n    let action: string;\n    if (typeCount > 1) {\n      action = 'processed';\n    } else if (stepCount > 0) {\n      action = 'run';\n    } else if (hookCount > 0) {\n      action = 'created';\n    } else if (waitCount > 0) {\n      action = 'created';\n    } else if (hookDisposedCount > 0) {\n      action = 'processed';\n    } else {\n      action = 'received';\n    }\n\n    const description =\n      parts.length > 0\n        ? `${parts.join(' and ')} ${hasOrHave} not been ${action} yet`\n        : '0 steps have not been run yet'; // Default case for empty array\n    super(description);\n    this.name = 'WorkflowSuspension';\n    this.steps = steps;\n    this.globalThis = global;\n    this.stepCount = stepCount;\n    this.hookCount = hookCount;\n    this.waitCount = waitCount;\n    this.hookDisposedCount = hookDisposedCount;\n  }\n\n  static is(value: unknown): value is WorkflowSuspension {\n    return value instanceof WorkflowSuspension;\n  }\n}\n\nexport function ENOTSUP(): never {\n  throw new Error('Not supported in workflow functions');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global.js","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"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","sourcesContent":["import { pluralize } from '@workflow/utils';\nimport type { Serializable } from './schemas.js';\n\nexport interface StepInvocationQueueItem {\n  type: 'step';\n  correlationId: string;\n  stepName: string;\n  args: Serializable[];\n  closureVars?: Record<string, Serializable>;\n  thisVal?: Serializable;\n  hasCreatedEvent?: boolean;\n}\n\nexport interface HookInvocationQueueItem {\n  type: 'hook';\n  correlationId: string;\n  token: string;\n  metadata?: Serializable;\n  hasCreatedEvent?: boolean;\n  /** Whether the workflow is awaiting `hook.getConflict()` for this hook */\n  hasConflictAwaiter?: boolean;\n  disposed?: boolean;\n  isWebhook?: boolean;\n}\n\nexport interface WaitInvocationQueueItem {\n  type: 'wait';\n  correlationId: string;\n  resumeAt: Date;\n  hasCreatedEvent?: boolean;\n}\n\nexport type QueueItem =\n  | StepInvocationQueueItem\n  | HookInvocationQueueItem\n  | WaitInvocationQueueItem;\n\n/**\n * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do\n * not yet have corresponding entries in the event log. The workflow\n * dispatcher will catch this error and push the operations\n * onto the queue.\n */\nexport class WorkflowSuspension extends Error {\n  steps: QueueItem[];\n  globalThis: typeof globalThis;\n  stepCount: number;\n  hookCount: number;\n  waitCount: number;\n  hookDisposedCount: number;\n\n  constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis) {\n    // Convert Map to array for iteration and storage\n    const steps = [...stepsInput.values()];\n\n    // Single-pass counting for efficiency\n    let stepCount = 0;\n    let hookCount = 0;\n    let waitCount = 0;\n    let hookDisposedCount = 0;\n    for (const item of steps) {\n      if (item.type === 'step') stepCount++;\n      else if (item.type === 'hook') {\n        if (item.disposed) hookDisposedCount++;\n        else hookCount++;\n      } else if (item.type === 'wait') waitCount++;\n    }\n\n    // Build description parts\n    const parts: string[] = [];\n    if (stepCount > 0) {\n      parts.push(`${stepCount} ${pluralize('step', 'steps', stepCount)}`);\n    }\n    if (hookCount > 0) {\n      parts.push(`${hookCount} ${pluralize('hook', 'hooks', hookCount)}`);\n    }\n    if (waitCount > 0) {\n      parts.push(`${waitCount} ${pluralize('wait', 'waits', waitCount)}`);\n    }\n    if (hookDisposedCount > 0) {\n      parts.push(\n        `${hookDisposedCount} hook ${pluralize('disposal', 'disposals', hookDisposedCount)}`\n      );\n    }\n\n    // Determine verb (has/have) and action (run/created/received)\n    const totalCount = stepCount + hookCount + waitCount + hookDisposedCount;\n    const hasOrHave = pluralize('has', 'have', totalCount);\n    // Pick action verb: use \"processed\" when mixed types are present\n    const typeCount =\n      (stepCount > 0 ? 1 : 0) +\n      (hookCount > 0 ? 1 : 0) +\n      (waitCount > 0 ? 1 : 0) +\n      (hookDisposedCount > 0 ? 1 : 0);\n    let action: string;\n    if (typeCount > 1) {\n      action = 'processed';\n    } else if (stepCount > 0) {\n      action = 'run';\n    } else if (hookCount > 0) {\n      action = 'created';\n    } else if (waitCount > 0) {\n      action = 'created';\n    } else if (hookDisposedCount > 0) {\n      action = 'processed';\n    } else {\n      action = 'received';\n    }\n\n    const description =\n      parts.length > 0\n        ? `${parts.join(' and ')} ${hasOrHave} not been ${action} yet`\n        : '0 steps have not been run yet'; // Default case for empty array\n    super(description);\n    this.name = 'WorkflowSuspension';\n    this.steps = steps;\n    this.globalThis = global;\n    this.stepCount = stepCount;\n    this.hookCount = hookCount;\n    this.waitCount = waitCount;\n    this.hookDisposedCount = hookDisposedCount;\n  }\n\n  static is(value: unknown): value is WorkflowSuspension {\n    return value instanceof WorkflowSuspension;\n  }\n}\n\nexport function ENOTSUP(): never {\n  throw new Error('Not supported in workflow functions');\n}\n"]}

package/dist/runtime/helpers.d.ts

@@ -4,7 +4,7 @@ import type { Event, HealthCheckPayload, ValidQueueName, World } from '@workflow
  * Ensures the workflow name only contains safe characters before
  * interpolating it into the queue name string.
  */
-export declare function getWorkflowQueueName(workflowName: string): ValidQueueName;
+export declare function getWorkflowQueueName(workflowName: string, namespace?: string): ValidQueueName;
 /**
  * Result of a health check operation.
  */
@@ -16,6 +16,14 @@ export interface HealthCheckResult {
     latencyMs?: number;
     /** Spec version of the responding deployment */
     specVersion?: number;
+    /**
+     * `@workflow/core` version of the responding deployment, used for
+     * capability detection (see `getRunCapabilities`). Omitted when the
+     * responding deployment did not provide the field as a string —
+     * for example, an older `@workflow/core` that predates this field,
+     * or a non-JSON plain-text health response.
+     */
+    workflowCoreVersion?: string;
 }
 /**
  * Checks if the given message is a health check payload.
@@ -37,7 +45,9 @@ export interface HealthCheckOptions {
     /** Deployment ID to send the health check to. Falls back to process.env.VERCEL_DEPLOYMENT_ID. */
     deploymentId?: string;
 }
-export declare function healthCheck(world: World, endpoint: HealthCheckEndpoint, options?: HealthCheckOptions): Promise<HealthCheckResult>;
+export declare function healthCheck(world: World, endpoint: HealthCheckEndpoint, options?: HealthCheckOptions & {
+    namespace?: string;
+}): Promise<HealthCheckResult>;
 export interface LoadedWorkflowRunEvents {
     events: Event[];
     cursor: string | null;

package/dist/runtime/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,KAAK,EACL,kBAAkB,EAClB,cAAc,EACd,KAAK,EACN,MAAM,iBAAiB,CAAC;AAwBzB;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,cAAc,CAOzE;AAWD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,GACf,kBAAkB,GAAG,SAAS,CAMhC;AAWD;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,kBAAkB,EAC/B,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iGAAiG;IACjG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAgLD,wBAAsB,WAAW,CAC/B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CA2D5B;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AA0DD;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,uBAAuB,CAAC,CAoGlC;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAG7E;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAC5C,gBAAgB,CAAC,EAAE,MAAM,GACxB,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAoCrC;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,iBA0BxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE;;cAS/D"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,KAAK,EACL,kBAAkB,EAClB,cAAc,EACd,KAAK,EACN,MAAM,iBAAiB,CAAC;AA0BzB;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,CAWhB;AAWD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,GACf,kBAAkB,GAAG,SAAS,CAMhC;AAWD;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,kBAAkB,EAC/B,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iGAAiG;IACjG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA6LD,wBAAsB,WAAW,CAC/B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,CAAC,EAAE,kBAAkB,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACpD,OAAO,CAAC,iBAAiB,CAAC,CAyD5B;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AA0DD;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,uBAAuB,CAAC,CAoGlC;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAG7E;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAC5C,gBAAgB,CAAC,EAAE,MAAM,GACxB,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAoCrC;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,iBA0BxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE;;cAS/D"}