@workflow/core 5.0.0-beta.0 → 5.0.0-beta.10

package/dist/workflow/abort-controller.js

@@ -0,0 +1,260 @@
+import { CorruptedEventLogError } from '@workflow/errors';
+import { EventConsumerResult } from '../events-consumer.js';
+import { hydrateStepReturnValue } from '../serialization.js';
+import { ABORT_HOOK_TOKEN, ABORT_STREAM_NAME } from '../symbols.js';
+import { getAbortStreamId } from '../util.js';
+/**
+ * A lightweight AbortSignal implementation for the workflow VM context.
+ *
+ * `signal.aborted` and listeners are updated in two scenarios:
+ * 1. On first-run: when `abort()` is called in the workflow code
+ * 2. On replay: when the events consumer processes the `hook_received`
+ *    event (chained through promiseQueue for deterministic ordering)
+ *
+ * On replay, `abort()` in the workflow code becomes a no-op since
+ * `_setAborted` was already called by the events consumer.
+ */
+export class WorkflowAbortSignal {
+    aborted = false;
+    reason = undefined;
+    [ABORT_STREAM_NAME];
+    [ABORT_HOOK_TOKEN];
+    #listeners = [];
+    #onabort = null;
+    get onabort() {
+        return this.#onabort;
+    }
+    set onabort(handler) {
+        this.#onabort = handler;
+        if (handler && this.aborted) {
+            handler.call(this);
+        }
+    }
+    constructor(streamName, hookToken) {
+        this[ABORT_STREAM_NAME] = streamName;
+        this[ABORT_HOOK_TOKEN] = hookToken;
+    }
+    /**
+     * @internal Sets aborted state and fires listeners.
+     * Called by abort() on first-run, or by the events consumer on replay.
+     * Idempotent — second call is a no-op.
+     */
+    _setAborted(reason) {
+        if (this.aborted)
+            return;
+        this.aborted = true;
+        this.reason = reason;
+        if (this.#onabort) {
+            this.#onabort.call(this);
+        }
+        for (const listener of this.#listeners) {
+            listener();
+        }
+        this.#listeners = [];
+    }
+    addEventListener(type, listener) {
+        if (type !== 'abort')
+            return;
+        if (this.aborted) {
+            // Fire synchronously, not on a microtask. Native AbortSignal fires on a
+            // microtask per spec, but inside the workflow VM we deliberately diverge
+            // for deterministic replay: listener ordering must be tied to the
+            // orchestrator's sync execution path, not to microtask scheduling.
+            listener();
+            return;
+        }
+        this.#listeners.push(listener);
+    }
+    removeEventListener(type, listener) {
+        if (type !== 'abort')
+            return;
+        this.#listeners = this.#listeners.filter((l) => l !== listener);
+    }
+    throwIfAborted() {
+        if (this.aborted) {
+            throw (this.reason ??
+                new DOMException('The operation was aborted.', 'AbortError'));
+        }
+    }
+}
+/**
+ * Creates a workflow-context `AbortController` class that uses hooks for
+ * durable state and streams for real-time step propagation.
+ *
+ * Follows the same pattern as `createCreateHook()` in `workflow/hook.ts`:
+ * - Registers a hook in the invocations queue on construction
+ * - Subscribes to the events consumer for hook_created/hook_received events
+ * - `abort()` calls `_setAborted` + marks the hook for resumption
+ * - The suspension handler processes the abort (creates event + writes stream)
+ * - On replay, the events consumer calls `_setAborted` when hook_received
+ *   is processed, and `abort()` in the workflow code becomes a no-op
+ */
+export function createCreateAbortController(ctx) {
+    return class WorkflowAbortController {
+        signal;
+        [ABORT_STREAM_NAME];
+        [ABORT_HOOK_TOKEN];
+        constructor() {
+            const id = ctx.generateUlid();
+            const streamName = getAbortStreamId(id);
+            const hookToken = `abrt_${id}`;
+            this[ABORT_STREAM_NAME] = streamName;
+            this[ABORT_HOOK_TOKEN] = hookToken;
+            this.signal = new WorkflowAbortSignal(streamName, hookToken);
+            // Register an internal system hook in the invocations queue.
+            // isSystem prevents token namespace conflicts with user hooks.
+            const correlationId = `hook_${ctx.generateUlid()}`;
+            ctx.invocationsQueue.set(correlationId, {
+                type: 'hook',
+                correlationId,
+                token: hookToken,
+                isWebhook: false,
+                isSystem: true,
+            });
+            // Subscribe to events for this hook's lifecycle
+            ctx.eventsConsumer.subscribe((event) => {
+                if (!event) {
+                    return EventConsumerResult.NotConsumed;
+                }
+                if (event.correlationId !== correlationId) {
+                    return EventConsumerResult.NotConsumed;
+                }
+                const eventToken = 'eventData' in event && event.eventData && 'token' in event.eventData
+                    ? event.eventData.token
+                    : undefined;
+                if (typeof eventToken === 'string' &&
+                    eventToken !== this[ABORT_HOOK_TOKEN]) {
+                    ctx.promiseQueue = ctx.promiseQueue.then(() => {
+                        ctx.onWorkflowError(new CorruptedEventLogError(`Corrupted event log: abort hook event ${event.eventType} for ${correlationId} belongs to token "${eventToken}", but the current abort hook expects "${this[ABORT_HOOK_TOKEN]}"`));
+                    });
+                    return EventConsumerResult.Finished;
+                }
+                if (event.eventType === 'hook_created') {
+                    const queueItem = ctx.invocationsQueue.get(correlationId);
+                    if (queueItem && queueItem.type === 'hook') {
+                        queueItem.hasCreatedEvent = true;
+                    }
+                    return EventConsumerResult.Consumed;
+                }
+                if (event.eventType === 'hook_received') {
+                    // The abort was recorded in the event log (from a previous run's
+                    // abort() call, or from a step/external abort). Update signal
+                    // state and fire listeners at this deterministic point in the
+                    // promiseQueue — same ordering as hook payload delivery.
+                    //
+                    // The payload is the dehydrated form written by the suspension
+                    // handler (a Uint8Array, possibly encrypted). Hydrate it via the
+                    // same machinery as regular hook payloads (workflow/hook.ts:117)
+                    // so the reason round-trips with full type fidelity. Reading the
+                    // raw payload here is a bug — it's not a plain object after
+                    // dehydration, so `'reason' in payload` is false and reason
+                    // ends up undefined on replay.
+                    const rawPayload = event.eventData?.payload;
+                    ctx.promiseQueue = ctx.promiseQueue.then(async () => {
+                        let reason;
+                        if (rawPayload !== undefined) {
+                            try {
+                                const hydrated = (await hydrateStepReturnValue(rawPayload, ctx.runId, ctx.encryptionKey, ctx.globalThis));
+                                if (hydrated &&
+                                    typeof hydrated === 'object' &&
+                                    'reason' in hydrated) {
+                                    reason = hydrated.reason;
+                                }
+                            }
+                            catch {
+                                // Best-effort: if hydration fails, fall back to undefined
+                                // reason. The signal still aborts; the user just won't see
+                                // the original reason. Matches WorkflowAbortSignal's spec
+                                // fallback (DOMException AbortError).
+                            }
+                        }
+                        this.signal._setAborted(reason);
+                    });
+                    ctx.invocationsQueue.delete(correlationId);
+                    // Multiple handlers can observe the same pending abort request and
+                    // durably record it before replay removes the queue item. Abort is
+                    // idempotent, so consume later matching receipts as no-ops instead
+                    // of surfacing a corrupted event log after the first receipt.
+                    return EventConsumerResult.Consumed;
+                }
+                if (event.eventType === 'hook_disposed') {
+                    ctx.invocationsQueue.delete(correlationId);
+                    return EventConsumerResult.Finished;
+                }
+                return EventConsumerResult.NotConsumed;
+            });
+        }
+        abort(reason) {
+            if (this.signal.aborted)
+                return; // no-op (already aborted, e.g. from replay)
+            // Update signal state and fire listeners synchronously
+            this.signal._setAborted(reason);
+            // Mark the hook for resumption so the suspension handler records
+            // the abort in the event log and writes the stream packet.
+            for (const [, item] of ctx.invocationsQueue) {
+                if (item.type === 'hook' && item.token === this[ABORT_HOOK_TOKEN]) {
+                    item.abortRequested = true;
+                    item.abortReason = reason;
+                    break;
+                }
+            }
+        }
+    };
+}
+/**
+ * Creates a workflow-context `AbortSignal` object with static methods.
+ */
+export function createAbortSignalStatics() {
+    return {
+        abort(reason) {
+            const signal = new WorkflowAbortSignal('', '');
+            signal._setAborted(reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+            return signal;
+        },
+        any(signals) {
+            const composite = new WorkflowAbortSignal('', '');
+            // Materialize the iterable once. Native AbortSignal.any does the same:
+            // single-shot iterables (e.g. generators) would otherwise produce zero
+            // entries on the second pass below.
+            const arr = Array.from(signals);
+            for (const signal of arr) {
+                if (signal.aborted) {
+                    composite._setAborted(signal.reason);
+                    return composite;
+                }
+            }
+            // Listen to each signal — first one to abort wins. Track listeners so
+            // we can remove them after the composite aborts; otherwise the closures
+            // (capturing `composite`) prevent GC for any input signal that outlives
+            // the composite (e.g. a long-lived external controller).
+            const listeners = [];
+            const cleanup = () => {
+                for (const { signal, listener } of listeners) {
+                    if (signal.removeEventListener) {
+                        signal.removeEventListener('abort', listener);
+                    }
+                }
+                listeners.length = 0;
+            };
+            for (const signal of arr) {
+                if (!signal.addEventListener)
+                    continue;
+                const listener = () => {
+                    if (!composite.aborted) {
+                        composite._setAborted(signal.reason);
+                        cleanup();
+                    }
+                };
+                listeners.push({ signal, listener });
+                signal.addEventListener('abort', listener);
+            }
+            return composite;
+        },
+        timeout() {
+            throw new Error('AbortSignal.timeout() is not supported in workflow functions. ' +
+                'Use sleep() with an AbortController instead. ' +
+                'See: /docs/errors/abort-signal-timeout-in-workflow');
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abort-controller.js","sourceRoot":"","sources":["../../src/workflow/abort-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { CorruptedEventLogError } from '@workflow/errors';\nimport { EventConsumerResult } from '../events-consumer.js';\nimport type { WorkflowOrchestratorContext } from '../private.js';\nimport { hydrateStepReturnValue } from '../serialization.js';\nimport { ABORT_HOOK_TOKEN, ABORT_STREAM_NAME } from '../symbols.js';\nimport { getAbortStreamId } from '../util.js';\n\n/**\n * A lightweight AbortSignal implementation for the workflow VM context.\n *\n * `signal.aborted` and listeners are updated in two scenarios:\n * 1. On first-run: when `abort()` is called in the workflow code\n * 2. On replay: when the events consumer processes the `hook_received`\n *    event (chained through promiseQueue for deterministic ordering)\n *\n * On replay, `abort()` in the workflow code becomes a no-op since\n * `_setAborted` was already called by the events consumer.\n */\nexport class WorkflowAbortSignal {\n  aborted = false;\n  reason: unknown = undefined;\n\n  readonly [ABORT_STREAM_NAME]: string;\n  readonly [ABORT_HOOK_TOKEN]: string;\n\n  #listeners: Array<() => void> = [];\n  #onabort: ((this: WorkflowAbortSignal) => void) | null = null;\n\n  get onabort(): ((this: WorkflowAbortSignal) => void) | null {\n    return this.#onabort;\n  }\n\n  set onabort(handler: ((this: WorkflowAbortSignal) => void) | null) {\n    this.#onabort = handler;\n    if (handler && this.aborted) {\n      handler.call(this);\n    }\n  }\n\n  constructor(streamName: string, hookToken: string) {\n    this[ABORT_STREAM_NAME] = streamName;\n    this[ABORT_HOOK_TOKEN] = hookToken;\n  }\n\n  /**\n   * @internal Sets aborted state and fires listeners.\n   * Called by abort() on first-run, or by the events consumer on replay.\n   * Idempotent — second call is a no-op.\n   */\n  _setAborted(reason?: unknown): void {\n    if (this.aborted) return;\n    this.aborted = true;\n    this.reason = reason;\n    if (this.#onabort) {\n      this.#onabort.call(this);\n    }\n    for (const listener of this.#listeners) {\n      listener();\n    }\n    this.#listeners = [];\n  }\n\n  addEventListener(type: string, listener: () => void): void {\n    if (type !== 'abort') return;\n    if (this.aborted) {\n      // Fire synchronously, not on a microtask. Native AbortSignal fires on a\n      // microtask per spec, but inside the workflow VM we deliberately diverge\n      // for deterministic replay: listener ordering must be tied to the\n      // orchestrator's sync execution path, not to microtask scheduling.\n      listener();\n      return;\n    }\n    this.#listeners.push(listener);\n  }\n\n  removeEventListener(type: string, listener: () => void): void {\n    if (type !== 'abort') return;\n    this.#listeners = this.#listeners.filter((l) => l !== listener);\n  }\n\n  throwIfAborted(): void {\n    if (this.aborted) {\n      throw (\n        this.reason ??\n        new DOMException('The operation was aborted.', 'AbortError')\n      );\n    }\n  }\n}\n\n/**\n * Creates a workflow-context `AbortController` class that uses hooks for\n * durable state and streams for real-time step propagation.\n *\n * Follows the same pattern as `createCreateHook()` in `workflow/hook.ts`:\n * - Registers a hook in the invocations queue on construction\n * - Subscribes to the events consumer for hook_created/hook_received events\n * - `abort()` calls `_setAborted` + marks the hook for resumption\n * - The suspension handler processes the abort (creates event + writes stream)\n * - On replay, the events consumer calls `_setAborted` when hook_received\n *   is processed, and `abort()` in the workflow code becomes a no-op\n */\nexport function createCreateAbortController(ctx: WorkflowOrchestratorContext) {\n  return class WorkflowAbortController {\n    readonly signal: WorkflowAbortSignal;\n    readonly [ABORT_STREAM_NAME]: string;\n    readonly [ABORT_HOOK_TOKEN]: string;\n\n    constructor() {\n      const id = ctx.generateUlid();\n      const streamName = getAbortStreamId(id);\n      const hookToken = `abrt_${id}`;\n\n      this[ABORT_STREAM_NAME] = streamName;\n      this[ABORT_HOOK_TOKEN] = hookToken;\n      this.signal = new WorkflowAbortSignal(streamName, hookToken);\n\n      // Register an internal system hook in the invocations queue.\n      // isSystem prevents token namespace conflicts with user hooks.\n      const correlationId = `hook_${ctx.generateUlid()}`;\n      ctx.invocationsQueue.set(correlationId, {\n        type: 'hook',\n        correlationId,\n        token: hookToken,\n        isWebhook: false,\n        isSystem: true,\n      });\n\n      // Subscribe to events for this hook's lifecycle\n      ctx.eventsConsumer.subscribe((event) => {\n        if (!event) {\n          return EventConsumerResult.NotConsumed;\n        }\n\n        if (event.correlationId !== correlationId) {\n          return EventConsumerResult.NotConsumed;\n        }\n\n        const eventToken =\n          'eventData' in event && event.eventData && 'token' in event.eventData\n            ? event.eventData.token\n            : undefined;\n\n        if (\n          typeof eventToken === 'string' &&\n          eventToken !== this[ABORT_HOOK_TOKEN]\n        ) {\n          ctx.promiseQueue = ctx.promiseQueue.then(() => {\n            ctx.onWorkflowError(\n              new CorruptedEventLogError(\n                `Corrupted event log: abort hook event ${event.eventType} for ${correlationId} belongs to token \"${eventToken}\", but the current abort hook expects \"${this[ABORT_HOOK_TOKEN]}\"`\n              )\n            );\n          });\n          return EventConsumerResult.Finished;\n        }\n\n        if (event.eventType === 'hook_created') {\n          const queueItem = ctx.invocationsQueue.get(correlationId);\n          if (queueItem && queueItem.type === 'hook') {\n            queueItem.hasCreatedEvent = true;\n          }\n          return EventConsumerResult.Consumed;\n        }\n\n        if (event.eventType === 'hook_received') {\n          // The abort was recorded in the event log (from a previous run's\n          // abort() call, or from a step/external abort). Update signal\n          // state and fire listeners at this deterministic point in the\n          // promiseQueue — same ordering as hook payload delivery.\n          //\n          // The payload is the dehydrated form written by the suspension\n          // handler (a Uint8Array, possibly encrypted). Hydrate it via the\n          // same machinery as regular hook payloads (workflow/hook.ts:117)\n          // so the reason round-trips with full type fidelity. Reading the\n          // raw payload here is a bug — it's not a plain object after\n          // dehydration, so `'reason' in payload` is false and reason\n          // ends up undefined on replay.\n          const rawPayload = event.eventData?.payload;\n          ctx.promiseQueue = ctx.promiseQueue.then(async () => {\n            let reason: unknown;\n            if (rawPayload !== undefined) {\n              try {\n                const hydrated = (await hydrateStepReturnValue(\n                  rawPayload,\n                  ctx.runId,\n                  ctx.encryptionKey,\n                  ctx.globalThis\n                )) as { reason?: unknown } | undefined;\n                if (\n                  hydrated &&\n                  typeof hydrated === 'object' &&\n                  'reason' in hydrated\n                ) {\n                  reason = hydrated.reason;\n                }\n              } catch {\n                // Best-effort: if hydration fails, fall back to undefined\n                // reason. The signal still aborts; the user just won't see\n                // the original reason. Matches WorkflowAbortSignal's spec\n                // fallback (DOMException AbortError).\n              }\n            }\n            this.signal._setAborted(reason);\n          });\n\n          ctx.invocationsQueue.delete(correlationId);\n          // Multiple handlers can observe the same pending abort request and\n          // durably record it before replay removes the queue item. Abort is\n          // idempotent, so consume later matching receipts as no-ops instead\n          // of surfacing a corrupted event log after the first receipt.\n          return EventConsumerResult.Consumed;\n        }\n\n        if (event.eventType === 'hook_disposed') {\n          ctx.invocationsQueue.delete(correlationId);\n          return EventConsumerResult.Finished;\n        }\n\n        return EventConsumerResult.NotConsumed;\n      });\n    }\n\n    abort(reason?: unknown): void {\n      if (this.signal.aborted) return; // no-op (already aborted, e.g. from replay)\n\n      // Update signal state and fire listeners synchronously\n      this.signal._setAborted(reason);\n\n      // Mark the hook for resumption so the suspension handler records\n      // the abort in the event log and writes the stream packet.\n      for (const [, item] of ctx.invocationsQueue) {\n        if (item.type === 'hook' && item.token === this[ABORT_HOOK_TOKEN]) {\n          item.abortRequested = true;\n          item.abortReason = reason;\n          break;\n        }\n      }\n    }\n  };\n}\n\n/**\n * Creates a workflow-context `AbortSignal` object with static methods.\n */\nexport function createAbortSignalStatics(): {\n  abort: (reason?: unknown) => WorkflowAbortSignal;\n  any: (\n    signals: Iterable<{\n      aborted: boolean;\n      reason?: unknown;\n      addEventListener?: Function;\n    }>\n  ) => WorkflowAbortSignal;\n  timeout: () => never;\n} {\n  return {\n    abort(reason?: unknown): WorkflowAbortSignal {\n      const signal = new WorkflowAbortSignal('', '');\n      signal._setAborted(\n        reason ?? new DOMException('The operation was aborted.', 'AbortError')\n      );\n      return signal;\n    },\n\n    any(\n      signals: Iterable<{\n        aborted: boolean;\n        reason?: unknown;\n        addEventListener?: Function;\n        removeEventListener?: Function;\n      }>\n    ): WorkflowAbortSignal {\n      const composite = new WorkflowAbortSignal('', '');\n\n      // Materialize the iterable once. Native AbortSignal.any does the same:\n      // single-shot iterables (e.g. generators) would otherwise produce zero\n      // entries on the second pass below.\n      const arr = Array.from(signals);\n\n      for (const signal of arr) {\n        if (signal.aborted) {\n          composite._setAborted(signal.reason);\n          return composite;\n        }\n      }\n\n      // Listen to each signal — first one to abort wins. Track listeners so\n      // we can remove them after the composite aborts; otherwise the closures\n      // (capturing `composite`) prevent GC for any input signal that outlives\n      // the composite (e.g. a long-lived external controller).\n      const listeners: Array<{\n        signal: (typeof arr)[number];\n        listener: () => void;\n      }> = [];\n      const cleanup = () => {\n        for (const { signal, listener } of listeners) {\n          if (signal.removeEventListener) {\n            signal.removeEventListener('abort', listener);\n          }\n        }\n        listeners.length = 0;\n      };\n\n      for (const signal of arr) {\n        if (!signal.addEventListener) continue;\n        const listener = () => {\n          if (!composite.aborted) {\n            composite._setAborted(signal.reason);\n            cleanup();\n          }\n        };\n        listeners.push({ signal, listener });\n        signal.addEventListener('abort', listener);\n      }\n\n      return composite;\n    },\n\n    timeout(): never {\n      throw new Error(\n        'AbortSignal.timeout() is not supported in workflow functions. ' +\n          'Use sleep() with an AbortController instead. ' +\n          'See: /docs/errors/abort-signal-timeout-in-workflow'\n      );\n    },\n  };\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"create-hook.d.ts","sourceRoot":"","sources":["../../src/workflow/create-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,WAAW,EACX,mBAAmB,EACnB,OAAO,EACP,cAAc,EACf,MAAM,mBAAmB,CAAC;AAI3B,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAWlE;AAED,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/workflow/create-hook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,IAAI,EACJ,WAAW,EACX,mBAAmB,EACnB,OAAO,EACP,cAAc,EACf,MAAM,mBAAmB,CAAC;AAI3B,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAalE;AAED,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/workflow/create-hook.js

@@ -1,10 +1,11 @@
+import { throwNotInWorkflowContext } from '../context-errors.js';
 import { WORKFLOW_CREATE_HOOK } from '../symbols.js';
 import { getWorkflowMetadata } from './get-workflow-metadata.js';
 export function createHook(options) {
     // Inside the workflow VM, the hook function is stored in the globalThis object behind a symbol
     const createHookFn = globalThis[WORKFLOW_CREATE_HOOK];
     if (!createHookFn) {
-        throw new Error('`createHook()` can only be called inside a workflow function');
+        throwNotInWorkflowContext('createHook()', 'https://workflow-sdk.dev/docs/api-reference/workflow/create-hook', createHook);
     }
     return createHookFn(options);
 }
@@ -22,4 +23,4 @@ export function createWebhook(options) {
     hook.url = `${url}/.well-known/workflow/v1/webhook/${encodeURIComponent(hook.token)}`;
     return hook;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWhvb2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd29ya2Zsb3cvY3JlYXRlLWhvb2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT0EsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3JELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRWpFLE1BQU0sVUFBVSxVQUFVLENBQVUsT0FBcUI7SUFDdkQsK0ZBQStGO0lBQy9GLE1BQU0sWUFBWSxHQUFJLFVBQWtCLENBQ3RDLG9CQUFvQixDQUNHLENBQUM7SUFDMUIsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ2xCLE1BQU0sSUFBSSxLQUFLLENBQ2IsOERBQThELENBQy9ELENBQUM7SUFDSixDQUFDO0lBQ0QsT0FBTyxZQUFZLENBQUMsT0FBTyxDQUFDLENBQUM7QUFDL0IsQ0FBQztBQU1ELE1BQU0sVUFBVSxhQUFhLENBQzNCLE9BQXdCO0lBRXhCLE1BQU0sRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLEdBQUcsSUFBSSxFQUFFLEdBQUcsQ0FBQyxPQUFPLElBQUksRUFBRSxDQUVyRCxDQUFDO0lBRUYsSUFBSSxLQUFLLEtBQUssU0FBUyxFQUFFLENBQUM7UUFDeEIsTUFBTSxJQUFJLEtBQUssQ0FDYiw0S0FBNEssQ0FDN0ssQ0FBQztJQUNKLENBQUM7SUFFRCxJQUFJLFFBQXlELENBQUM7SUFDOUQsSUFBSSxPQUFPLFdBQVcsS0FBSyxXQUFXLEVBQUUsQ0FBQztRQUN2QyxRQUFRLEdBQUcsRUFBRSxXQUFXLEVBQUUsQ0FBQztJQUM3QixDQUFDO0lBRUQsTUFBTSxJQUFJLEdBQUcsVUFBVSxDQUFDLEVBQUUsR0FBRyxJQUFJLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FFOUIsQ0FBQztJQUVqQyxNQUFNLEVBQUUsR0FBRyxFQUFFLEdBQUcsbUJBQW1CLEVBQUUsQ0FBQztJQUN0QyxJQUFJLENBQUMsR0FBRyxHQUFHLEdBQUcsR0FBRyxvQ0FBb0Msa0JBQWtCLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7SUFFdEYsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/workflow/define-hook.d.ts

@@ -5,6 +5,6 @@ import type { Hook, HookOptions } from '../create-hook.js';
  */
 export declare function defineHook<TInput, TOutput = TInput>(): {
     create(options?: HookOptions): Hook<TOutput>;
-    resume(_token: string, _payload: TInput): Promise<HookEntity | null>;
+    resume: (_token: string, _payload: TInput) => Promise<HookEntity | null>;
 };
 //# sourceMappingURL=define-hook.d.ts.map

package/dist/workflow/define-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"define-hook.d.ts","sourceRoot":"","sources":["../../src/workflow/define-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAG3D;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM;qBAE9B,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC;mBAI7B,MAAM,YAAY,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;EAMvE"}
+{"version":3,"file":"define-hook.d.ts","sourceRoot":"","sources":["../../src/workflow/define-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE1D,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAG3D;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM;qBAe9B,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC;qBAbpC,MAAM,YACJ,MAAM,KACf,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;EAgB9B"}

package/dist/workflow/define-hook.js

@@ -1,15 +1,19 @@
+import { throwUnavailableInWorkflowContext } from '../context-errors.js';
 import { createHook } from './create-hook.js';
 /**
  * NOTE: This is the implementation of `defineHook()` that is used in workflow contexts.
  */
 export function defineHook() {
+    function resume(_token, _payload) {
+        // Referenced by name (not `this.resume`) so the stack strip works even
+        // if the caller destructured the hook.
+        throwUnavailableInWorkflowContext('defineHook().resume()', 'https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook', resume);
+    }
     return {
         create(options) {
             return createHook(options);
         },
-        resume(_token, _payload) {
-            throw new Error('`defineHook().resume()` can only be called from external contexts (e.g. API routes).');
-        },
+        resume,
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmaW5lLWhvb2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd29ya2Zsb3cvZGVmaW5lLWhvb2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTlDOztHQUVHO0FBQ0gsTUFBTSxVQUFVLFVBQVU7SUFDeEIsT0FBTztRQUNMLE1BQU0sQ0FBQyxPQUFxQjtZQUMxQixPQUFPLFVBQVUsQ0FBVSxPQUFPLENBQUMsQ0FBQztRQUN0QyxDQUFDO1FBRUQsTUFBTSxDQUFDLE1BQWMsRUFBRSxRQUFnQjtZQUNyQyxNQUFNLElBQUksS0FBSyxDQUNiLHNGQUFzRixDQUN2RixDQUFDO1FBQ0osQ0FBQztLQUNGLENBQUM7QUFDSixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmaW5lLWhvb2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd29ya2Zsb3cvZGVmaW5lLWhvb2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGlDQUFpQyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTlDOztHQUVHO0FBQ0gsTUFBTSxVQUFVLFVBQVU7SUFDeEIsU0FBUyxNQUFNLENBQ2IsTUFBYyxFQUNkLFFBQWdCO1FBRWhCLHVFQUF1RTtRQUN2RSx1Q0FBdUM7UUFDdkMsaUNBQWlDLENBQy9CLHVCQUF1QixFQUN2QixzRUFBc0UsRUFDdEUsTUFBTSxDQUNQLENBQUM7SUFDSixDQUFDO0lBRUQsT0FBTztRQUNMLE1BQU0sQ0FBQyxPQUFxQjtZQUMxQixPQUFPLFVBQVUsQ0FBVSxPQUFPLENBQUMsQ0FBQztRQUN0QyxDQUFDO1FBQ0QsTUFBTTtLQUNQLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBIb29rIGFzIEhvb2tFbnRpdHkgfSBmcm9tICdAd29ya2Zsb3cvd29ybGQnO1xuaW1wb3J0IHsgdGhyb3dVbmF2YWlsYWJsZUluV29ya2Zsb3dDb250ZXh0IH0gZnJvbSAnLi4vY29udGV4dC1lcnJvcnMuanMnO1xuaW1wb3J0IHR5cGUgeyBIb29rLCBIb29rT3B0aW9ucyB9IGZyb20gJy4uL2NyZWF0ZS1ob29rLmpzJztcbmltcG9ydCB7IGNyZWF0ZUhvb2sgfSBmcm9tICcuL2NyZWF0ZS1ob29rLmpzJztcblxuLyoqXG4gKiBOT1RFOiBUaGlzIGlzIHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBgZGVmaW5lSG9vaygpYCB0aGF0IGlzIHVzZWQgaW4gd29ya2Zsb3cgY29udGV4dHMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWZpbmVIb29rPFRJbnB1dCwgVE91dHB1dCA9IFRJbnB1dD4oKSB7XG4gIGZ1bmN0aW9uIHJlc3VtZShcbiAgICBfdG9rZW46IHN0cmluZyxcbiAgICBfcGF5bG9hZDogVElucHV0XG4gICk6IFByb21pc2U8SG9va0VudGl0eSB8IG51bGw+IHtcbiAgICAvLyBSZWZlcmVuY2VkIGJ5IG5hbWUgKG5vdCBgdGhpcy5yZXN1bWVgKSBzbyB0aGUgc3RhY2sgc3RyaXAgd29ya3MgZXZlblxuICAgIC8vIGlmIHRoZSBjYWxsZXIgZGVzdHJ1Y3R1cmVkIHRoZSBob29rLlxuICAgIHRocm93VW5hdmFpbGFibGVJbldvcmtmbG93Q29udGV4dChcbiAgICAgICdkZWZpbmVIb29rKCkucmVzdW1lKCknLFxuICAgICAgJ2h0dHBzOi8vd29ya2Zsb3ctc2RrLmRldi9kb2NzL2FwaS1yZWZlcmVuY2Uvd29ya2Zsb3ctYXBpL3Jlc3VtZS1ob29rJyxcbiAgICAgIHJlc3VtZVxuICAgICk7XG4gIH1cblxuICByZXR1cm4ge1xuICAgIGNyZWF0ZShvcHRpb25zPzogSG9va09wdGlvbnMpOiBIb29rPFRPdXRwdXQ+IHtcbiAgICAgIHJldHVybiBjcmVhdGVIb29rPFRPdXRwdXQ+KG9wdGlvbnMpO1xuICAgIH0sXG4gICAgcmVzdW1lLFxuICB9O1xufVxuIl19

package/dist/workflow/get-workflow-metadata.d.ts

@@ -15,6 +15,17 @@ export interface WorkflowMetadata {
      * The URL where the workflow can be triggered.
      */
     url: string;
+    /**
+     * Feature flags indicating which capabilities are active for this workflow run.
+     */
+    features: {
+        /**
+         * Whether encryption is enabled for this workflow run.
+         * When `true`, step inputs, outputs, and other serialized data
+         * are encrypted at rest.
+         */
+        encryption: boolean;
+    };
 }
 export declare const WORKFLOW_CONTEXT_SYMBOL: unique symbol;
 export declare function getWorkflowMetadata(): WorkflowMetadata;

package/dist/workflow/get-workflow-metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-workflow-metadata.d.ts","sourceRoot":"","sources":["../../src/workflow/get-workflow-metadata.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,iBAAiB,EAAE,IAAI,CAAC;IAExB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,eAAO,MAAM,uBAAuB,eACY,CAAC;AAEjD,wBAAgB,mBAAmB,IAAI,gBAAgB,CAStD"}
+{"version":3,"file":"get-workflow-metadata.d.ts","sourceRoot":"","sources":["../../src/workflow/get-workflow-metadata.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,iBAAiB,EAAE,IAAI,CAAC;IAExB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,QAAQ,EAAE;QACR;;;;WAIG;QACH,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC;CACH;AAED,eAAO,MAAM,uBAAuB,eACY,CAAC;AAEjD,wBAAgB,mBAAmB,IAAI,gBAAgB,CAmBtD"}

package/dist/workflow/get-workflow-metadata.js

@@ -1,11 +1,22 @@
+import { redirectStackToCaller } from '../capture-stack.js';
+import { NotInWorkflowOrStepContextError } from '../context-violation-error.js';
 export const WORKFLOW_CONTEXT_SYMBOL = 
 /* @__PURE__ */ Symbol.for('WORKFLOW_CONTEXT');
 export function getWorkflowMetadata() {
-    // Inside the workflow VM, the context is stored in the globalThis object behind a symbol
+    // Inside the workflow VM, the context is stored in the globalThis object
+    // behind a symbol.
     const ctx = globalThis[WORKFLOW_CONTEXT_SYMBOL];
     if (!ctx) {
-        throw new Error('`getWorkflowMetadata()` can only be called inside a workflow or step function');
+        // Use the shared `NotInWorkflowOrStepContextError` — it lives in
+        // `context-violation-error.ts` specifically so this file can throw it
+        // without creating a module-init cycle (the full `context-errors.ts`
+        // depends on this file's `WORKFLOW_CONTEXT_SYMBOL`).
+        const err = new NotInWorkflowOrStepContextError('getWorkflowMetadata()', 'https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata');
+        // Redirect the stack to the caller so terminal overlays (Next.js,
+        // Turbopack, VS Code) point at the user's code rather than this frame.
+        redirectStackToCaller(err, getWorkflowMetadata);
+        throw err;
     }
     return ctx;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXdvcmtmbG93LW1ldGFkYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3dvcmtmbG93L2dldC13b3JrZmxvdy1tZXRhZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFzQkEsTUFBTSxDQUFDLE1BQU0sdUJBQXVCO0FBQ2xDLGVBQWUsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLGtCQUFrQixDQUFDLENBQUM7QUFFakQsTUFBTSxVQUFVLG1CQUFtQjtJQUNqQyx5RkFBeUY7SUFDekYsTUFBTSxHQUFHLEdBQUksVUFBa0IsQ0FBQyx1QkFBdUIsQ0FBcUIsQ0FBQztJQUM3RSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDVCxNQUFNLElBQUksS0FBSyxDQUNiLCtFQUErRSxDQUNoRixDQUFDO0lBQ0osQ0FBQztJQUNELE9BQU8sR0FBRyxDQUFDO0FBQ2IsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist/workflow/hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../src/workflow/hook.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAI3D,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,eAAe,CAAC;AAGvB,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,2BAA2B,IAChC,CAAC,GAAG,GAAG,EAAE,UAAS,WAAgB,KAAG,IAAI,CAAC,CAAC,CAAC,CA0Q5E"}
+{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../src/workflow/hook.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAI3D,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,eAAe,CAAC;AAGvB,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,2BAA2B,IAChC,CAAC,GAAG,GAAG,EAAE,UAAS,WAAgB,KAAG,IAAI,CAAC,CAAC,CAAC,CA2R5E"}

package/dist/workflow/hook.js

@@ -1,4 +1,4 @@
-import { HookConflictError, WorkflowRuntimeError } from '@workflow/errors';
+import { CorruptedEventLogError, HookConflictError } from '@workflow/errors';
 import { withResolvers } from '@workflow/utils';
 import { EventConsumerResult } from '../events-consumer.js';
 import { WorkflowSuspension } from '../global.js';
@@ -47,6 +47,15 @@ export function createCreateHook(ctx) {
                 // We're not interested in this event - the correlationId belongs to a different entity
                 return EventConsumerResult.NotConsumed;
             }
+            const eventToken = 'eventData' in event && event.eventData && 'token' in event.eventData
+                ? event.eventData.token
+                : undefined;
+            if (typeof eventToken === 'string' && eventToken !== token) {
+                ctx.promiseQueue = ctx.promiseQueue.then(() => {
+                    ctx.onWorkflowError(new CorruptedEventLogError(`Corrupted event log: hook event ${event.eventType} for ${correlationId} belongs to token "${eventToken}", but the current hook consumer expects "${token}"`));
+                });
+                return EventConsumerResult.Finished;
+            }
             // Check for hook_created event to mark this hook as already created
             if (event.eventType === 'hook_created') {
                 const queueItem = ctx.invocationsQueue.get(correlationId);
@@ -62,7 +71,7 @@ export function createCreateHook(ctx) {
                 // Store the conflict event so we can reject any awaited promises.
                 // Chain through promiseQueue to ensure deterministic ordering.
                 const conflictEvent = event;
-                const conflictError = new HookConflictError(conflictEvent.eventData.token);
+                const conflictError = new HookConflictError(conflictEvent.eventData.token, conflictEvent.eventData.conflictingRunId);
                 // Mark that we have a conflict so future awaits also reject
                 hasConflict = true;
                 conflictErrorRef = conflictError;
@@ -115,7 +124,7 @@ export function createCreateHook(ctx) {
             }
             // An unexpected event type has been received, this event log looks corrupted. Let's fail immediately.
             ctx.promiseQueue = ctx.promiseQueue.then(() => {
-                ctx.onWorkflowError(new WorkflowRuntimeError(`Unexpected event type for hook ${correlationId} (token: ${token}) "${event.eventType}"`));
+                ctx.onWorkflowError(new CorruptedEventLogError(`Unexpected event type for hook ${correlationId} (token: ${token}) "${event.eventType}"`));
             });
             return EventConsumerResult.Finished;
         });
@@ -213,4 +222,4 @@ export function createCreateHook(ctx) {
         return hook;
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hook.js","sourceRoot":"","sources":["../../src/workflow/hook.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hook.js","sourceRoot":"","sources":["../../src/workflow/hook.ts"],"names":[],"mappings":"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","sourcesContent":["import { CorruptedEventLogError, HookConflictError } from '@workflow/errors';\nimport { type PromiseWithResolvers, withResolvers } from '@workflow/utils';\nimport type { HookConflictEvent, HookReceivedEvent } from '@workflow/world';\nimport type { Hook, HookOptions } from '../create-hook.js';\nimport { EventConsumerResult } from '../events-consumer.js';\nimport { WorkflowSuspension } from '../global.js';\nimport { webhookLogger } from '../logger.js';\nimport {\n  scheduleWhenIdle,\n  type WorkflowOrchestratorContext,\n} from '../private.js';\nimport { hydrateStepReturnValue } from '../serialization.js';\n\nexport function createCreateHook(ctx: WorkflowOrchestratorContext) {\n  return function createHookImpl<T = any>(options: HookOptions = {}): Hook<T> {\n    // Generate hook ID and token\n    const correlationId = `hook_${ctx.generateUlid()}`;\n    const token = options.token ?? ctx.generateNanoid();\n\n    // Add hook creation to invocations queue (using Map for O(1) operations)\n    const isWebhook = options.isWebhook ?? false;\n\n    ctx.invocationsQueue.set(correlationId, {\n      type: 'hook',\n      correlationId,\n      token,\n      metadata: options.metadata,\n      isWebhook,\n    });\n\n    // Queue of hook events that have been received but not yet processed\n    const payloadsQueue: HookReceivedEvent[] = [];\n\n    // Queue of promises that resolve to the next hook payload\n    const promises: PromiseWithResolvers<T>[] = [];\n\n    let eventLogEmpty = false;\n\n    // Track if the event log confirms disposal happened (replay no-op)\n    let hasDisposedEvent = false;\n\n    // Track if we have a conflict so we can reject future awaits\n    let hasConflict = false;\n    let conflictErrorRef: HookConflictError | null = null;\n\n    webhookLogger.debug('Hook consumer setup', { correlationId, token });\n    ctx.eventsConsumer.subscribe((event) => {\n      // If there are no events and there are promises waiting,\n      // it means the hook has been awaited, but an incoming payload has not yet been received.\n      // In this case, the workflow should be suspended until the hook is resumed.\n      if (!event) {\n        eventLogEmpty = true;\n\n        if (promises.length > 0 && payloadsQueue.length === 0) {\n          scheduleWhenIdle(ctx, () => {\n            ctx.onWorkflowError(\n              new WorkflowSuspension(ctx.invocationsQueue, ctx.globalThis)\n            );\n          });\n        }\n        return EventConsumerResult.NotConsumed;\n      }\n\n      if (event.correlationId !== correlationId) {\n        // We're not interested in this event - the correlationId belongs to a different entity\n        return EventConsumerResult.NotConsumed;\n      }\n\n      const eventToken =\n        'eventData' in event && event.eventData && 'token' in event.eventData\n          ? event.eventData.token\n          : undefined;\n\n      if (typeof eventToken === 'string' && eventToken !== token) {\n        ctx.promiseQueue = ctx.promiseQueue.then(() => {\n          ctx.onWorkflowError(\n            new CorruptedEventLogError(\n              `Corrupted event log: hook event ${event.eventType} for ${correlationId} belongs to token \"${eventToken}\", but the current hook consumer expects \"${token}\"`\n            )\n          );\n        });\n        return EventConsumerResult.Finished;\n      }\n\n      // Check for hook_created event to mark this hook as already created\n      if (event.eventType === 'hook_created') {\n        const queueItem = ctx.invocationsQueue.get(correlationId);\n        if (queueItem && queueItem.type === 'hook') {\n          queueItem.hasCreatedEvent = true;\n        }\n        return EventConsumerResult.Consumed;\n      }\n\n      // Handle hook_conflict event - another workflow is using this token\n      if (event.eventType === 'hook_conflict') {\n        // Remove this hook from the invocations queue\n        ctx.invocationsQueue.delete(correlationId);\n\n        // Store the conflict event so we can reject any awaited promises.\n        // Chain through promiseQueue to ensure deterministic ordering.\n        const conflictEvent = event as HookConflictEvent;\n        const conflictError = new HookConflictError(\n          conflictEvent.eventData.token,\n          conflictEvent.eventData.conflictingRunId\n        );\n\n        // Mark that we have a conflict so future awaits also reject\n        hasConflict = true;\n        conflictErrorRef = conflictError;\n\n        // Capture and drain pending promises synchronously so the null event\n        // handler won't see them and trigger a spurious WorkflowSuspension.\n        // The actual rejections are deferred through promiseQueue for ordering.\n        const pendingPromises = promises.slice();\n        promises.length = 0;\n\n        ctx.promiseQueue = ctx.promiseQueue.then(() => {\n          for (const resolver of pendingPromises) {\n            resolver.reject(conflictError);\n          }\n        });\n\n        return EventConsumerResult.Consumed;\n      }\n\n      if (event.eventType === 'hook_received') {\n        if (promises.length > 0) {\n          const next = promises.shift();\n          if (next) {\n            // Reconstruct the payload from the event data.\n            // Chain through ctx.promiseQueue to ensure that async\n            // deserialization (e.g., decryption) resolves in event log order.\n            ctx.pendingDeliveries++;\n            ctx.promiseQueue = ctx.promiseQueue.then(async () => {\n              try {\n                const payload = await hydrateStepReturnValue(\n                  event.eventData.payload,\n                  ctx.runId,\n                  ctx.encryptionKey,\n                  ctx.globalThis\n                );\n                next.resolve(payload as T);\n              } catch (error) {\n                next.reject(error);\n              } finally {\n                ctx.pendingDeliveries--;\n              }\n            });\n          }\n        } else {\n          payloadsQueue.push(event);\n        }\n\n        return EventConsumerResult.Consumed;\n      }\n\n      if (event.eventType === 'hook_disposed') {\n        // Terminal state - remove from queue (like step_completed/wait_completed)\n        ctx.invocationsQueue.delete(correlationId);\n        // Mark that the event log confirms disposal happened\n        hasDisposedEvent = true;\n        // We're done processing any more events for this hook\n        return EventConsumerResult.Finished;\n      }\n\n      // An unexpected event type has been received, this event log looks corrupted. Let's fail immediately.\n      ctx.promiseQueue = ctx.promiseQueue.then(() => {\n        ctx.onWorkflowError(\n          new CorruptedEventLogError(\n            `Unexpected event type for hook ${correlationId} (token: ${token}) \"${event.eventType}\"`\n          )\n        );\n      });\n      return EventConsumerResult.Finished;\n    });\n\n    // Track if the hook has been disposed\n    let isDisposed = false;\n\n    // Helper function to create a new promise that waits for the next hook payload\n    function createHookPromise(): Promise<T> {\n      const resolvers = withResolvers<T>();\n\n      // If we have a conflict, reject through the promiseQueue to maintain\n      // deterministic ordering with any prior queued resolutions.\n      if (hasConflict && conflictErrorRef) {\n        ctx.promiseQueue = ctx.promiseQueue.then(() => {\n          resolvers.reject(conflictErrorRef);\n        });\n        return resolvers.promise;\n      }\n\n      if (payloadsQueue.length > 0) {\n        const nextPayload = payloadsQueue.shift();\n        if (nextPayload) {\n          // Chain through ctx.promiseQueue to ensure that async\n          // deserialization (e.g., decryption) resolves in event log order.\n          ctx.pendingDeliveries++;\n          ctx.promiseQueue = ctx.promiseQueue.then(async () => {\n            try {\n              const payload = await hydrateStepReturnValue(\n                nextPayload.eventData.payload,\n                ctx.runId,\n                ctx.encryptionKey,\n                ctx.globalThis\n              );\n              resolvers.resolve(payload as T);\n            } catch (error) {\n              resolvers.reject(error);\n            } finally {\n              ctx.pendingDeliveries--;\n            }\n          });\n          return resolvers.promise;\n        }\n      }\n\n      if (eventLogEmpty) {\n        scheduleWhenIdle(ctx, () => {\n          ctx.onWorkflowError(\n            new WorkflowSuspension(ctx.invocationsQueue, ctx.globalThis)\n          );\n        });\n      }\n\n      promises.push(resolvers);\n\n      return resolvers.promise;\n    }\n\n    // Helper function to dispose the hook\n    function disposeHook(): void {\n      if (isDisposed) {\n        return; // Already disposed, nothing to do\n      }\n      isDisposed = true;\n\n      // If the event log already contains hook_disposed, this is a replay — no-op\n      if (hasDisposedEvent) {\n        return;\n      }\n\n      // Set disposed flag on the existing queue item\n      const queueItem = ctx.invocationsQueue.get(correlationId);\n      if (queueItem && queueItem.type === 'hook') {\n        queueItem.disposed = true;\n      }\n\n      // Drain any pending promises that are waiting for payloads.\n      // Without this, promises created by `await hook` or the async iterator's\n      // `yield await this` would hang forever since the event consumer will\n      // never deliver another hook_received after disposal.\n      if (promises.length > 0) {\n        promises.length = 0;\n        scheduleWhenIdle(ctx, () => {\n          ctx.onWorkflowError(\n            new WorkflowSuspension(ctx.invocationsQueue, ctx.globalThis)\n          );\n        });\n      }\n\n      webhookLogger.debug('Hook disposed', { correlationId, token });\n    }\n\n    const hook: Hook<T> = {\n      token,\n\n      // biome-ignore lint/suspicious/noThenProperty: Intentionally thenable\n      then<TResult1 = T, TResult2 = never>(\n        onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,\n        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null\n      ): Promise<TResult1 | TResult2> {\n        return createHookPromise().then(onfulfilled, onrejected);\n      },\n\n      // Support `for await (const payload of hook) { … }` syntax\n      async *[Symbol.asyncIterator]() {\n        while (!isDisposed) {\n          yield await this;\n        }\n      },\n\n      dispose: disposeHook,\n\n      [Symbol.dispose]: disposeHook,\n    };\n\n    // Also register with the VM's Symbol.dispose so `using` works inside\n    // the workflow sandbox (the VM may have a polyfilled Symbol.dispose\n    // that differs from the host's).\n    const vmDispose = ctx.globalThis.Symbol.dispose;\n    if (vmDispose && vmDispose !== Symbol.dispose) {\n      (hook as any)[vmDispose] = disposeHook;\n    }\n\n    return hook;\n  };\n}\n"]}

package/dist/workflow/index.d.ts

@@ -1,6 +1,7 @@
 import type { StepMetadata } from '../step/get-step-metadata.js';
 export { FatalError, RetryableError, type RetryableErrorOptions, } from '@workflow/errors';
 export type { Hook, HookOptions } from '../create-hook.js';
+export { experimental_setAttributes } from './set-attributes.js';
 export { sleep } from '../sleep.js';
 export { createHook, createWebhook } from './create-hook.js';
 export { defineHook } from './define-hook.js';

package/dist/workflow/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAInD,wBAAgB,eAAe,IAAI,YAAY,CAI9C;AACD,wBAAgB,UAAU,SAIzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAInD,wBAAgB,eAAe,IAAI,YAAY,CAM9C;AACD,wBAAgB,UAAU,SAMzB"}

package/dist/workflow/index.js

@@ -1,4 +1,6 @@
+import { throwNotInStepContext, throwUnavailableInWorkflowContext, } from '../context-errors.js';
 export { FatalError, RetryableError, } from '@workflow/errors';
+export { experimental_setAttributes } from './set-attributes.js';
 export { sleep } from '../sleep.js';
 export { createHook, createWebhook } from './create-hook.js';
 export { defineHook } from './define-hook.js';
@@ -7,9 +9,9 @@ export { getWritable } from './writable-stream.js';
 // workflows can't use these functions, but we still need to provide
 // the export so bundling doesn't fail when step and workflow are in same file
 export function getStepMetadata() {
-    throw new Error('`getStepMetadata()` can only be called inside a step function');
+    throwNotInStepContext('getStepMetadata()', 'https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata', getStepMetadata);
 }
 export function resumeHook() {
-    throw new Error('`resumeHook()` can only be called from outside a workflow function');
+    throwUnavailableInWorkflowContext('resumeHook()', 'https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook', resumeHook);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd29ya2Zsb3cvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUNMLFVBQVUsRUFDVixjQUFjLEdBRWYsTUFBTSxrQkFBa0IsQ0FBQztBQUUxQixPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxVQUFVLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDN0QsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVuRCxvRUFBb0U7QUFDcEUsOEVBQThFO0FBQzlFLE1BQU0sVUFBVSxlQUFlO0lBQzdCLE1BQU0sSUFBSSxLQUFLLENBQ2IsK0RBQStELENBQ2hFLENBQUM7QUFDSixDQUFDO0FBQ0QsTUFBTSxVQUFVLFVBQVU7SUFDeEIsTUFBTSxJQUFJLEtBQUssQ0FDYixvRUFBb0UsQ0FDckUsQ0FBQztBQUNKLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,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