@workflow/core 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/set-attributes.d.ts

@@ -0,0 +1,18 @@
+import type { ExperimentalSetAttributesOptions, SetAttributesOptions } from './workflow/set-attributes.js';
+export type { ExperimentalSetAttributesOptions, SetAttributesOptions };
+/**
+ * Host-side implementation for `setAttributes`. Workflow bodies resolve
+ * to `./workflow/set-attributes.ts` via the `workflow` package-exports
+ * condition; step bodies resolve here and can perform the world write
+ * directly because they already run in host context.
+ *
+ * Plain application code still has no active workflow run, so it throws
+ * a clear `FatalError`.
+ */
+export declare function setAttributes(attrs: Record<string, string | undefined>, options?: SetAttributesOptions): Promise<void>;
+/**
+ * @deprecated The feature is no longer experimental — use
+ * {@link setAttributes} instead.
+ */
+export declare const experimental_setAttributes: typeof setAttributes;
+//# sourceMappingURL=set-attributes.d.ts.map

package/dist/set-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-attributes.d.ts","sourceRoot":"","sources":["../src/set-attributes.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,gCAAgC,EAChC,oBAAoB,EACrB,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,gCAAgC,EAAE,oBAAoB,EAAE,CAAC;AAEvE;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACzC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CA2Cf;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,sBAAgB,CAAC"}

package/dist/set-attributes.js

@@ -0,0 +1,61 @@
+import { FatalError } from '@workflow/errors';
+import { SPEC_VERSION_CURRENT } from '@workflow/world';
+import { normalizeAttributeChanges } from './attribute-changes.js';
+import { getWorldLazy } from './runtime/get-world-lazy.js';
+import { contextStorage } from './step/context-storage.js';
+/**
+ * Host-side implementation for `setAttributes`. Workflow bodies resolve
+ * to `./workflow/set-attributes.ts` via the `workflow` package-exports
+ * condition; step bodies resolve here and can perform the world write
+ * directly because they already run in host context.
+ *
+ * Plain application code still has no active workflow run, so it throws
+ * a clear `FatalError`.
+ */
+export async function setAttributes(attrs, options = {}) {
+    const store = contextStorage.getStore();
+    const runId = store?.workflowMetadata?.workflowRunId;
+    if (!runId) {
+        throw new FatalError("setAttributes() must be called from a 'use workflow' or 'use step' function. " +
+            'Calling it from plain host code is not supported.');
+    }
+    const changes = normalizeAttributeChanges(attrs, options);
+    if (changes.length === 0)
+        return;
+    // Turbo optimistic start runs the step body before the backgrounded
+    // `run_started` is durable. Order this `attr_set` after the run exists so it
+    // never reaches the World before the run does (which would be rejected as
+    // run-not-found). A no-op outside turbo (barrier undefined) and on the await
+    // path. The rejection is swallowed for ordering only: if `run_started` truly
+    // failed the run does not exist, so the create below surfaces the real error.
+    if (store.runReadyBarrier) {
+        try {
+            await store.runReadyBarrier;
+        }
+        catch {
+            // intentional: ordering barrier only — see above.
+        }
+    }
+    const world = await getWorldLazy();
+    await world.events.create(runId, {
+        eventType: 'attr_set',
+        specVersion: SPEC_VERSION_CURRENT,
+        eventData: {
+            changes,
+            writer: {
+                type: 'step',
+                stepId: store.stepMetadata.stepId,
+                attempt: store.stepMetadata.attempt,
+            },
+            ...(options.allowReservedAttributes === true
+                ? { allowReservedAttributes: true }
+                : {}),
+        },
+    });
+}
+/**
+ * @deprecated The feature is no longer experimental — use
+ * {@link setAttributes} instead.
+ */
+export const experimental_setAttributes = setAttributes;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/sleep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../src/sleep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC;AAGtC;;;;;;;;;GASG;AACH,wBAAsB,KAAK,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAElE;;;;;;;;GAQG;AACH,wBAAsB,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEvD;;;;;;;;GAQG;AACH,wBAAsB,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC"}
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../src/sleep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC;AAItC;;;;;;;;;GASG;AACH,wBAAsB,KAAK,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAElE;;;;;;;;GAQG;AACH,wBAAsB,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEvD;;;;;;;;GAQG;AACH,wBAAsB,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC"}

package/dist/sleep.js

@@ -1,10 +1,11 @@
+import { throwNotInWorkflowContext } from './context-errors.js';
 import { WORKFLOW_SLEEP } from './symbols.js';
 export async function sleep(param) {
     // Inside the workflow VM, the sleep function is stored in the globalThis object behind a symbol
     const sleepFn = globalThis[WORKFLOW_SLEEP];
     if (!sleepFn) {
-        throw new Error('`sleep()` can only be called inside a workflow function');
+        throwNotInWorkflowContext('sleep()', 'https://workflow-sdk.dev/docs/api-reference/workflow/sleep', sleep);
     }
     return sleepFn(param);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/source-map.d.ts

@@ -1,6 +1,11 @@
 /**
  * Remaps an error stack trace using inline source maps to show original source locations.
  *
+ * Degrades gracefully when the bundle has no inline source map (e.g. production
+ * builds, where maps are off by default): the original stack is returned
+ * unchanged. A cheap `filename` presence check skips all work when no frame
+ * references the workflow file, and parsed source maps are memoized per bundle.
+ *
  * @param stack - The error stack trace to remap
  * @param filename - The workflow filename to match in stack frames
  * @param workflowCode - The workflow bundle code containing inline source maps

package/dist/source-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-map.d.ts","sourceRoot":"","sources":["../src/source-map.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,MAAM,CA0DR"}
+{"version":3,"file":"source-map.d.ts","sourceRoot":"","sources":["../src/source-map.ts"],"names":[],"mappings":"AAuGA;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,MAAM,CAsDR"}

package/dist/source-map.js

@@ -1,24 +1,116 @@
 import { originalPositionFor, TraceMap } from '@jridgewell/trace-mapping';
+function isBase64Char(code) {
+    return ((code >= 0x41 && code <= 0x5a) ||
+        (code >= 0x61 && code <= 0x7a) ||
+        (code >= 0x30 && code <= 0x39) ||
+        code === 0x2b ||
+        code === 0x2f ||
+        code === 0x3d);
+}
+function extractInlineSourceMapBase64(source) {
+    const sourceMapPrefix = '//# sourceMappingURL=data:application/json';
+    const base64Marker = ';base64,';
+    let scanFrom = 0;
+    while (scanFrom < source.length) {
+        const prefixIdx = source.indexOf(sourceMapPrefix, scanFrom);
+        if (prefixIdx === -1)
+            return undefined;
+        const base64Start = source.indexOf(base64Marker, prefixIdx + sourceMapPrefix.length);
+        if (base64Start === -1) {
+            scanFrom = prefixIdx + sourceMapPrefix.length;
+            continue;
+        }
+        const commaBefore = source.indexOf(',', prefixIdx);
+        if (commaBefore !== -1 && commaBefore < base64Start) {
+            scanFrom = base64Start + base64Marker.length;
+            continue;
+        }
+        const valueStart = base64Start + base64Marker.length;
+        let valueEnd = valueStart;
+        while (valueEnd < source.length) {
+            if (!isBase64Char(source.charCodeAt(valueEnd))) {
+                break;
+            }
+            valueEnd++;
+        }
+        if (valueEnd > valueStart) {
+            return source.slice(valueStart, valueEnd);
+        }
+        scanFrom = valueEnd;
+    }
+}
+/**
+ * Memoized `TraceMap | null` per workflow bundle. `null` records "this bundle
+ * has no usable inline source map" so repeated failures don't rescan the whole
+ * (potentially multi-MB) bundle string or re-parse the map. This matters most
+ * in production, where source maps are off by default: the first failure scans
+ * once and caches `null`, every later failure is O(1).
+ *
+ * Keyed by the bundle `code`. Insertion-ordered LRU capped at `MAX_TRACERS`,
+ * mirroring `vm/script-cache.ts`: production serves a single build-time bundle
+ * literal for the process lifetime, while dev/watch produces a new bundle
+ * string per edit — the bound keeps the few most-recent ones and evicts the
+ * rest instead of pinning every historical version.
+ */
+const tracerCache = new Map();
+const MAX_TRACERS = 8;
+function getTraceMapForCode(workflowCode) {
+    const cached = tracerCache.get(workflowCode);
+    if (cached !== undefined) {
+        // Move to most-recently-used position (end of insertion order).
+        tracerCache.delete(workflowCode);
+        tracerCache.set(workflowCode, cached);
+        return cached;
+    }
+    let tracer = null;
+    const base64 = extractInlineSourceMapBase64(workflowCode);
+    if (base64) {
+        try {
+            const sourceMapJson = Buffer.from(base64, 'base64').toString('utf-8');
+            const sourceMapData = JSON.parse(sourceMapJson);
+            // Use TraceMap (pure JS, no WASM required)
+            tracer = new TraceMap(sourceMapData);
+        }
+        catch {
+            // Malformed inline map — treat as absent so we don't retry parsing it.
+            tracer = null;
+        }
+    }
+    tracerCache.set(workflowCode, tracer);
+    // Evict the least-recently-used entries when over the cap. New entries are
+    // appended at the end, so the oldest live at the front.
+    while (tracerCache.size > MAX_TRACERS) {
+        const oldest = tracerCache.keys().next().value;
+        if (oldest === undefined)
+            break;
+        tracerCache.delete(oldest);
+    }
+    return tracer;
+}
 /**
  * Remaps an error stack trace using inline source maps to show original source locations.
  *
+ * Degrades gracefully when the bundle has no inline source map (e.g. production
+ * builds, where maps are off by default): the original stack is returned
+ * unchanged. A cheap `filename` presence check skips all work when no frame
+ * references the workflow file, and parsed source maps are memoized per bundle.
+ *
  * @param stack - The error stack trace to remap
  * @param filename - The workflow filename to match in stack frames
  * @param workflowCode - The workflow bundle code containing inline source maps
  * @returns The remapped stack trace with original source locations
  */
 export function remapErrorStack(stack, filename, workflowCode) {
-    // Extract inline source map from workflow code
-    const sourceMapMatch = workflowCode.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
-    if (!sourceMapMatch) {
+    // Nothing to remap if no frame references the workflow file. Avoids touching
+    // the (large) bundle string entirely for errors thrown elsewhere.
+    if (!stack.includes(filename)) {
+        return stack;
+    }
+    const tracer = getTraceMapForCode(workflowCode);
+    if (!tracer) {
         return stack; // No source map found
     }
     try {
-        const base64 = sourceMapMatch[1];
-        const sourceMapJson = Buffer.from(base64, 'base64').toString('utf-8');
-        const sourceMapData = JSON.parse(sourceMapJson);
-        // Use TraceMap (pure JS, no WASM required)
-        const tracer = new TraceMap(sourceMapData);
         // Parse and remap each line in the stack trace
         const lines = stack.split('\n');
         const remappedLines = lines.map((line) => {
@@ -48,9 +140,9 @@ export function remapErrorStack(stack, filename, workflowCode) {
         });
         return remappedLines.join('\n');
     }
-    catch (e) {
+    catch {
         // If source map processing fails, return original stack
         return stack;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-map.js","sourceRoot":"","sources":["../src/source-map.ts"],"names":[],"mappings":"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","sourcesContent":["import { originalPositionFor, TraceMap } from '@jridgewell/trace-mapping';\n\nfunction isBase64Char(code: number): boolean {\n  return (\n    (code >= 0x41 && code <= 0x5a) ||\n    (code >= 0x61 && code <= 0x7a) ||\n    (code >= 0x30 && code <= 0x39) ||\n    code === 0x2b ||\n    code === 0x2f ||\n    code === 0x3d\n  );\n}\n\nfunction extractInlineSourceMapBase64(source: string): string | undefined {\n  const sourceMapPrefix = '//# sourceMappingURL=data:application/json';\n  const base64Marker = ';base64,';\n  let scanFrom = 0;\n\n  while (scanFrom < source.length) {\n    const prefixIdx = source.indexOf(sourceMapPrefix, scanFrom);\n    if (prefixIdx === -1) return undefined;\n\n    const base64Start = source.indexOf(\n      base64Marker,\n      prefixIdx + sourceMapPrefix.length\n    );\n    if (base64Start === -1) {\n      scanFrom = prefixIdx + sourceMapPrefix.length;\n      continue;\n    }\n\n    const commaBefore = source.indexOf(',', prefixIdx);\n    if (commaBefore !== -1 && commaBefore < base64Start) {\n      scanFrom = base64Start + base64Marker.length;\n      continue;\n    }\n\n    const valueStart = base64Start + base64Marker.length;\n    let valueEnd = valueStart;\n    while (valueEnd < source.length) {\n      if (!isBase64Char(source.charCodeAt(valueEnd))) {\n        break;\n      }\n      valueEnd++;\n    }\n\n    if (valueEnd > valueStart) {\n      return source.slice(valueStart, valueEnd);\n    }\n    scanFrom = valueEnd;\n  }\n}\n\n/**\n * Memoized `TraceMap | null` per workflow bundle. `null` records \"this bundle\n * has no usable inline source map\" so repeated failures don't rescan the whole\n * (potentially multi-MB) bundle string or re-parse the map. This matters most\n * in production, where source maps are off by default: the first failure scans\n * once and caches `null`, every later failure is O(1).\n *\n * Keyed by the bundle `code`. Insertion-ordered LRU capped at `MAX_TRACERS`,\n * mirroring `vm/script-cache.ts`: production serves a single build-time bundle\n * literal for the process lifetime, while dev/watch produces a new bundle\n * string per edit — the bound keeps the few most-recent ones and evicts the\n * rest instead of pinning every historical version.\n */\nconst tracerCache = new Map<string, TraceMap | null>();\nconst MAX_TRACERS = 8;\n\nfunction getTraceMapForCode(workflowCode: string): TraceMap | null {\n  const cached = tracerCache.get(workflowCode);\n  if (cached !== undefined) {\n    // Move to most-recently-used position (end of insertion order).\n    tracerCache.delete(workflowCode);\n    tracerCache.set(workflowCode, cached);\n    return cached;\n  }\n\n  let tracer: TraceMap | null = null;\n  const base64 = extractInlineSourceMapBase64(workflowCode);\n  if (base64) {\n    try {\n      const sourceMapJson = Buffer.from(base64, 'base64').toString('utf-8');\n      const sourceMapData = JSON.parse(sourceMapJson);\n      // Use TraceMap (pure JS, no WASM required)\n      tracer = new TraceMap(sourceMapData);\n    } catch {\n      // Malformed inline map — treat as absent so we don't retry parsing it.\n      tracer = null;\n    }\n  }\n\n  tracerCache.set(workflowCode, tracer);\n  // Evict the least-recently-used entries when over the cap. New entries are\n  // appended at the end, so the oldest live at the front.\n  while (tracerCache.size > MAX_TRACERS) {\n    const oldest = tracerCache.keys().next().value;\n    if (oldest === undefined) break;\n    tracerCache.delete(oldest);\n  }\n  return tracer;\n}\n\n/**\n * Remaps an error stack trace using inline source maps to show original source locations.\n *\n * Degrades gracefully when the bundle has no inline source map (e.g. production\n * builds, where maps are off by default): the original stack is returned\n * unchanged. A cheap `filename` presence check skips all work when no frame\n * references the workflow file, and parsed source maps are memoized per bundle.\n *\n * @param stack - The error stack trace to remap\n * @param filename - The workflow filename to match in stack frames\n * @param workflowCode - The workflow bundle code containing inline source maps\n * @returns The remapped stack trace with original source locations\n */\nexport function remapErrorStack(\n  stack: string,\n  filename: string,\n  workflowCode: string\n): string {\n  // Nothing to remap if no frame references the workflow file. Avoids touching\n  // the (large) bundle string entirely for errors thrown elsewhere.\n  if (!stack.includes(filename)) {\n    return stack;\n  }\n\n  const tracer = getTraceMapForCode(workflowCode);\n  if (!tracer) {\n    return stack; // No source map found\n  }\n\n  try {\n    // Parse and remap each line in the stack trace\n    const lines = stack.split('\\n');\n    const remappedLines = lines.map((line) => {\n      // Match stack frames: \"at functionName (filename:line:column)\" or \"at filename:line:column\"\n      const frameMatch = line.match(\n        /^\\s*at\\s+(?:(.+?)\\s+\\()?(.+?):(\\d+):(\\d+)\\)?$/\n      );\n      if (!frameMatch) {\n        return line; // Not a stack frame, return as-is\n      }\n\n      const [, functionName, file, lineStr, colStr] = frameMatch;\n\n      // Only remap frames from our workflow file\n      if (!file.includes(filename)) {\n        return line;\n      }\n\n      const lineNumber = parseInt(lineStr, 10);\n      const columnNumber = parseInt(colStr, 10);\n\n      // Map to original source position\n      const original = originalPositionFor(tracer, {\n        line: lineNumber,\n        column: columnNumber,\n      });\n\n      if (original.source && original.line !== null) {\n        const func = functionName || original.name || 'anonymous';\n        const col = original.column !== null ? original.column : columnNumber;\n        return `    at ${func} (${original.source}:${original.line}:${col})`;\n      }\n\n      return line; // Couldn't map, return original\n    });\n\n    return remappedLines.join('\\n');\n  } catch {\n    // If source map processing fails, return original stack\n    return stack;\n  }\n}\n"]}

package/dist/step/context-storage.d.ts

@@ -1,13 +1,66 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import type { CryptoKey } from '../encryption.js';
+import type { FlushableStreamState } from '../flushable-stream.js';
 import type { WorkflowMetadata } from '../workflow/get-workflow-metadata.js';
 import type { StepMetadata } from './get-step-metadata.js';
+/**
+ * Per-step cache entry for a `(runId, namespace)` writable stream.
+ *
+ * Holds the user-facing `WritableStream` and the shared `FlushableStreamState`
+ * driving the background pipe to the workflow server. Re-used so repeat calls
+ * to `getWritable()` within the same step return the same handle instead of
+ * spawning racing pipes — see https://github.com/vercel/workflow/issues/2058.
+ */
+export interface CachedWritable {
+    writable: WritableStream<any>;
+    state: FlushableStreamState;
+}
 export type StepContext = {
     stepMetadata: StepMetadata;
     workflowMetadata: WorkflowMetadata;
+    /** Deployment that owns the current workflow run, used for forwarded streams. */
+    workflowDeploymentId?: string;
     ops: Promise<void>[];
+    /**
+     * Operations that MUST be durably committed before the step's
+     * `step_completed`/`step_failed` event is written, because the workflow
+     * continuation triggered by that event depends on them.
+     *
+     * The canonical case is a step-initiated `AbortController.abort()`: the
+     * durable `hook_received` event records the cancellation in the workflow's
+     * event log. If it is flushed in the background (like `ops`), the workflow
+     * continuation enqueued by `step_completed` can run — and advance past the
+     * abort, dispatching a later step with a stale, non-aborted `signal` — before
+     * the `hook_received` event exists. Awaiting these inline before completion
+     * guarantees the abort is ordered ahead of any continuation that observes the
+     * step's result. Unlike these, `ops` holds best-effort real-time stream
+     * writes that should fire ASAP and are intentionally left in the background.
+     *
+     * Contract: producers MUST NOT push a promise that can reject — these are
+     * awaited only to enforce ordering, never to surface an outcome. A rejection
+     * here would propagate as an infra error (queue re-delivery), not the
+     * user-code failure path, so each producer swallows its own errors (see
+     * `reviveAbortController` in serialization.ts). The await sites also
+     * defensively `.catch()` so ordering is all this bucket can ever enforce.
+     *
+     * Required (not optional) so a new step-context construction site that
+     * forgets to wire it fails at compile time, rather than silently regressing
+     * the ordering guarantee back to background-flush behavior.
+     */
+    preCompletionOps: Promise<void>[];
     closureVars?: Record<string, any>;
     encryptionKey?: CryptoKey;
+    writables?: Map<string, CachedWritable>;
+    /**
+     * Turbo mode only: a promise that resolves once the backgrounded
+     * `run_started` has landed (the run exists). Set when the step body runs
+     * optimistically — before `run_started`/`step_started` are confirmed — so a
+     * direct step-body world write (e.g. `setAttributes`, which
+     * resolves to a host-side `attr_set` create) can gate on it and never race
+     * ahead of the run's creation. `undefined` outside turbo and on the await
+     * path, where `run_started` was already durable before the body ran.
+     */
+    runReadyBarrier?: Promise<unknown>;
 };
 export declare const contextStorage: AsyncLocalStorage<StepContext>;
 //# sourceMappingURL=context-storage.d.ts.map

package/dist/step/context-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context-storage.d.ts","sourceRoot":"","sources":["../../src/step/context-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,MAAM,MAAM,WAAW,GAAG;IACxB,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,GAAG,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAClC,aAAa,CAAC,EAAE,SAAS,CAAC;CAC3B,CAAC;AAoBF,eAAO,MAAM,cAAc,EAAE,iBAAiB,CAAC,WAAW,CAKjB,CAAC"}
+{"version":3,"file":"context-storage.d.ts","sourceRoot":"","sources":["../../src/step/context-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC;IAC9B,KAAK,EAAE,oBAAoB,CAAC;CAC7B;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,iFAAiF;IACjF,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,GAAG,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;IACrB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,gBAAgB,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAClC,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACxC;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CACpC,CAAC;AAoBF,eAAO,MAAM,cAAc,EAAE,iBAAiB,CAAC,WAAW,CAKjB,CAAC"}

package/dist/step/context-storage.js

@@ -19,4 +19,4 @@ const CONTEXT_STORAGE_SYMBOL = Symbol.for('WORKFLOW_STEP_CONTEXT_STORAGE');
 export const contextStorage = globalThis[CONTEXT_STORAGE_SYMBOL] ??
     (globalThis[CONTEXT_STORAGE_SYMBOL] =
         new AsyncLocalStorage());
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/step/get-closure-vars.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-closure-vars.d.ts","sourceRoot":"","sources":["../../src/step/get-closure-vars.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQ9D"}
+{"version":3,"file":"get-closure-vars.d.ts","sourceRoot":"","sources":["../../src/step/get-closure-vars.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQ9D"}

package/dist/step/get-closure-vars.js

@@ -1,3 +1,4 @@
+import { WorkflowRuntimeError } from '@workflow/errors';
 import { contextStorage } from './context-storage.js';
 /**
  * Returns the closure variables for the current step function.
@@ -9,8 +10,8 @@ import { contextStorage } from './context-storage.js';
 export function __private_getClosureVars() {
     const ctx = contextStorage.getStore();
     if (!ctx) {
-        throw new Error('Closure variables can only be accessed inside a step function');
+        throw new WorkflowRuntimeError('Closure variables can only be accessed inside a step function');
     }
     return ctx.closureVars || {};
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWNsb3N1cmUtdmFycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdGVwL2dldC1jbG9zdXJlLXZhcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRXREOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSx3QkFBd0I7SUFDdEMsTUFBTSxHQUFHLEdBQUcsY0FBYyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3RDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNULE1BQU0sSUFBSSxLQUFLLENBQ2IsK0RBQStELENBQ2hFLENBQUM7SUFDSixDQUFDO0lBQ0QsT0FBTyxHQUFHLENBQUMsV0FBVyxJQUFJLEVBQUUsQ0FBQztBQUMvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY29udGV4dFN0b3JhZ2UgfSBmcm9tICcuL2NvbnRleHQtc3RvcmFnZS5qcyc7XG5cbi8qKlxuICogUmV0dXJucyB0aGUgY2xvc3VyZSB2YXJpYWJsZXMgZm9yIHRoZSBjdXJyZW50IHN0ZXAgZnVuY3Rpb24uXG4gKiBUaGlzIGlzIGFuIGludGVybmFsIGZ1bmN0aW9uIHVzZWQgYnkgdGhlIFNXQyB0cmFuc2Zvcm0gdG8gYWNjZXNzXG4gKiB2YXJpYWJsZXMgZnJvbSB0aGUgcGFyZW50IHdvcmtmbG93IHNjb3BlLlxuICpcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgZnVuY3Rpb24gX19wcml2YXRlX2dldENsb3N1cmVWYXJzKCk6IFJlY29yZDxzdHJpbmcsIGFueT4ge1xuICBjb25zdCBjdHggPSBjb250ZXh0U3RvcmFnZS5nZXRTdG9yZSgpO1xuICBpZiAoIWN0eCkge1xuICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICdDbG9zdXJlIHZhcmlhYmxlcyBjYW4gb25seSBiZSBhY2Nlc3NlZCBpbnNpZGUgYSBzdGVwIGZ1bmN0aW9uJ1xuICAgICk7XG4gIH1cbiAgcmV0dXJuIGN0eC5jbG9zdXJlVmFycyB8fCB7fTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWNsb3N1cmUtdmFycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdGVwL2dldC1jbG9zdXJlLXZhcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRXREOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSx3QkFBd0I7SUFDdEMsTUFBTSxHQUFHLEdBQUcsY0FBYyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3RDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNULE1BQU0sSUFBSSxvQkFBb0IsQ0FDNUIsK0RBQStELENBQ2hFLENBQUM7SUFDSixDQUFDO0lBQ0QsT0FBTyxHQUFHLENBQUMsV0FBVyxJQUFJLEVBQUUsQ0FBQztBQUMvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgV29ya2Zsb3dSdW50aW1lRXJyb3IgfSBmcm9tICdAd29ya2Zsb3cvZXJyb3JzJztcbmltcG9ydCB7IGNvbnRleHRTdG9yYWdlIH0gZnJvbSAnLi9jb250ZXh0LXN0b3JhZ2UuanMnO1xuXG4vKipcbiAqIFJldHVybnMgdGhlIGNsb3N1cmUgdmFyaWFibGVzIGZvciB0aGUgY3VycmVudCBzdGVwIGZ1bmN0aW9uLlxuICogVGhpcyBpcyBhbiBpbnRlcm5hbCBmdW5jdGlvbiB1c2VkIGJ5IHRoZSBTV0MgdHJhbnNmb3JtIHRvIGFjY2Vzc1xuICogdmFyaWFibGVzIGZyb20gdGhlIHBhcmVudCB3b3JrZmxvdyBzY29wZS5cbiAqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIF9fcHJpdmF0ZV9nZXRDbG9zdXJlVmFycygpOiBSZWNvcmQ8c3RyaW5nLCBhbnk+IHtcbiAgY29uc3QgY3R4ID0gY29udGV4dFN0b3JhZ2UuZ2V0U3RvcmUoKTtcbiAgaWYgKCFjdHgpIHtcbiAgICB0aHJvdyBuZXcgV29ya2Zsb3dSdW50aW1lRXJyb3IoXG4gICAgICAnQ2xvc3VyZSB2YXJpYWJsZXMgY2FuIG9ubHkgYmUgYWNjZXNzZWQgaW5zaWRlIGEgc3RlcCBmdW5jdGlvbidcbiAgICApO1xuICB9XG4gIHJldHVybiBjdHguY2xvc3VyZVZhcnMgfHwge307XG59XG4iXX0=

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

@@ -1 +1 @@
-{"version":3,"file":"get-step-metadata.d.ts","sourceRoot":"","sources":["../../src/step/get-step-metadata.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;;;;;OASG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;;;;;OAOG;IACH,aAAa,EAAE,IAAI,CAAC;IAEpB;;;;;;;OAOG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAQ9C"}
+{"version":3,"file":"get-step-metadata.d.ts","sourceRoot":"","sources":["../../src/step/get-step-metadata.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;;;;;OASG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;;;;;OAOG;IACH,aAAa,EAAE,IAAI,CAAC;IAEpB;;;;;;;OAOG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAU9C"}

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

@@ -1,3 +1,4 @@
+import { throwNotInStepContext } from '../context-errors.js';
 import { contextStorage } from './context-storage.js';
 /**
  * Returns metadata available in the current step function.
@@ -7,8 +8,8 @@ import { contextStorage } from './context-storage.js';
 export function getStepMetadata() {
     const ctx = contextStorage.getStore();
     if (!ctx) {
-        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);
     }
     return ctx.stepMetadata;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"get-workflow-metadata.d.ts","sourceRoot":"","sources":["../../src/step/get-workflow-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAG7E,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,CAQtD"}
+{"version":3,"file":"get-workflow-metadata.d.ts","sourceRoot":"","sources":["../../src/step/get-workflow-metadata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAG7E,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,CAUtD"}

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

@@ -1,3 +1,4 @@
+import { throwNotInWorkflowOrStepContext } from '../context-errors.js';
 import { contextStorage } from './context-storage.js';
 /**
  * Returns metadata available in the current workflow run inside a step function.
@@ -5,8 +6,8 @@ import { contextStorage } from './context-storage.js';
 export function getWorkflowMetadata() {
     const ctx = contextStorage.getStore();
     if (!ctx) {
-        throw new Error('`getWorkflowMetadata()` can only be called inside a workflow or step function');
+        throwNotInWorkflowOrStepContext('getWorkflowMetadata()', 'https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata', getWorkflowMetadata);
     }
     return ctx.workflowMetadata;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXdvcmtmbG93LW1ldGFkYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N0ZXAvZ2V0LXdvcmtmbG93LW1ldGFkYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUl0RDs7R0FFRztBQUNILE1BQU0sVUFBVSxtQkFBbUI7SUFDakMsTUFBTSxHQUFHLEdBQUcsY0FBYyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3RDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNULE1BQU0sSUFBSSxLQUFLLENBQ2IsK0VBQStFLENBQ2hGLENBQUM7SUFDSixDQUFDO0lBQ0QsT0FBTyxHQUFHLENBQUMsZ0JBQWdCLENBQUM7QUFDOUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgV29ya2Zsb3dNZXRhZGF0YSB9IGZyb20gJy4uL3dvcmtmbG93L2dldC13b3JrZmxvdy1tZXRhZGF0YS5qcyc7XG5pbXBvcnQgeyBjb250ZXh0U3RvcmFnZSB9IGZyb20gJy4vY29udGV4dC1zdG9yYWdlLmpzJztcblxuZXhwb3J0IHR5cGUgeyBXb3JrZmxvd01ldGFkYXRhIH07XG5cbi8qKlxuICogUmV0dXJucyBtZXRhZGF0YSBhdmFpbGFibGUgaW4gdGhlIGN1cnJlbnQgd29ya2Zsb3cgcnVuIGluc2lkZSBhIHN0ZXAgZnVuY3Rpb24uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRXb3JrZmxvd01ldGFkYXRhKCk6IFdvcmtmbG93TWV0YWRhdGEge1xuICBjb25zdCBjdHggPSBjb250ZXh0U3RvcmFnZS5nZXRTdG9yZSgpO1xuICBpZiAoIWN0eCkge1xuICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICdgZ2V0V29ya2Zsb3dNZXRhZGF0YSgpYCBjYW4gb25seSBiZSBjYWxsZWQgaW5zaWRlIGEgd29ya2Zsb3cgb3Igc3RlcCBmdW5jdGlvbidcbiAgICApO1xuICB9XG4gIHJldHVybiBjdHgud29ya2Zsb3dNZXRhZGF0YTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXdvcmtmbG93LW1ldGFkYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N0ZXAvZ2V0LXdvcmtmbG93LW1ldGFkYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRXZFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUl0RDs7R0FFRztBQUNILE1BQU0sVUFBVSxtQkFBbUI7SUFDakMsTUFBTSxHQUFHLEdBQUcsY0FBYyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3RDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNULCtCQUErQixDQUM3Qix1QkFBdUIsRUFDdkIsNEVBQTRFLEVBQzVFLG1CQUFtQixDQUNwQixDQUFDO0lBQ0osQ0FBQztJQUNELE9BQU8sR0FBRyxDQUFDLGdCQUFnQixDQUFDO0FBQzlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0aHJvd05vdEluV29ya2Zsb3dPclN0ZXBDb250ZXh0IH0gZnJvbSAnLi4vY29udGV4dC1lcnJvcnMuanMnO1xuaW1wb3J0IHR5cGUgeyBXb3JrZmxvd01ldGFkYXRhIH0gZnJvbSAnLi4vd29ya2Zsb3cvZ2V0LXdvcmtmbG93LW1ldGFkYXRhLmpzJztcbmltcG9ydCB7IGNvbnRleHRTdG9yYWdlIH0gZnJvbSAnLi9jb250ZXh0LXN0b3JhZ2UuanMnO1xuXG5leHBvcnQgdHlwZSB7IFdvcmtmbG93TWV0YWRhdGEgfTtcblxuLyoqXG4gKiBSZXR1cm5zIG1ldGFkYXRhIGF2YWlsYWJsZSBpbiB0aGUgY3VycmVudCB3b3JrZmxvdyBydW4gaW5zaWRlIGEgc3RlcCBmdW5jdGlvbi5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFdvcmtmbG93TWV0YWRhdGEoKTogV29ya2Zsb3dNZXRhZGF0YSB7XG4gIGNvbnN0IGN0eCA9IGNvbnRleHRTdG9yYWdlLmdldFN0b3JlKCk7XG4gIGlmICghY3R4KSB7XG4gICAgdGhyb3dOb3RJbldvcmtmbG93T3JTdGVwQ29udGV4dChcbiAgICAgICdnZXRXb3JrZmxvd01ldGFkYXRhKCknLFxuICAgICAgJ2h0dHBzOi8vd29ya2Zsb3ctc2RrLmRldi9kb2NzL2FwaS1yZWZlcmVuY2Uvd29ya2Zsb3cvZ2V0LXdvcmtmbG93LW1ldGFkYXRhJyxcbiAgICAgIGdldFdvcmtmbG93TWV0YWRhdGFcbiAgICApO1xuICB9XG4gIHJldHVybiBjdHgud29ya2Zsb3dNZXRhZGF0YTtcbn1cbiJdfQ==

package/dist/step/writable-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writable-stream.d.ts","sourceRoot":"","sources":["../../src/step/writable-stream.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,GAAG,EACjC,OAAO,GAAE,6BAAkC,GAC1C,cAAc,CAAC,CAAC,CAAC,CAkCnB"}
+{"version":3,"file":"writable-stream.d.ts","sourceRoot":"","sources":["../../src/step/writable-stream.ts"],"names":[],"mappings":"AAmBA;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,GAAG,EACjC,OAAO,GAAE,6BAAkC,GAC1C,cAAc,CAAC,CAAC,CAAC,CAuGnB"}