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

package/dist/test-support/orchestrator-context.js

@@ -0,0 +1,107 @@
+import { WorkflowRuntimeError } from '@workflow/errors';
+import { withResolvers } from '@workflow/utils';
+import * as nanoid from 'nanoid';
+import { monotonicFactory } from 'ulid';
+import { vi } from 'vitest';
+import { EventsConsumer } from '../events-consumer.js';
+import { describeDivergenceContext } from '../replay-divergence.js';
+import { ReplayPayloadCache } from '../replay-payload-cache.js';
+import { createContext } from '../vm/index.js';
+/**
+ * Builds an orchestrator context that replays a hand-written event log through
+ * the real workflow primitives (`createUseStep`, `createSleep`,
+ * `createCreateHook`), without a World or a VM entrypoint.
+ */
+export function setupWorkflowContext(events, options = {}) {
+    const context = createContext({
+        seed: 'test',
+        fixedTimestamp: 1753481739458,
+    });
+    const ulid = monotonicFactory(() => context.globalThis.Math.random());
+    // Real-session parity: the log-order-draws quiescence fixpoint keys its
+    // progress metric on `mintCount`. Without it the loop degrades to a single
+    // turn and these suites would only exercise a degraded variant.
+    let mintCount = 0;
+    const workflowStartedAt = context.globalThis.Date.now();
+    const promiseQueueHolder = { current: Promise.resolve() };
+    // Forward onUnconsumedEvent through ctx.onWorkflowError so tests that wire
+    // onWorkflowError to a discontinuation promise (see runWithDiscontinuation)
+    // actually observe false-positive unconsumed-event detections instead of
+    // silently dropping them.
+    const ctxRef = {};
+    const ctx = {
+        suspensionGeneration: 0,
+        runId: 'wrun_test',
+        encryptionKey: undefined,
+        replayPayloadCache: new ReplayPayloadCache(undefined),
+        globalThis: context.globalThis,
+        eventsConsumer: new EventsConsumer(events, {
+            // Fake context: no deliveries are modeled, so the gate is a no-op here.
+            isDeliveryIdle: () => true,
+            onUnconsumedEvent: (event) => {
+                const current = ctxRef.current;
+                if (!current)
+                    return;
+                // Same detail the production path appends (see `onUnconsumedEvent` in
+                // workflow.ts), so a test can assert on what a user would read.
+                current.onWorkflowError(new WorkflowRuntimeError(`Unconsumed event in event log: eventType=${event.eventType}, correlationId=${event.correlationId}, eventId=${event.eventId}. This indicates a corrupted or invalid event log. ${describeDivergenceContext(event, current.invocationsQueue, current.eventsConsumer)}`));
+            },
+            onDuplicateEvent: options.onDuplicateEvent,
+            getPromiseQueue: () => promiseQueueHolder.current,
+        }),
+        invocationsQueue: new Map(),
+        generateUlid: () => {
+            mintCount += 1;
+            return ulid(workflowStartedAt);
+        },
+        get mintCount() {
+            return mintCount;
+        },
+        generateNanoid: nanoid.customRandom(nanoid.urlAlphabet, 21, (size) => new Uint8Array(size).map(() => 256 * context.globalThis.Math.random())),
+        onWorkflowError: vi.fn(),
+        get promiseQueue() {
+            return promiseQueueHolder.current;
+        },
+        set promiseQueue(value) {
+            promiseQueueHolder.current = value;
+        },
+        pendingDeliveries: 0,
+        pendingDeliveryBarriers: new Map(),
+    };
+    ctxRef.current = ctx;
+    return ctx;
+}
+/**
+ * Deterministic correlation IDs from the ULID generator with seed 'test', in
+ * the order {@link setupWorkflowContext}'s generator mints them.
+ */
+export const CORR_IDS = [
+    '01K11TFZ62YS0YYFDQ3E8B9YCV',
+    '01K11TFZ62YS0YYFDQ3E8B9YCW',
+    '01K11TFZ62YS0YYFDQ3E8B9YCX',
+    '01K11TFZ62YS0YYFDQ3E8B9YCY',
+    '01K11TFZ62YS0YYFDQ3E8B9YCZ',
+    '01K11TFZ62YS0YYFDQ3E8B9YD0',
+];
+/**
+ * Runs `workflowFn` against `ctx`, racing it against the context's error
+ * channel so a `WorkflowSuspension` or a detected divergence surfaces as
+ * `error` rather than hanging.
+ */
+export async function runWithDiscontinuation(ctx, workflowFn) {
+    const workflowDiscontinuation = withResolvers();
+    ctx.onWorkflowError = workflowDiscontinuation.reject;
+    let result;
+    let error;
+    try {
+        result = await Promise.race([
+            workflowFn(),
+            workflowDiscontinuation.promise,
+        ]);
+    }
+    catch (err) {
+        error = err;
+    }
+    return { result, error };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orchestrator-context.js","sourceRoot":"","sources":["../../src/test-support/orchestrator-context.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { withResolvers } from '@workflow/utils';\nimport type { Event } from '@workflow/world';\nimport * as nanoid from 'nanoid';\nimport { monotonicFactory } from 'ulid';\nimport { vi } from 'vitest';\nimport { EventsConsumer } from '../events-consumer.js';\nimport type { WorkflowOrchestratorContext } from '../private.js';\nimport { describeDivergenceContext } from '../replay-divergence.js';\nimport { ReplayPayloadCache } from '../replay-payload-cache.js';\nimport { createContext } from '../vm/index.js';\n\n/**\n * Builds an orchestrator context that replays a hand-written event log through\n * the real workflow primitives (`createUseStep`, `createSleep`,\n * `createCreateHook`), without a World or a VM entrypoint.\n */\nexport function setupWorkflowContext(\n  events: Event[],\n  options: { onDuplicateEvent?: (event: Event) => void } = {}\n): WorkflowOrchestratorContext {\n  const context = createContext({\n    seed: 'test',\n    fixedTimestamp: 1753481739458,\n  });\n  const ulid = monotonicFactory(() => context.globalThis.Math.random());\n  // Real-session parity: the log-order-draws quiescence fixpoint keys its\n  // progress metric on `mintCount`. Without it the loop degrades to a single\n  // turn and these suites would only exercise a degraded variant.\n  let mintCount = 0;\n  const workflowStartedAt = context.globalThis.Date.now();\n  const promiseQueueHolder = { current: Promise.resolve() };\n  // Forward onUnconsumedEvent through ctx.onWorkflowError so tests that wire\n  // onWorkflowError to a discontinuation promise (see runWithDiscontinuation)\n  // actually observe false-positive unconsumed-event detections instead of\n  // silently dropping them.\n  const ctxRef: { current?: WorkflowOrchestratorContext } = {};\n  const ctx: WorkflowOrchestratorContext = {\n    suspensionGeneration: 0,\n    runId: 'wrun_test',\n    encryptionKey: undefined,\n    replayPayloadCache: new ReplayPayloadCache(undefined),\n    globalThis: context.globalThis,\n    eventsConsumer: new EventsConsumer(events, {\n      // Fake context: no deliveries are modeled, so the gate is a no-op here.\n      isDeliveryIdle: () => true,\n      onUnconsumedEvent: (event) => {\n        const current = ctxRef.current;\n        if (!current) return;\n        // Same detail the production path appends (see `onUnconsumedEvent` in\n        // workflow.ts), so a test can assert on what a user would read.\n        current.onWorkflowError(\n          new WorkflowRuntimeError(\n            `Unconsumed event in event log: eventType=${event.eventType}, correlationId=${event.correlationId}, eventId=${event.eventId}. This indicates a corrupted or invalid event log. ${describeDivergenceContext(event, current.invocationsQueue, current.eventsConsumer)}`\n          )\n        );\n      },\n      onDuplicateEvent: options.onDuplicateEvent,\n      getPromiseQueue: () => promiseQueueHolder.current,\n    }),\n    invocationsQueue: new Map(),\n    generateUlid: () => {\n      mintCount += 1;\n      return ulid(workflowStartedAt);\n    },\n    get mintCount() {\n      return mintCount;\n    },\n    generateNanoid: nanoid.customRandom(nanoid.urlAlphabet, 21, (size) =>\n      new Uint8Array(size).map(() => 256 * context.globalThis.Math.random())\n    ),\n    onWorkflowError: vi.fn(),\n    get promiseQueue() {\n      return promiseQueueHolder.current;\n    },\n    set promiseQueue(value: Promise<void>) {\n      promiseQueueHolder.current = value;\n    },\n    pendingDeliveries: 0,\n    pendingDeliveryBarriers: new Map(),\n  };\n  ctxRef.current = ctx;\n  return ctx;\n}\n\n/**\n * Deterministic correlation IDs from the ULID generator with seed 'test', in\n * the order {@link setupWorkflowContext}'s generator mints them.\n */\nexport const CORR_IDS = [\n  '01K11TFZ62YS0YYFDQ3E8B9YCV',\n  '01K11TFZ62YS0YYFDQ3E8B9YCW',\n  '01K11TFZ62YS0YYFDQ3E8B9YCX',\n  '01K11TFZ62YS0YYFDQ3E8B9YCY',\n  '01K11TFZ62YS0YYFDQ3E8B9YCZ',\n  '01K11TFZ62YS0YYFDQ3E8B9YD0',\n];\n\n/**\n * Runs `workflowFn` against `ctx`, racing it against the context's error\n * channel so a `WorkflowSuspension` or a detected divergence surfaces as\n * `error` rather than hanging.\n */\nexport async function runWithDiscontinuation(\n  ctx: WorkflowOrchestratorContext,\n  workflowFn: () => Promise<any>\n): Promise<{ result?: any; error?: any }> {\n  const workflowDiscontinuation = withResolvers<void>();\n  ctx.onWorkflowError = workflowDiscontinuation.reject;\n\n  let result: any;\n  let error: any;\n  try {\n    result = await Promise.race([\n      workflowFn(),\n      workflowDiscontinuation.promise,\n    ]);\n  } catch (err) {\n    error = err;\n  }\n  return { result, error };\n}\n"]}

package/dist/types.d.ts

@@ -1,5 +1,11 @@
 export declare function getErrorName(v: unknown): string;
 export declare function getErrorStack(v: unknown): string;
+export declare function isAbortError(value: unknown): value is {
+    name: 'AbortError';
+    message: string;
+    stack?: string;
+};
+export declare function promoteAbortErrorToFatal(value: unknown): unknown;
 export interface NormalizedUnknownError {
     name: string;
     message: string;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAK/C;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAKhD;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AA2CD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,sBAAsB,CAAC,CAmBjC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAK/C;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAKhD;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAYlE;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAUhE;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AA2CD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,sBAAsB,CAAC,CAmBjC"}

package/dist/types.js

@@ -1,4 +1,5 @@
 import { types } from 'node:util';
+import { FatalError } from '@workflow/errors';
 export function getErrorName(v) {
     if (types.isNativeError(v)) {
         return v.name;
@@ -11,6 +12,27 @@ export function getErrorStack(v) {
     }
     return '';
 }
+export function isAbortError(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'name' in value &&
+        value.name === 'AbortError' &&
+        'message' in value &&
+        typeof value.message === 'string' &&
+        (!('stack' in value) ||
+            value.stack === undefined ||
+            typeof value.stack === 'string'));
+}
+export function promoteAbortErrorToFatal(value) {
+    if (!isAbortError(value) || FatalError.is(value)) {
+        return value;
+    }
+    const fatalError = new FatalError(`Aborted: ${value.message}`);
+    if (value.stack) {
+        fatalError.stack = value.stack;
+    }
+    return fatalError;
+}
 function isThenable(value) {
     return (typeof value === 'object' &&
         value !== null &&
@@ -72,4 +94,4 @@ export async function normalizeUnknownError(value) {
     }
     return normalizeSyncError(value);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/util.d.ts

@@ -32,9 +32,4 @@ export declare function getAbortStreamId(id: string): string;
  * `strm_{id}_system_abort`.
  */
 export declare function getAbortStreamIdFromToken(hookToken: string): string;
-/**
- * A small wrapper around `waitUntil` that also returns
- * the result of the awaited promise.
- */
-export declare function waitedUntil<T>(fn: () => Promise<T>): Promise<T>;
 //# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CA6Bf;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,UAUvE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,UAE1C;AAID;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAOnE;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAUrE"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CA6Bf;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,UAUvE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,UAE1C;AAID;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAOnE"}

package/dist/util.js

@@ -1,4 +1,3 @@
-import { waitUntil } from '@vercel/functions';
 import { pluralize } from '@workflow/utils';
 /**
  * Builds a workflow suspension log message based on the counts of steps,
@@ -76,17 +75,4 @@ export function getAbortStreamIdFromToken(hookToken) {
     }
     return getAbortStreamId(hookToken.slice(ABORT_TOKEN_PREFIX.length));
 }
-/**
- * A small wrapper around `waitUntil` that also returns
- * the result of the awaited promise.
- */
-export async function waitedUntil(fn) {
-    const result = fn();
-    waitUntil(result.catch(() => {
-        // Ignore error from the promise being rejected.
-        // It's expected that the invoker of `waitedUntil`
-        // will handle the error.
-    }));
-    return result;
-}
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.0.0-beta.5";
+export declare const version = "5.0.0-beta.51";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,iBAAiB,CAAA"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,kBAAkB,CAAA"}

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '5.0.0-beta.5';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJCQUEyQjtBQUMzQixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsY0FBYyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR2VuZXJhdGVkIGJ5IGdlbnZlcnNpb24uXG5leHBvcnQgY29uc3QgdmVyc2lvbiA9ICc1LjAuMC1iZXRhLjUnXG4iXX0=
+export const version = '5.0.0-beta.51';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJCQUEyQjtBQUMzQixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsZUFBZSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR2VuZXJhdGVkIGJ5IGdlbnZlcnNpb24uXG5leHBvcnQgY29uc3QgdmVyc2lvbiA9ICc1LjAuMC1iZXRhLjUxJ1xuIl19

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vm/index.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IAEb,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB;;;iCAsG1B,MAAM;EAItC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vm/index.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IAEb,cAAc,EAAE,MAAM,CAAC;CACxB;AAgCD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB;;;iCA4J1B,MAAM;EAItC"}

package/dist/vm/index.js

@@ -1,8 +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.
@@ -18,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
@@ -42,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') {
@@ -54,15 +121,18 @@ export function createContext(options) {
             if (prop === 'subtle') {
                 return new Proxy(originalSubtle, {
                     get(target, prop) {
-                        if (prop === 'generateKey') {
-                            return () => {
-                                throw new WorkflowRuntimeError('`crypto.subtle.generateKey()` is not available inside a workflow function. Move key generation to a step function where full Node.js crypto is available.');
-                            };
+                        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.`);
+                        };
                     },
                 });
             }
@@ -100,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":"AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,IAAI,eAAe,EAAE,MAAM,SAAS,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,UAAU,MAAM,YAAY,CAAC;AACpC,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAQ7C;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,OAA6B;IACzD,IAAI,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;IACjC,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC;IACzB,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAC7B,MAAM,OAAO,GAAG,eAAe,EAAE,CAAC;IAElC,MAAM,CAAC,GAAsB,YAAY,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;IAEjE,gCAAgC;IAChC,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;IAEpB,iFAAiF;IACjF,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC;IACrB,6HAA6H;IAC5H,CAAS,CAAC,IAAI,GAAG,SAAS,IAAI,CAC7B,GAAG,IAA+C;QAElD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;QACnC,CAAC;QACD,0DAA0D;QAC1D,OAAO,IAAI,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;IAC5B,CAAC,CAAC;IACD,CAAS,CAAC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;IAC5C,0BAA0B;IAC1B,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,cAAc,CAAC;IAElC,sEAAsE;IACtE,MAAM,cAAc,GAAG,UAAU,CAAC,MAAM,CAAC;IACzC,MAAM,cAAc,GAAG,cAAc,CAAC,MAAM,CAAC;IAE7C,SAAS,eAAe,CAAC,KAAiB;QACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,UAAU,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAEzC,MAAM,WAAW,GAAG,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAE/D,CAAC,CAAC,MAAM,GAAG,IAAI,KAAK,CAAC,cAAc,EAAE;QACnC,GAAG,CAAC,MAAM,EAAE,IAAI;YACd,IAAI,IAAI,KAAK,iBAAiB,EAAE,CAAC;gBAC/B,OAAO,eAAe,CAAC;YACzB,CAAC;YACD,IAAI,IAAI,KAAK,YAAY,EAAE,CAAC;gBAC1B,OAAO,UAAU,CAAC;YACpB,CAAC;YACD,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,OAAO,IAAI,KAAK,CAAC,cAAc,EAAE;oBAC/B,GAAG,CAAC,MAAM,EAAE,IAAI;wBACd,IAAI,IAAI,KAAK,aAAa,EAAE,CAAC;4BAC3B,OAAO,GAAG,EAAE;gCACV,MAAM,IAAI,oBAAoB,CAC5B,2JAA2J,CAC5J,CAAC;4BACJ,CAAC,CAAC;wBACJ,CAAC;6BAAM,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;4BAC7B,OAAO,WAAW,CAAC;wBACrB,CAAC;wBACD,OAAO,MAAM,CAAC,IAAmC,CAAC,CAAC;oBACrD,CAAC;iBACF,CAAC,CAAC;YACL,CAAC;YACD,OAAO,MAAM,CAAC,IAAmC,CAAC,CAAC;QACrD,CAAC;KACF,CAAC,CAAC;IAEH,kCAAkC;IACjC,CAAS,CAAC,OAAO,GAAG;QACnB,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;KACvC,CAAC;IAEF,8EAA8E;IAC9E,CAAC,CAAC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;IACzC,CAAC,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;IAC/B,CAAC,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;IACvC,CAAC,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;IACvC,CAAC,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;IAC/B,CAAC,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC;IACvB,CAAC,CAAC,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC;IAC/C,CAAC,CAAC,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC;IAC/C,CAAC,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;IACzB,CAAC,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;IAEzB,oEAAoE;IACpE,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IAEtC,iEAAiE;IAChE,CAAC,CAAC,MAAc,CAAC,OAAO,KAAK,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IAC1D,CAAC,CAAC,MAAc,CAAC,YAAY,KAAK,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;IAErE,sCAAsC;IACtC,CAAC,CAAC,OAAO,GAAG,EAAE,CAAC;IACd,CAAS,CAAC,MAAM,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IAE3C,OAAO;QACL,OAAO;QACP,UAAU,EAAE,CAAC;QACb,eAAe,EAAE,CAAC,SAAiB,EAAE,EAAE;YACrC,cAAc,GAAG,SAAS,CAAC;QAC7B,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { 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/**\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 WorkflowRuntimeError(\n                  '`crypto.subtle.generateKey()` is not available inside a workflow function. Move key generation to a step function where full Node.js crypto is available.'\n                );\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,26 @@
+import { Script } from 'node:vm';
+/**
+ * Returns a compiled `vm.Script` for the given source 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: Script;
+    cacheHit: boolean;
+};
+/**
+ * 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 script source strings 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,MAAM,EAAE,MAAM,SAAS,CAAC;AAuFjC;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAsBvC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}