@workflow/core 5.0.0-beta.5 → 5.0.0-beta.50

package/dist/set-attributes.d.ts

@@ -0,0 +1,13 @@
+import type { SetAttributesOptions } from './workflow/set-attributes.js';
+export type { 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>;
+//# 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,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE,YAAY,EAAE,oBAAoB,EAAE,CAAC;AAErC;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACzC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CA+Cf"}

package/dist/set-attributes.js

@@ -0,0 +1,60 @@
+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();
+    // Deliberately unguarded, unlike the attr_set a suspension writes: this call
+    // runs inside a step body, which holds no replay snapshot, so there is no
+    // event log to compare against and nothing a precondition could fence. It is
+    // a genuinely out-of-band write from the event log's point of view.
+    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 }
+                : {}),
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/source-map.d.ts

@@ -1,6 +1,31 @@
+/**
+ * Strip the trailing `//# sourceMappingURL=data:…` comment from a JS
+ * bundle. Returns the input unchanged if no trailing inline map is
+ * present.
+ *
+ * Use this on the host side before evaluating workflow bundles inside
+ * the QuickJS VM: the inline map can account for several MB of bundle
+ * text (measured ~30%+ of VM heap bytes on the example workbench's
+ * bundle), and the VM never needs it; only host-side `remapErrorStack`
+ * reads the map (and it can do so against the original, unstripped
+ * string).
+ *
+ * Implemented as a linear `lastIndexOf` + character scan rather than a
+ * regex: on webpack dev-server bundles (tens of MB, with hundreds of
+ * per-module inline map comments embedded in eval strings) a
+ * `String.replace` regex over the bundle blows V8's call stack
+ * ("RangeError: Maximum call stack size exceeded"), wedging every
+ * workflow invocation on that framework.
+ */
+export declare function stripInlineSourceMap(workflowCode: string): string;
 /**
  * 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":"AAOA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAqBjE;AA4GD;;;;;;;;;;;;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,168 @@
 import { originalPositionFor, TraceMap } from '@jridgewell/trace-mapping';
+import { globalSingleton } from '@workflow/utils';
+/** Marker prefix of an inline source map comment emitted by bundlers. */
+const INLINE_SOURCE_MAP_MARKER = '//# sourceMappingURL=data:application/json;base64,';
+/**
+ * Strip the trailing `//# sourceMappingURL=data:…` comment from a JS
+ * bundle. Returns the input unchanged if no trailing inline map is
+ * present.
+ *
+ * Use this on the host side before evaluating workflow bundles inside
+ * the QuickJS VM: the inline map can account for several MB of bundle
+ * text (measured ~30%+ of VM heap bytes on the example workbench's
+ * bundle), and the VM never needs it; only host-side `remapErrorStack`
+ * reads the map (and it can do so against the original, unstripped
+ * string).
+ *
+ * Implemented as a linear `lastIndexOf` + character scan rather than a
+ * regex: on webpack dev-server bundles (tens of MB, with hundreds of
+ * per-module inline map comments embedded in eval strings) a
+ * `String.replace` regex over the bundle blows V8's call stack
+ * ("RangeError: Maximum call stack size exceeded"), wedging every
+ * workflow invocation on that framework.
+ */
+export function stripInlineSourceMap(workflowCode) {
+    const idx = workflowCode.lastIndexOf(INLINE_SOURCE_MAP_MARKER);
+    if (idx === -1)
+        return workflowCode;
+    // Only strip when the comment is the TRAILING content: everything
+    // after the marker must be base64 payload followed by optional
+    // whitespace. A mid-bundle occurrence (e.g. inside a string literal)
+    // is left untouched.
+    let i = idx + INLINE_SOURCE_MAP_MARKER.length;
+    const payloadStart = i;
+    const n = workflowCode.length;
+    while (i < n && isBase64Char(workflowCode.charCodeAt(i)))
+        i++;
+    if (i === payloadStart)
+        return workflowCode;
+    while (i < n) {
+        const c = workflowCode.charCodeAt(i);
+        // space, tab, newline, carriage return
+        if (c !== 0x20 && c !== 0x09 && c !== 0x0a && c !== 0x0d) {
+            return workflowCode;
+        }
+        i++;
+    }
+    return workflowCode.slice(0, idx);
+}
+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.
+ */
+// On `globalThis` (see `globalSingleton`): the cache exists to avoid re-parsing
+// one build-time bundle for the life of the process, which per-copy state would
+// do once per bundler layer.
+const tracers = globalSingleton('@workflow/core//sourceMapTracers', 1, () => ({
+    byCode: new Map(),
+}));
+const MAX_TRACERS = 8;
+function getTraceMapForCode(workflowCode) {
+    const cached = tracers.byCode.get(workflowCode);
+    if (cached !== undefined) {
+        // Move to most-recently-used position (end of insertion order).
+        tracers.byCode.delete(workflowCode);
+        tracers.byCode.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;
+        }
+    }
+    tracers.byCode.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 (tracers.byCode.size > MAX_TRACERS) {
+        const oldest = tracers.byCode.keys().next().value;
+        if (oldest === undefined)
+            break;
+        tracers.byCode.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 +192,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';\nimport { globalSingleton } from '@workflow/utils';\n\n/** Marker prefix of an inline source map comment emitted by bundlers. */\nconst INLINE_SOURCE_MAP_MARKER =\n  '//# sourceMappingURL=data:application/json;base64,';\n\n/**\n * Strip the trailing `//# sourceMappingURL=data:…` comment from a JS\n * bundle. Returns the input unchanged if no trailing inline map is\n * present.\n *\n * Use this on the host side before evaluating workflow bundles inside\n * the QuickJS VM: the inline map can account for several MB of bundle\n * text (measured ~30%+ of VM heap bytes on the example workbench's\n * bundle), and the VM never needs it; only host-side `remapErrorStack`\n * reads the map (and it can do so against the original, unstripped\n * string).\n *\n * Implemented as a linear `lastIndexOf` + character scan rather than a\n * regex: on webpack dev-server bundles (tens of MB, with hundreds of\n * per-module inline map comments embedded in eval strings) a\n * `String.replace` regex over the bundle blows V8's call stack\n * (\"RangeError: Maximum call stack size exceeded\"), wedging every\n * workflow invocation on that framework.\n */\nexport function stripInlineSourceMap(workflowCode: string): string {\n  const idx = workflowCode.lastIndexOf(INLINE_SOURCE_MAP_MARKER);\n  if (idx === -1) return workflowCode;\n  // Only strip when the comment is the TRAILING content: everything\n  // after the marker must be base64 payload followed by optional\n  // whitespace. A mid-bundle occurrence (e.g. inside a string literal)\n  // is left untouched.\n  let i = idx + INLINE_SOURCE_MAP_MARKER.length;\n  const payloadStart = i;\n  const n = workflowCode.length;\n  while (i < n && isBase64Char(workflowCode.charCodeAt(i))) i++;\n  if (i === payloadStart) return workflowCode;\n  while (i < n) {\n    const c = workflowCode.charCodeAt(i);\n    // space, tab, newline, carriage return\n    if (c !== 0x20 && c !== 0x09 && c !== 0x0a && c !== 0x0d) {\n      return workflowCode;\n    }\n    i++;\n  }\n  return workflowCode.slice(0, idx);\n}\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 */\n// On `globalThis` (see `globalSingleton`): the cache exists to avoid re-parsing\n// one build-time bundle for the life of the process, which per-copy state would\n// do once per bundler layer.\nconst tracers = globalSingleton('@workflow/core//sourceMapTracers', 1, () => ({\n  byCode: new Map<string, TraceMap | null>(),\n}));\nconst MAX_TRACERS = 8;\n\nfunction getTraceMapForCode(workflowCode: string): TraceMap | null {\n  const cached = tracers.byCode.get(workflowCode);\n  if (cached !== undefined) {\n    // Move to most-recently-used position (end of insertion order).\n    tracers.byCode.delete(workflowCode);\n    tracers.byCode.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  tracers.byCode.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 (tracers.byCode.size > MAX_TRACERS) {\n    const oldest = tracers.byCode.keys().next().value;\n    if (oldest === undefined) break;\n    tracers.byCode.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,72 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
-import type { CryptoKey } from '../encryption.js';
+import type { FlushableStreamState } from '../flushable-stream.js';
+import type { PayloadKey } from '../serialization/encryption.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;
+    /**
+     * Root run id of the current run's lineage (`$rootRunId`), so a nested
+     * `start()` inherits it without reloading the parent. Set by the runtime from
+     * the run it already has loaded.
+     */
+    rootRunId?: 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;
+    encryptionKey?: PayloadKey;
+    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,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,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;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,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,UAAU,CAAC;IAC3B,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,CAItD,CAAC"}

package/dist/step/context-storage.js

@@ -4,7 +4,7 @@ import { AsyncLocalStorage } from 'node:async_hooks';
  *
  * Uses `Symbol.for()` on globalThis to guarantee a single instance even when
  * bundlers (e.g. Vercel's production bundler) create multiple copies of this
- * module. Without this, `contextStorage.run()` in the step handler and
+ * module. Without this, `contextStorage.run()` in the step executor and
  * `contextStorage.getStore()` in user code (via getWorkflowMetadata /
  * getStepMetadata) can reference different AsyncLocalStorage instances,
  * causing the store to appear empty.
@@ -16,7 +16,9 @@ import { AsyncLocalStorage } from 'node:async_hooks';
  * See: https://github.com/vercel/workflow/issues/1577
  */
 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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
+export const contextStorage = (() => {
+    const store = globalThis;
+    store[CONTEXT_STORAGE_SYMBOL] ??= new AsyncLocalStorage();
+    return store[CONTEXT_STORAGE_SYMBOL];
+})();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -9,10 +9,10 @@ export interface WorkflowWritableStreamOptions {
     namespace?: string;
 }
 /**
- * Retrieves a writable stream that is associated with the current workflow.
+ * Retrieves the writable stream associated with the current workflow.
  *
- * The writable stream is intended to be used within step functions to write
- * data that can be read outside the workflow by using the readable method of getRun.
+ * Use the writable stream within step functions to write data. Read the data
+ * outside the workflow by using the readable method of `getRun`.
  *
  * @param options - Optional configuration for the writable stream
  * @returns The writable stream associated with the current workflow run

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":"AAcA;;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,CAoCnB"}
+{"version":3,"file":"writable-stream.d.ts","sourceRoot":"","sources":["../../src/step/writable-stream.ts"],"names":[],"mappings":"AAsBA;;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,CAkHnB"}