@workflow/core 5.0.0-beta.4 → 5.0.0-beta.41

package/dist/vm/index.js

@@ -1,7 +1,34 @@
+import { createHash } from 'node:crypto';
+import { types } from 'node:util';
 import { runInContext, createContext as vmCreateContext } from 'node:vm';
+import { WorkflowRuntimeError } from '@workflow/errors';
 import seedrandom from 'seedrandom';
 import { installUint8ArrayBase64 } from './uint8array-base64.js';
 import { createRandomUUID } from './uuid.js';
+// WebCrypto digest algorithm names → node:crypto (OpenSSL) names.
+const DIGEST_ALGORITHMS = {
+    'SHA-1': 'sha1',
+    'SHA-256': 'sha256',
+    'SHA-384': 'sha384',
+    'SHA-512': 'sha512',
+};
+// WebCrypto BufferSource conversion. The `util.types` brand checks work
+// across vm realms, and node:crypto's `hash.update()` reads view ranges from
+// internal slots (own properties shadowing `byteOffset`/`byteLength` are
+// ignored) — matching WebCrypto, which also reads internal slots.
+function toDigestInput(data) {
+    if (types.isTypedArray(data) || types.isDataView(data)) {
+        // WebCrypto's BufferSource excludes SharedArrayBuffer-backed views.
+        if (types.isSharedArrayBuffer(data.buffer)) {
+            throw new TypeError('crypto.subtle.digest does not accept SharedArrayBuffer-backed views');
+        }
+        return data;
+    }
+    if (!types.isArrayBuffer(data)) {
+        throw new TypeError('data must be an ArrayBuffer or ArrayBufferView');
+    }
+    return new Uint8Array(data);
+}
 /**
  * Creates a Node.js `vm.Context` configured to be usable for
  * executing workflow logic in a deterministic environment.
@@ -17,15 +44,18 @@ export function createContext(options) {
     const g = runInContext('globalThis', context);
     // Deterministic `Math.random()`
     g.Math.random = rng;
-    // Override `Date` constructor to return fixed time when called without arguments
+    // Override `Date` constructor to return fixed time when called without
+    // arguments. Constructing through `Reflect.construct` with `new.target`
+    // keeps subclassing intact (e.g. `TZDate` from `@date-fns/tz`), while a
+    // plain function (rather than a `class`) keeps `Date()` callable without
+    // `new`, which per spec ignores its arguments and returns the time string.
     const Date_ = g.Date;
     // biome-ignore lint/suspicious/noShadowRestrictedNames: We're shadowing the global `Date` property to make it deterministic.
     g.Date = function Date(...args) {
-        if (args.length === 0) {
-            return new Date_(fixedTimestamp);
+        if (new.target === undefined) {
+            return new Date_(fixedTimestamp).toString();
         }
-        // @ts-expect-error - Args is `Date` constructor arguments
-        return new Date_(...args);
+        return Reflect.construct(Date_, args.length === 0 ? [fixedTimestamp] : args, new.target);
     };
     g.Date.prototype = Date_.prototype;
     // Preserve static methods
@@ -41,7 +71,45 @@ export function createContext(options) {
         return array;
     }
     const randomUUID = createRandomUUID(rng);
-    const boundDigest = originalSubtle.digest.bind(originalSubtle);
+    // The sandbox must not hand workflow code a promise that settles on host
+    // timing or a way to observe host state (best-effort, for non-adversarial
+    // code): every promise a workflow creates settles either from the event log
+    // or within its own microtask cascade, so a suspended VM is fully quiescent
+    // and can be retained across inline steps.
+    //
+    // - `Atomics.waitAsync` is a wall-clock timer (via SharedArrayBuffer).
+    // - The async `WebAssembly` entry points resolve on compile-thread timing;
+    //   the synchronous `new WebAssembly.Module()` / `Instance()` remain.
+    // - `WeakRef.deref()` and finalizer callbacks observe GC timing.
+    // - Dynamic `import()` settles within a microtask (rejected: no
+    //   `importModuleDynamically`), so it needs no handling.
+    // - All `crypto.subtle` methods except the deterministic `digest` override
+    //   below throw explicitly (see the subtle proxy) — binding them to the
+    //   host subtle would hand workflows a host-timing promise.
+    const intrinsics = g;
+    delete intrinsics.Atomics.waitAsync;
+    delete intrinsics.WebAssembly.compile;
+    delete intrinsics.WebAssembly.instantiate;
+    delete intrinsics.WebAssembly.compileStreaming;
+    delete intrinsics.WebAssembly.instantiateStreaming;
+    delete intrinsics.WeakRef;
+    delete intrinsics.FinalizationRegistry;
+    // `crypto.subtle.digest` computes synchronously via node:crypto, so its
+    // promise settles on a deterministic microtask instead of host threadpool
+    // timing — a digest can never advance a suspended workflow, and
+    // digest-using VMs stay retainable. Values are byte-identical to WebCrypto.
+    const digest = async (algorithm, data) => {
+        const name = typeof algorithm === 'string' ? algorithm : algorithm.name;
+        const ossl = DIGEST_ALGORITHMS[name.toUpperCase()];
+        if (!ossl) {
+            throw new DOMException(`Unrecognized algorithm name: ${name}`, 'NotSupportedError');
+        }
+        const hash = createHash(ossl).update(toDigestInput(data)).digest();
+        // Copy out: small Buffers share the internal pool allocation.
+        const out = new ArrayBuffer(hash.byteLength);
+        new Uint8Array(out).set(hash);
+        return out;
+    };
     g.crypto = new Proxy(originalCrypto, {
         get(target, prop) {
             if (prop === 'getRandomValues') {
@@ -53,15 +121,18 @@ export function createContext(options) {
             if (prop === 'subtle') {
                 return new Proxy(originalSubtle, {
                     get(target, prop) {
-                        if (prop === 'generateKey') {
-                            return () => {
-                                throw new Error('Not implemented');
-                            };
+                        if (prop === 'digest') {
+                            return digest;
                         }
-                        else if (prop === 'digest') {
-                            return boundDigest;
+                        const value = target[prop];
+                        if (typeof value !== 'function') {
+                            return value;
                         }
-                        return target[prop];
+                        // Every other subtle method (`encrypt`, `sign`, `importKey`, …)
+                        // settles on host threadpool timing, which cannot be replayed.
+                        return () => {
+                            throw new WorkflowRuntimeError(`\`crypto.subtle.${String(prop)}()\` is not available inside a workflow function. Move it to a step function where full Node.js crypto is available.`);
+                        };
                     },
                 });
             }
@@ -99,4 +170,4 @@ export function createContext(options) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/vm/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { runInContext, createContext as vmCreateContext } from 'node:vm';\nimport seedrandom from 'seedrandom';\nimport { installUint8ArrayBase64 } from './uint8array-base64.js';\nimport { createRandomUUID } from './uuid.js';\n\nexport interface CreateContextOptions {\n  seed: string;\n  // Fixed timestamp for deterministic Date operations\n  fixedTimestamp: number;\n}\n\n/**\n * Creates a Node.js `vm.Context` configured to be usable for\n * executing workflow logic in a deterministic environment.\n *\n * @param options - The options for the context.\n * @returns The context.\n */\nexport function createContext(options: CreateContextOptions) {\n  let { fixedTimestamp } = options;\n  const { seed } = options;\n  const rng = seedrandom(seed);\n  const context = vmCreateContext();\n\n  const g: typeof globalThis = runInContext('globalThis', context);\n\n  // Deterministic `Math.random()`\n  g.Math.random = rng;\n\n  // Override `Date` constructor to return fixed time when called without arguments\n  const Date_ = g.Date;\n  // biome-ignore lint/suspicious/noShadowRestrictedNames: We're shadowing the global `Date` property to make it deterministic.\n  (g as any).Date = function Date(\n    ...args: Parameters<(typeof globalThis)['Date']>[]\n  ) {\n    if (args.length === 0) {\n      return new Date_(fixedTimestamp);\n    }\n    // @ts-expect-error - Args is `Date` constructor arguments\n    return new Date_(...args);\n  };\n  (g as any).Date.prototype = Date_.prototype;\n  // Preserve static methods\n  Object.setPrototypeOf(g.Date, Date_);\n  g.Date.now = () => fixedTimestamp;\n\n  // Deterministic `crypto` using Proxy to avoid mutating global objects\n  const originalCrypto = globalThis.crypto;\n  const originalSubtle = originalCrypto.subtle;\n\n  function getRandomValues(array: Uint8Array) {\n    for (let i = 0; i < array.length; i++) {\n      array[i] = Math.floor(rng() * 256);\n    }\n    return array;\n  }\n\n  const randomUUID = createRandomUUID(rng);\n\n  const boundDigest = originalSubtle.digest.bind(originalSubtle);\n\n  g.crypto = new Proxy(originalCrypto, {\n    get(target, prop) {\n      if (prop === 'getRandomValues') {\n        return getRandomValues;\n      }\n      if (prop === 'randomUUID') {\n        return randomUUID;\n      }\n      if (prop === 'subtle') {\n        return new Proxy(originalSubtle, {\n          get(target, prop) {\n            if (prop === 'generateKey') {\n              return () => {\n                throw new Error('Not implemented');\n              };\n            } else if (prop === 'digest') {\n              return boundDigest;\n            }\n            return target[prop as keyof typeof originalSubtle];\n          },\n        });\n      }\n      return target[prop as keyof typeof originalCrypto];\n    },\n  });\n\n  // Propagate environment variables\n  (g as any).process = {\n    env: Object.freeze({ ...process.env }),\n  };\n\n  // Stateless + synchronous Web APIs that are made available inside the sandbox\n  g.DOMException = globalThis.DOMException;\n  g.Headers = globalThis.Headers;\n  g.TextEncoder = globalThis.TextEncoder;\n  g.TextDecoder = globalThis.TextDecoder;\n  g.console = globalThis.console;\n  g.URL = globalThis.URL;\n  g.URLSearchParams = globalThis.URLSearchParams;\n  g.structuredClone = globalThis.structuredClone;\n  g.atob = globalThis.atob;\n  g.btoa = globalThis.btoa;\n\n  // TC39 Uint8Array base64/hex polyfill (proposal-arraybuffer-base64)\n  installUint8ArrayBase64(g.Uint8Array);\n\n  // TC39 Explicit Resource Management polyfill for `using` keyword\n  (g.Symbol as any).dispose ??= Symbol.for('Symbol.dispose');\n  (g.Symbol as any).asyncDispose ??= Symbol.for('Symbol.asyncDispose');\n\n  // HACK: Shim `exports` for the bundle\n  g.exports = {};\n  (g as any).module = { exports: g.exports };\n\n  return {\n    context,\n    globalThis: g,\n    updateTimestamp: (timestamp: number) => {\n      fixedTimestamp = timestamp;\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/vm/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'node:crypto';\nimport { types } from 'node:util';\nimport { runInContext, createContext as vmCreateContext } from 'node:vm';\nimport { WorkflowRuntimeError } from '@workflow/errors';\nimport seedrandom from 'seedrandom';\nimport { installUint8ArrayBase64 } from './uint8array-base64.js';\nimport { createRandomUUID } from './uuid.js';\n\nexport interface CreateContextOptions {\n  seed: string;\n  // Fixed timestamp for deterministic Date operations\n  fixedTimestamp: number;\n}\n\n// WebCrypto digest algorithm names → node:crypto (OpenSSL) names.\nconst DIGEST_ALGORITHMS: Record<string, string> = {\n  'SHA-1': 'sha1',\n  'SHA-256': 'sha256',\n  'SHA-384': 'sha384',\n  'SHA-512': 'sha512',\n};\n\n// WebCrypto BufferSource conversion. The `util.types` brand checks work\n// across vm realms, and node:crypto's `hash.update()` reads view ranges from\n// internal slots (own properties shadowing `byteOffset`/`byteLength` are\n// ignored) — matching WebCrypto, which also reads internal slots.\nfunction toDigestInput(\n  data: ArrayBuffer | ArrayBufferView\n): NodeJS.ArrayBufferView {\n  if (types.isTypedArray(data) || types.isDataView(data)) {\n    // WebCrypto's BufferSource excludes SharedArrayBuffer-backed views.\n    if (types.isSharedArrayBuffer(data.buffer)) {\n      throw new TypeError(\n        'crypto.subtle.digest does not accept SharedArrayBuffer-backed views'\n      );\n    }\n    return data;\n  }\n  if (!types.isArrayBuffer(data)) {\n    throw new TypeError('data must be an ArrayBuffer or ArrayBufferView');\n  }\n  return new Uint8Array(data);\n}\n\n/**\n * Creates a Node.js `vm.Context` configured to be usable for\n * executing workflow logic in a deterministic environment.\n *\n * @param options - The options for the context.\n * @returns The context.\n */\nexport function createContext(options: CreateContextOptions) {\n  let { fixedTimestamp } = options;\n  const { seed } = options;\n  const rng = seedrandom(seed);\n  const context = vmCreateContext();\n\n  const g: typeof globalThis = runInContext('globalThis', context);\n\n  // Deterministic `Math.random()`\n  g.Math.random = rng;\n\n  // Override `Date` constructor to return fixed time when called without\n  // arguments. Constructing through `Reflect.construct` with `new.target`\n  // keeps subclassing intact (e.g. `TZDate` from `@date-fns/tz`), while a\n  // plain function (rather than a `class`) keeps `Date()` callable without\n  // `new`, which per spec ignores its arguments and returns the time string.\n  const Date_ = g.Date;\n  // biome-ignore lint/suspicious/noShadowRestrictedNames: We're shadowing the global `Date` property to make it deterministic.\n  (g as any).Date = function Date(...args: any[]) {\n    if (new.target === undefined) {\n      return new Date_(fixedTimestamp).toString();\n    }\n    return Reflect.construct(\n      Date_,\n      args.length === 0 ? [fixedTimestamp] : args,\n      new.target\n    );\n  };\n  (g as any).Date.prototype = Date_.prototype;\n  // Preserve static methods\n  Object.setPrototypeOf(g.Date, Date_);\n  g.Date.now = () => fixedTimestamp;\n\n  // Deterministic `crypto` using Proxy to avoid mutating global objects\n  const originalCrypto = globalThis.crypto;\n  const originalSubtle = originalCrypto.subtle;\n\n  function getRandomValues(array: Uint8Array) {\n    for (let i = 0; i < array.length; i++) {\n      array[i] = Math.floor(rng() * 256);\n    }\n    return array;\n  }\n\n  const randomUUID = createRandomUUID(rng);\n\n  // The sandbox must not hand workflow code a promise that settles on host\n  // timing or a way to observe host state (best-effort, for non-adversarial\n  // code): every promise a workflow creates settles either from the event log\n  // or within its own microtask cascade, so a suspended VM is fully quiescent\n  // and can be retained across inline steps.\n  //\n  // - `Atomics.waitAsync` is a wall-clock timer (via SharedArrayBuffer).\n  // - The async `WebAssembly` entry points resolve on compile-thread timing;\n  //   the synchronous `new WebAssembly.Module()` / `Instance()` remain.\n  // - `WeakRef.deref()` and finalizer callbacks observe GC timing.\n  // - Dynamic `import()` settles within a microtask (rejected: no\n  //   `importModuleDynamically`), so it needs no handling.\n  // - All `crypto.subtle` methods except the deterministic `digest` override\n  //   below throw explicitly (see the subtle proxy) — binding them to the\n  //   host subtle would hand workflows a host-timing promise.\n  const intrinsics = g as unknown as Record<string, Record<string, unknown>>;\n  delete intrinsics.Atomics.waitAsync;\n  delete intrinsics.WebAssembly.compile;\n  delete intrinsics.WebAssembly.instantiate;\n  delete intrinsics.WebAssembly.compileStreaming;\n  delete intrinsics.WebAssembly.instantiateStreaming;\n  delete intrinsics.WeakRef;\n  delete intrinsics.FinalizationRegistry;\n\n  // `crypto.subtle.digest` computes synchronously via node:crypto, so its\n  // promise settles on a deterministic microtask instead of host threadpool\n  // timing — a digest can never advance a suspended workflow, and\n  // digest-using VMs stay retainable. Values are byte-identical to WebCrypto.\n  const digest = async (\n    algorithm: string | { name: string },\n    data: ArrayBuffer | ArrayBufferView\n  ): Promise<ArrayBuffer> => {\n    const name = typeof algorithm === 'string' ? algorithm : algorithm.name;\n    const ossl = DIGEST_ALGORITHMS[name.toUpperCase()];\n    if (!ossl) {\n      throw new DOMException(\n        `Unrecognized algorithm name: ${name}`,\n        'NotSupportedError'\n      );\n    }\n    const hash = createHash(ossl).update(toDigestInput(data)).digest();\n    // Copy out: small Buffers share the internal pool allocation.\n    const out = new ArrayBuffer(hash.byteLength);\n    new Uint8Array(out).set(hash);\n    return out;\n  };\n\n  g.crypto = new Proxy(originalCrypto, {\n    get(target, prop) {\n      if (prop === 'getRandomValues') {\n        return getRandomValues;\n      }\n      if (prop === 'randomUUID') {\n        return randomUUID;\n      }\n      if (prop === 'subtle') {\n        return new Proxy(originalSubtle, {\n          get(target, prop) {\n            if (prop === 'digest') {\n              return digest;\n            }\n            const value = target[prop as keyof typeof originalSubtle];\n            if (typeof value !== 'function') {\n              return value;\n            }\n            // Every other subtle method (`encrypt`, `sign`, `importKey`, …)\n            // settles on host threadpool timing, which cannot be replayed.\n            return () => {\n              throw new WorkflowRuntimeError(\n                `\\`crypto.subtle.${String(prop)}()\\` is not available inside a workflow function. Move it to a step function where full Node.js crypto is available.`\n              );\n            };\n          },\n        });\n      }\n      return target[prop as keyof typeof originalCrypto];\n    },\n  });\n\n  // Propagate environment variables\n  (g as any).process = {\n    env: Object.freeze({ ...process.env }),\n  };\n\n  // Stateless + synchronous Web APIs that are made available inside the sandbox\n  g.DOMException = globalThis.DOMException;\n  g.Headers = globalThis.Headers;\n  g.TextEncoder = globalThis.TextEncoder;\n  g.TextDecoder = globalThis.TextDecoder;\n  g.console = globalThis.console;\n  g.URL = globalThis.URL;\n  g.URLSearchParams = globalThis.URLSearchParams;\n  g.structuredClone = globalThis.structuredClone;\n  g.atob = globalThis.atob;\n  g.btoa = globalThis.btoa;\n\n  // TC39 Uint8Array base64/hex polyfill (proposal-arraybuffer-base64)\n  installUint8ArrayBase64(g.Uint8Array);\n\n  // TC39 Explicit Resource Management polyfill for `using` keyword\n  (g.Symbol as any).dispose ??= Symbol.for('Symbol.dispose');\n  (g.Symbol as any).asyncDispose ??= Symbol.for('Symbol.asyncDispose');\n\n  // HACK: Shim `exports` for the bundle\n  g.exports = {};\n  (g as any).module = { exports: g.exports };\n\n  return {\n    context,\n    globalThis: g,\n    updateTimestamp: (timestamp: number) => {\n      fixedTimestamp = timestamp;\n    },\n  };\n}\n"]}

package/dist/vm/script-cache.d.ts

@@ -0,0 +1,28 @@
+import { type Context, Script } from 'node:vm';
+/**
+ * Returns a compiled `vm.Script` for the given workflow bundle code and
+ * filename, compiling and caching it on first use. Subsequent calls with the
+ * same `(code, filename)` return the cached `Script`.
+ *
+ * The returned `Script` is not yet bound to any context; the caller runs it
+ * against a specific VM context via `script.runInContext(context)`. This is
+ * equivalent to `vm.runInContext(code, context, { filename })` but skips the
+ * recompile.
+ */
+export declare function getCachedWorkflowScript(code: string, filename: string): Script;
+/**
+ * Runs the cached workflow-bundle `Script` against `context`. Compiles and
+ * caches the `Script` on first use for the given `(code, filename)`.
+ */
+export declare function runCachedWorkflowScript(code: string, filename: string, context: Context): unknown;
+/**
+ * Clears the compiled-script cache. Intended for tests that want to assert
+ * compile-vs-cache behaviour in isolation; not used on the hot path.
+ */
+export declare function clearWorkflowScriptCache(): void;
+/**
+ * Number of distinct bundle (`code`) versions currently retained. Exposed for
+ * tests asserting the LRU bound; not used on the hot path.
+ */
+export declare function workflowScriptCacheSize(): number;
+//# sourceMappingURL=script-cache.d.ts.map

package/dist/vm/script-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-cache.d.ts","sourceRoot":"","sources":["../../src/vm/script-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AA0F/C;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,MAAM,CAqBR;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,OAAO,CAET;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}

package/dist/vm/script-cache.js

@@ -0,0 +1,140 @@
+import { Script } from 'node:vm';
+/**
+ * Module-level cache of compiled workflow-bundle `vm.Script` objects.
+ *
+ * Why this exists
+ * ---------------
+ * Replaying a workflow re-evaluates the workflow bundle against a fresh VM
+ * context on every iteration of the inline replay loop (see
+ * `runWorkflow` in `../workflow.ts`). The bundle is a single string that
+ * contains every workflow function in the app and registers them on
+ * `globalThis.__private_workflows`. Previously each replay called
+ * `vm.runInContext(workflowCode, context, { filename })`, which RE-PARSES and
+ * RE-COMPILES the entire bundle every time — O(N) full re-parses for a
+ * sequential workflow of N steps, plus the same parse cost repeated across
+ * every invocation in the process.
+ *
+ * Compilation is a pure function of `(code, filename)`: a `vm.Script` carries
+ * no realm/context state — it is only bound to a context at `runInContext`
+ * time. So a single compiled `Script` can be reused across replays AND across
+ * workflow invocations in the same process without affecting determinism: the
+ * produced workflow function is identical to the previous re-parse-every-time
+ * behaviour, with identical `filename` source attribution (see the precise
+ * claim — and its one caveat — in `runWorkflow`).
+ *
+ * Keying
+ * ------
+ * Keyed by `code` then `filename`. The `filename` is part of the key on
+ * purpose, NOT as a dedupe key: it is baked into the compiled script's source
+ * attribution and surfaces in stack traces, where `remapErrorStack` keys on it
+ * to map frames back to the user's source. Two workflows in the same bundle
+ * share the same `code` but have different `filename`s, so they intentionally
+ * compile to distinct `Script`s — collapsing them onto a single shared `Script`
+ * would misattribute one workflow's stack frames to another file. The cost of
+ * keeping them distinct is that the whole bundle is compiled once per distinct
+ * `filename` (not once per bundle); in practice that is bounded by the number
+ * of source files that define a workflow, and because V8 lazily compiles
+ * function bodies the duplicated work is the (cheap) top-level parse, not full
+ * per-workflow codegen.
+ *
+ * We use a nested Map (code -> filename -> Script) so that evicting a bundle
+ * (e.g. a new deployment/hot-reload producing a different `code`) drops the old
+ * code string and all of its per-filename scripts together.
+ *
+ * Bounding
+ * --------
+ * The top-level (`code`-keyed) map is an insertion-ordered LRU capped at
+ * `MAX_BUNDLES` entries. In production this bound is never reached: a
+ * deployment is its own process serving exactly one build-time bundle literal
+ * (skew protection runs old versions as separate processes), so there is a
+ * single `code` key for the process lifetime. The bound exists for dev/watch
+ * mode, where the dev route re-reads `workflowCode` from disk and re-invokes
+ * the entrypoint on every edit — each edit produces a NEW bundle string, which
+ * without a bound would pin every historical version forever (~0.8MB per edit,
+ * growing monotonically with edit count). The dev path only ever needs the
+ * latest bundle, so an LRU that keeps the few most-recent bundles and evicts
+ * the rest preserves the pre-cache GC behaviour while still serving the
+ * steady-state single-bundle case for free. The per-`filename` inner map is not
+ * separately bounded: it is naturally bounded by the (small) number of workflow
+ * source files in a bundle and is dropped wholesale when its parent `code`
+ * entry is evicted.
+ */
+const scriptCache = new Map();
+/**
+ * Max number of distinct bundle (`code`) versions to retain. One is enough for
+ * production; a handful covers pathological dev hot-reload / repeated-rebuild
+ * churn within a single long-lived process (e.g. a watch session or a test
+ * file) without unbounded growth. Kept deliberately small — there is no value
+ * in retaining stale bundles, only a memory cost.
+ */
+const MAX_BUNDLES = 8;
+/**
+ * Looks up the per-filename map for `code`, marking it most-recently-used.
+ * Relies on `Map` preserving insertion order: deleting and re-inserting an
+ * existing key moves it to the end (newest), so the first key is always the
+ * least-recently-used eviction candidate.
+ */
+function touchBundle(code) {
+    const byFilename = scriptCache.get(code);
+    if (byFilename === undefined) {
+        return undefined;
+    }
+    // Move to the most-recently-used position (end of insertion order).
+    scriptCache.delete(code);
+    scriptCache.set(code, byFilename);
+    return byFilename;
+}
+/**
+ * Returns a compiled `vm.Script` for the given workflow bundle code and
+ * filename, compiling and caching it on first use. Subsequent calls with the
+ * same `(code, filename)` return the cached `Script`.
+ *
+ * The returned `Script` is not yet bound to any context; the caller runs it
+ * against a specific VM context via `script.runInContext(context)`. This is
+ * equivalent to `vm.runInContext(code, context, { filename })` but skips the
+ * recompile.
+ */
+export function getCachedWorkflowScript(code, filename) {
+    let byFilename = touchBundle(code);
+    if (byFilename === undefined) {
+        byFilename = new Map();
+        scriptCache.set(code, byFilename);
+        // Evict the least-recently-used bundle(s) when over the cap. New bundles
+        // are appended at the end, so the oldest live at the front.
+        while (scriptCache.size > MAX_BUNDLES) {
+            const oldest = scriptCache.keys().next().value;
+            if (oldest === undefined) {
+                break;
+            }
+            scriptCache.delete(oldest);
+        }
+    }
+    let script = byFilename.get(filename);
+    if (script === undefined) {
+        script = new Script(code, { filename });
+        byFilename.set(filename, script);
+    }
+    return script;
+}
+/**
+ * Runs the cached workflow-bundle `Script` against `context`. Compiles and
+ * caches the `Script` on first use for the given `(code, filename)`.
+ */
+export function runCachedWorkflowScript(code, filename, context) {
+    return getCachedWorkflowScript(code, filename).runInContext(context);
+}
+/**
+ * Clears the compiled-script cache. Intended for tests that want to assert
+ * compile-vs-cache behaviour in isolation; not used on the hot path.
+ */
+export function clearWorkflowScriptCache() {
+    scriptCache.clear();
+}
+/**
+ * Number of distinct bundle (`code`) versions currently retained. Exposed for
+ * tests asserting the LRU bound; not used on the hot path.
+ */
+export function workflowScriptCacheSize() {
+    return scriptCache.size;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"script-cache.js","sourceRoot":"","sources":["../../src/vm/script-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,WAAW,GAAG,IAAI,GAAG,EAA+B,CAAC;AAE3D;;;;;;GAMG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC;AAEtB;;;;;GAKG;AACH,SAAS,WAAW,CAAC,IAAY;IAC/B,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACzC,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,oEAAoE;IACpE,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACzB,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAClC,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAY,EACZ,QAAgB;IAEhB,IAAI,UAAU,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,UAAU,GAAG,IAAI,GAAG,EAAkB,CAAC;QACvC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAClC,yEAAyE;QACzE,4DAA4D;QAC5D,OAAO,WAAW,CAAC,IAAI,GAAG,WAAW,EAAE,CAAC;YACtC,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;YAC/C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,MAAM;YACR,CAAC;YACD,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IACD,IAAI,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QACxC,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACnC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAY,EACZ,QAAgB,EAChB,OAAgB;IAEhB,OAAO,uBAAuB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;AACvE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,wBAAwB;IACtC,WAAW,CAAC,KAAK,EAAE,CAAC;AACtB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO,WAAW,CAAC,IAAI,CAAC;AAC1B,CAAC","sourcesContent":["import { type Context, Script } from 'node:vm';\n\n/**\n * Module-level cache of compiled workflow-bundle `vm.Script` objects.\n *\n * Why this exists\n * ---------------\n * Replaying a workflow re-evaluates the workflow bundle against a fresh VM\n * context on every iteration of the inline replay loop (see\n * `runWorkflow` in `../workflow.ts`). The bundle is a single string that\n * contains every workflow function in the app and registers them on\n * `globalThis.__private_workflows`. Previously each replay called\n * `vm.runInContext(workflowCode, context, { filename })`, which RE-PARSES and\n * RE-COMPILES the entire bundle every time — O(N) full re-parses for a\n * sequential workflow of N steps, plus the same parse cost repeated across\n * every invocation in the process.\n *\n * Compilation is a pure function of `(code, filename)`: a `vm.Script` carries\n * no realm/context state — it is only bound to a context at `runInContext`\n * time. So a single compiled `Script` can be reused across replays AND across\n * workflow invocations in the same process without affecting determinism: the\n * produced workflow function is identical to the previous re-parse-every-time\n * behaviour, with identical `filename` source attribution (see the precise\n * claim — and its one caveat — in `runWorkflow`).\n *\n * Keying\n * ------\n * Keyed by `code` then `filename`. The `filename` is part of the key on\n * purpose, NOT as a dedupe key: it is baked into the compiled script's source\n * attribution and surfaces in stack traces, where `remapErrorStack` keys on it\n * to map frames back to the user's source. Two workflows in the same bundle\n * share the same `code` but have different `filename`s, so they intentionally\n * compile to distinct `Script`s — collapsing them onto a single shared `Script`\n * would misattribute one workflow's stack frames to another file. The cost of\n * keeping them distinct is that the whole bundle is compiled once per distinct\n * `filename` (not once per bundle); in practice that is bounded by the number\n * of source files that define a workflow, and because V8 lazily compiles\n * function bodies the duplicated work is the (cheap) top-level parse, not full\n * per-workflow codegen.\n *\n * We use a nested Map (code -> filename -> Script) so that evicting a bundle\n * (e.g. a new deployment/hot-reload producing a different `code`) drops the old\n * code string and all of its per-filename scripts together.\n *\n * Bounding\n * --------\n * The top-level (`code`-keyed) map is an insertion-ordered LRU capped at\n * `MAX_BUNDLES` entries. In production this bound is never reached: a\n * deployment is its own process serving exactly one build-time bundle literal\n * (skew protection runs old versions as separate processes), so there is a\n * single `code` key for the process lifetime. The bound exists for dev/watch\n * mode, where the dev route re-reads `workflowCode` from disk and re-invokes\n * the entrypoint on every edit — each edit produces a NEW bundle string, which\n * without a bound would pin every historical version forever (~0.8MB per edit,\n * growing monotonically with edit count). The dev path only ever needs the\n * latest bundle, so an LRU that keeps the few most-recent bundles and evicts\n * the rest preserves the pre-cache GC behaviour while still serving the\n * steady-state single-bundle case for free. The per-`filename` inner map is not\n * separately bounded: it is naturally bounded by the (small) number of workflow\n * source files in a bundle and is dropped wholesale when its parent `code`\n * entry is evicted.\n */\nconst scriptCache = new Map<string, Map<string, Script>>();\n\n/**\n * Max number of distinct bundle (`code`) versions to retain. One is enough for\n * production; a handful covers pathological dev hot-reload / repeated-rebuild\n * churn within a single long-lived process (e.g. a watch session or a test\n * file) without unbounded growth. Kept deliberately small — there is no value\n * in retaining stale bundles, only a memory cost.\n */\nconst MAX_BUNDLES = 8;\n\n/**\n * Looks up the per-filename map for `code`, marking it most-recently-used.\n * Relies on `Map` preserving insertion order: deleting and re-inserting an\n * existing key moves it to the end (newest), so the first key is always the\n * least-recently-used eviction candidate.\n */\nfunction touchBundle(code: string): Map<string, Script> | undefined {\n  const byFilename = scriptCache.get(code);\n  if (byFilename === undefined) {\n    return undefined;\n  }\n  // Move to the most-recently-used position (end of insertion order).\n  scriptCache.delete(code);\n  scriptCache.set(code, byFilename);\n  return byFilename;\n}\n\n/**\n * Returns a compiled `vm.Script` for the given workflow bundle code and\n * filename, compiling and caching it on first use. Subsequent calls with the\n * same `(code, filename)` return the cached `Script`.\n *\n * The returned `Script` is not yet bound to any context; the caller runs it\n * against a specific VM context via `script.runInContext(context)`. This is\n * equivalent to `vm.runInContext(code, context, { filename })` but skips the\n * recompile.\n */\nexport function getCachedWorkflowScript(\n  code: string,\n  filename: string\n): Script {\n  let byFilename = touchBundle(code);\n  if (byFilename === undefined) {\n    byFilename = new Map<string, Script>();\n    scriptCache.set(code, byFilename);\n    // Evict the least-recently-used bundle(s) when over the cap. New bundles\n    // are appended at the end, so the oldest live at the front.\n    while (scriptCache.size > MAX_BUNDLES) {\n      const oldest = scriptCache.keys().next().value;\n      if (oldest === undefined) {\n        break;\n      }\n      scriptCache.delete(oldest);\n    }\n  }\n  let script = byFilename.get(filename);\n  if (script === undefined) {\n    script = new Script(code, { filename });\n    byFilename.set(filename, script);\n  }\n  return script;\n}\n\n/**\n * Runs the cached workflow-bundle `Script` against `context`. Compiles and\n * caches the `Script` on first use for the given `(code, filename)`.\n */\nexport function runCachedWorkflowScript(\n  code: string,\n  filename: string,\n  context: Context\n): unknown {\n  return getCachedWorkflowScript(code, filename).runInContext(context);\n}\n\n/**\n * Clears the compiled-script cache. Intended for tests that want to assert\n * compile-vs-cache behaviour in isolation; not used on the hot path.\n */\nexport function clearWorkflowScriptCache(): void {\n  scriptCache.clear();\n}\n\n/**\n * Number of distinct bundle (`code`) versions currently retained. Exposed for\n * tests asserting the LRU bound; not used on the hot path.\n */\nexport function workflowScriptCacheSize(): number {\n  return scriptCache.size;\n}\n"]}

package/dist/workflow/abort-controller.d.ts

@@ -0,0 +1,65 @@
+import { type WorkflowOrchestratorContext } from '../private.js';
+import { ABORT_HOOK_TOKEN, ABORT_STREAM_NAME } from '../symbols.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 declare class WorkflowAbortSignal {
+    #private;
+    aborted: boolean;
+    reason: unknown;
+    readonly [ABORT_STREAM_NAME]: string;
+    readonly [ABORT_HOOK_TOKEN]: string;
+    get onabort(): ((this: WorkflowAbortSignal) => void) | null;
+    set onabort(handler: ((this: WorkflowAbortSignal) => void) | null);
+    constructor(streamName: string, hookToken: string);
+    /**
+     * @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?: unknown): void;
+    addEventListener(type: string, listener: () => void): void;
+    removeEventListener(type: string, listener: () => void): void;
+    throwIfAborted(): void;
+}
+/**
+ * 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 declare function createCreateAbortController(ctx: WorkflowOrchestratorContext): {
+    new (): {
+        readonly signal: WorkflowAbortSignal;
+        abort(reason?: unknown): void;
+        readonly [ABORT_STREAM_NAME]: string;
+        readonly [ABORT_HOOK_TOKEN]: string;
+    };
+};
+/**
+ * Creates a workflow-context `AbortSignal` object with static methods.
+ */
+export declare function createAbortSignalStatics(): {
+    abort: (reason?: unknown) => WorkflowAbortSignal;
+    any: (signals: Iterable<{
+        aborted: boolean;
+        reason?: unknown;
+        addEventListener?: Function;
+    }>) => WorkflowAbortSignal;
+    timeout: () => never;
+};
+//# sourceMappingURL=abort-controller.d.ts.map

package/dist/workflow/abort-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort-controller.d.ts","sourceRoot":"","sources":["../../src/workflow/abort-controller.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,2BAA2B,EACjC,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAGpE;;;;;;;;;;GAUG;AACH,qBAAa,mBAAmB;;IAC9B,OAAO,UAAS;IAChB,MAAM,EAAE,OAAO,CAAa;IAE5B,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAKpC,IAAI,OAAO,IAAI,CAAC,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,CAAC,GAAG,IAAI,CAE1D;IAED,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,CAAC,GAAG,IAAI,EAKhE;gBAEW,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAKjD;;;;OAIG;IACH,WAAW,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAanC,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAa1D,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAK7D,cAAc,IAAI,IAAI;CAQvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,2BAA2B;;yBAEvD,mBAAmB;uBAqLrB,OAAO,GAAG,IAAI;sCApLC,MAAM;qCACP,MAAM;;EAoMtC;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI;IAC1C,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,mBAAmB,CAAC;IACjD,GAAG,EAAE,CACH,OAAO,EAAE,QAAQ,CAAC;QAChB,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,gBAAgB,CAAC,EAAE,QAAQ,CAAC;KAC7B,CAAC,KACC,mBAAmB,CAAC;IACzB,OAAO,EAAE,MAAM,KAAK,CAAC;CACtB,CAwEA"}