@workflow/core 5.0.0-beta.35 → 5.0.0-beta.37

package/dist/step-hydration-cache.d.ts

@@ -1,148 +0,0 @@
-/**
- * Per-run memoization cache for hydrated step return values.
- *
- * ## Why
- *
- * The inline replay loop (`runtime.ts`) re-runs the workflow body from the top
- * on every iteration, re-consuming the full event log each time. For every
- * already-completed step, the step consumer (`step.ts`) re-runs
- * `hydrateStepReturnValue` — which AES-GCM-decrypts and devalue-parses the
- * serialized result — even though that exact result was already hydrated on
- * every prior replay. For a sequential workflow of N steps, replay K hydrates
- * K results, so the total work across a single invocation is O(N²)
- * decrypt+parse operations.
- *
- * This cache makes a completed step's hydrated result available in O(1) on
- * subsequent replays within the SAME invocation, turning the aggregate cost
- * into O(N).
- *
- * ## Scope / lifetime
- *
- * The cache is owned by the inline loop in `runtime.ts` (one per workflow run
- * invocation) and passed into `runWorkflow` so it survives across the loop's
- * iterations but never leaks across unrelated runs or process-level
- * invocations. A fresh `runWorkflow` / `WorkflowOrchestratorContext` is created
- * each iteration, so the cache must live OUTSIDE the per-iteration context.
- *
- * ## Keying
- *
- * Entries are keyed by the persisted event's `eventId` — a stable,
- * world-assigned identifier for the `step_completed` event whose serialized
- * `result` is being hydrated. The same event (same `eventId`) carries the same
- * immutable serialized bytes across every replay, so a hit is guaranteed to
- * correspond to the identical input.
- *
- * ## Identity safety (why primitives only)
- *
- * `hydrateStepReturnValue` (devalue.parse) produces a FRESH object graph on
- * every call, and each replay iteration runs in a FRESH workflow VM. The
- * current (uncached) behavior therefore hands the workflow a brand-new value
- * on every replay. If we cached and returned the SAME object reference across
- * replays, workflow code that mutates a step result (`const r = await step();
- * r.count++`) would observe the mutation from a previous replay on the next
- * replay — a non-deterministic divergence. Structured-cloning on each hit is
- * both lossy (revivers reconstruct stream handles, step-function proxies,
- * Request/Response, and AbortController/AbortSignal class instances that don't
- * survive a structured clone) and still O(size).
- *
- * So we only cache values for which returning the same reference on every
- * replay is provably indistinguishable from re-hydrating: JavaScript
- * primitives (string, number, boolean, bigint, symbol, null, undefined).
- * Primitives are immutable and compared by value, so sharing the reference is
- * byte-for-byte equivalent to re-parsing. Any non-primitive result falls
- * through to a full re-hydrate every replay, preserving current behavior
- * exactly. This trades some of the optimization away in the object-returning
- * case in exchange for keeping deterministic replay airtight.
- *
- * ## Memory characteristic
- *
- * Cached entries hold the decrypted/devalue-parsed *plaintext* of a step
- * result, which is retained for the rest of the invocation on top of the
- * serialized bytes already held in `cachedEvents`. So the residual cost is:
- *
- * - **Scoped to one workflow-run invocation.** A fresh `Map` is created per
- *   invocation (in `runtime.ts`) and is unreachable / GC'd when the invocation
- *   returns. Nothing accumulates across runs or across process-level
- *   invocations.
- * - **Bounded by the number of primitive-returning completed steps in that
- *   run** — at most one small entry per such step.
- * - **Primitives only, and additionally byte-bounded.** Most primitives
- *   (numbers, booleans, null/undefined, symbols, short ids/strings) are tiny
- *   and fixed-size. The only primitive that can be large is a string (or a
- *   pathologically long bigint), so to keep the doubled-residency worst case
- *   bounded we *do not* memoize string/bigint results whose character length
- *   exceeds {@link MAX_MEMOIZED_PRIMITIVE_LENGTH}. A large string is cheap to
- *   re-hydrate relative to its footprint, so letting it fall through to the
- *   existing per-replay re-hydrate path costs little and caps peak retained
- *   memory.
- *
- * (This is a much weaker concern than a *process-wide* cache: the dominant
- * residency — the full event log in `cachedEvents` — already exists for the
- * same lifetime, and everything here is freed together with it when the
- * invocation ends.)
- */
-/**
- * Upper bound, in characters, on a string/bigint primitive that may be
- * memoized. Beyond this, the value falls through to a fresh re-hydrate on every
- * replay so the cache never holds a large plaintext payload for the lifetime of
- * the invocation. 4 KiB comfortably covers ids, counts, flags, and typical
- * short string results while excluding the large-payload case the bound exists
- * to guard. Other primitive types (number, boolean, symbol, null, undefined)
- * are inherently small and are never length-checked.
- */
-export declare const MAX_MEMOIZED_PRIMITIVE_LENGTH = 4096;
-/**
- * Returns true for values that are safe to memoize and return by reference
- * across replays: JS primitives. Objects and functions are excluded because
- * sharing a mutable reference across replays could change observable behavior.
- *
- * Strings and bigints are additionally bounded by length: a value longer than
- * {@link MAX_MEMOIZED_PRIMITIVE_LENGTH} characters is treated as non-memoizable
- * so the cache never retains a large plaintext payload for the whole invocation
- * (see the module-level "Memory characteristic" docs). It re-hydrates fresh on
- * every replay instead — cheap relative to its footprint.
- *
- * Note: `typeof null === 'object'`, so it is handled explicitly. `undefined`,
- * `string`, `number`, `boolean`, `bigint`, and `symbol` are all primitives.
- */
-export declare function isMemoizablePrimitive(value: unknown): boolean;
-/**
- * Cache of hydrated step return values for a single workflow run invocation.
- *
- * Keyed by `step_completed` event id; the value is the already-hydrated
- * primitive result. Only successful, primitive hydrations are stored (see
- * {@link getOrHydrateStepReturnValue}), so a non-`undefined` `has(eventId)`
- * always means "this step completed with a memoizable primitive value".
- */
-export type StepHydrationCache = Map<string, unknown>;
-/**
- * Create an empty per-invocation step hydration cache.
- */
-export declare function createStepHydrationCache(): StepHydrationCache;
-/**
- * Return the hydrated step result for `eventId`, using `cache` as a per-run
- * memo. On a hit, the cached primitive is returned without re-running the
- * expensive decrypt + devalue-parse. On a miss, `hydrate()` runs and its
- * result is memoized only when it is a small primitive (see the module docs for
- * the identity-safety rationale and the length bound on string/bigint results).
- *
- * This always returns a `Promise` and `await`s `hydrate()` even on the miss
- * path, so the caller's `await` inside its serial `promiseQueue` slot keeps the
- * same scheduling on both hit and miss — a cache hit resolves through the exact
- * same promise-chain position a re-hydrate would have, preserving the
- * deterministic delivery order that `pendingDeliveries`, the delivery barriers,
- * and `Promise.race`/`Promise.all` replay all depend on.
- *
- * `has(eventId)` is used rather than `get(eventId) !== undefined` so that a
- * legitimately memoized `undefined` step result still registers as a hit.
- *
- * When `cache` or `eventId` is absent (lightweight test harnesses, or a context
- * that predates this plumbing), this degrades to calling `hydrate()` directly
- * with no memoization — identical to the previous behavior.
- *
- * Errors are intentionally never cached: a rejected hydrate propagates to the
- * caller (which rejects the step promise) and the next replay re-attempts it,
- * matching the uncached behavior and avoiding a parked rejected promise.
- */
-export declare function getOrHydrateStepReturnValue(cache: StepHydrationCache | undefined, eventId: string | undefined, hydrate: () => Promise<unknown>): Promise<unknown>;
-//# sourceMappingURL=step-hydration-cache.d.ts.map

package/dist/step-hydration-cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"step-hydration-cache.d.ts","sourceRoot":"","sources":["../src/step-hydration-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAElD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAY7D;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEtD;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,kBAAkB,CAE7D;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,kBAAkB,GAAG,SAAS,EACrC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAC9B,OAAO,CAAC,OAAO,CAAC,CAkBlB"}

package/dist/step-hydration-cache.js

@@ -1,171 +0,0 @@
-/**
- * Per-run memoization cache for hydrated step return values.
- *
- * ## Why
- *
- * The inline replay loop (`runtime.ts`) re-runs the workflow body from the top
- * on every iteration, re-consuming the full event log each time. For every
- * already-completed step, the step consumer (`step.ts`) re-runs
- * `hydrateStepReturnValue` — which AES-GCM-decrypts and devalue-parses the
- * serialized result — even though that exact result was already hydrated on
- * every prior replay. For a sequential workflow of N steps, replay K hydrates
- * K results, so the total work across a single invocation is O(N²)
- * decrypt+parse operations.
- *
- * This cache makes a completed step's hydrated result available in O(1) on
- * subsequent replays within the SAME invocation, turning the aggregate cost
- * into O(N).
- *
- * ## Scope / lifetime
- *
- * The cache is owned by the inline loop in `runtime.ts` (one per workflow run
- * invocation) and passed into `runWorkflow` so it survives across the loop's
- * iterations but never leaks across unrelated runs or process-level
- * invocations. A fresh `runWorkflow` / `WorkflowOrchestratorContext` is created
- * each iteration, so the cache must live OUTSIDE the per-iteration context.
- *
- * ## Keying
- *
- * Entries are keyed by the persisted event's `eventId` — a stable,
- * world-assigned identifier for the `step_completed` event whose serialized
- * `result` is being hydrated. The same event (same `eventId`) carries the same
- * immutable serialized bytes across every replay, so a hit is guaranteed to
- * correspond to the identical input.
- *
- * ## Identity safety (why primitives only)
- *
- * `hydrateStepReturnValue` (devalue.parse) produces a FRESH object graph on
- * every call, and each replay iteration runs in a FRESH workflow VM. The
- * current (uncached) behavior therefore hands the workflow a brand-new value
- * on every replay. If we cached and returned the SAME object reference across
- * replays, workflow code that mutates a step result (`const r = await step();
- * r.count++`) would observe the mutation from a previous replay on the next
- * replay — a non-deterministic divergence. Structured-cloning on each hit is
- * both lossy (revivers reconstruct stream handles, step-function proxies,
- * Request/Response, and AbortController/AbortSignal class instances that don't
- * survive a structured clone) and still O(size).
- *
- * So we only cache values for which returning the same reference on every
- * replay is provably indistinguishable from re-hydrating: JavaScript
- * primitives (string, number, boolean, bigint, symbol, null, undefined).
- * Primitives are immutable and compared by value, so sharing the reference is
- * byte-for-byte equivalent to re-parsing. Any non-primitive result falls
- * through to a full re-hydrate every replay, preserving current behavior
- * exactly. This trades some of the optimization away in the object-returning
- * case in exchange for keeping deterministic replay airtight.
- *
- * ## Memory characteristic
- *
- * Cached entries hold the decrypted/devalue-parsed *plaintext* of a step
- * result, which is retained for the rest of the invocation on top of the
- * serialized bytes already held in `cachedEvents`. So the residual cost is:
- *
- * - **Scoped to one workflow-run invocation.** A fresh `Map` is created per
- *   invocation (in `runtime.ts`) and is unreachable / GC'd when the invocation
- *   returns. Nothing accumulates across runs or across process-level
- *   invocations.
- * - **Bounded by the number of primitive-returning completed steps in that
- *   run** — at most one small entry per such step.
- * - **Primitives only, and additionally byte-bounded.** Most primitives
- *   (numbers, booleans, null/undefined, symbols, short ids/strings) are tiny
- *   and fixed-size. The only primitive that can be large is a string (or a
- *   pathologically long bigint), so to keep the doubled-residency worst case
- *   bounded we *do not* memoize string/bigint results whose character length
- *   exceeds {@link MAX_MEMOIZED_PRIMITIVE_LENGTH}. A large string is cheap to
- *   re-hydrate relative to its footprint, so letting it fall through to the
- *   existing per-replay re-hydrate path costs little and caps peak retained
- *   memory.
- *
- * (This is a much weaker concern than a *process-wide* cache: the dominant
- * residency — the full event log in `cachedEvents` — already exists for the
- * same lifetime, and everything here is freed together with it when the
- * invocation ends.)
- */
-/**
- * Upper bound, in characters, on a string/bigint primitive that may be
- * memoized. Beyond this, the value falls through to a fresh re-hydrate on every
- * replay so the cache never holds a large plaintext payload for the lifetime of
- * the invocation. 4 KiB comfortably covers ids, counts, flags, and typical
- * short string results while excluding the large-payload case the bound exists
- * to guard. Other primitive types (number, boolean, symbol, null, undefined)
- * are inherently small and are never length-checked.
- */
-export const MAX_MEMOIZED_PRIMITIVE_LENGTH = 4096;
-/**
- * Returns true for values that are safe to memoize and return by reference
- * across replays: JS primitives. Objects and functions are excluded because
- * sharing a mutable reference across replays could change observable behavior.
- *
- * Strings and bigints are additionally bounded by length: a value longer than
- * {@link MAX_MEMOIZED_PRIMITIVE_LENGTH} characters is treated as non-memoizable
- * so the cache never retains a large plaintext payload for the whole invocation
- * (see the module-level "Memory characteristic" docs). It re-hydrates fresh on
- * every replay instead — cheap relative to its footprint.
- *
- * Note: `typeof null === 'object'`, so it is handled explicitly. `undefined`,
- * `string`, `number`, `boolean`, `bigint`, and `symbol` are all primitives.
- */
-export function isMemoizablePrimitive(value) {
-    if (value === null)
-        return true;
-    const t = typeof value;
-    if (t === 'object' || t === 'function')
-        return false;
-    // Bound the only primitive types that can carry a large payload.
-    if (t === 'string') {
-        return value.length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;
-    }
-    if (t === 'bigint') {
-        return value.toString().length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;
-    }
-    return true;
-}
-/**
- * Create an empty per-invocation step hydration cache.
- */
-export function createStepHydrationCache() {
-    return new Map();
-}
-/**
- * Return the hydrated step result for `eventId`, using `cache` as a per-run
- * memo. On a hit, the cached primitive is returned without re-running the
- * expensive decrypt + devalue-parse. On a miss, `hydrate()` runs and its
- * result is memoized only when it is a small primitive (see the module docs for
- * the identity-safety rationale and the length bound on string/bigint results).
- *
- * This always returns a `Promise` and `await`s `hydrate()` even on the miss
- * path, so the caller's `await` inside its serial `promiseQueue` slot keeps the
- * same scheduling on both hit and miss — a cache hit resolves through the exact
- * same promise-chain position a re-hydrate would have, preserving the
- * deterministic delivery order that `pendingDeliveries`, the delivery barriers,
- * and `Promise.race`/`Promise.all` replay all depend on.
- *
- * `has(eventId)` is used rather than `get(eventId) !== undefined` so that a
- * legitimately memoized `undefined` step result still registers as a hit.
- *
- * When `cache` or `eventId` is absent (lightweight test harnesses, or a context
- * that predates this plumbing), this degrades to calling `hydrate()` directly
- * with no memoization — identical to the previous behavior.
- *
- * Errors are intentionally never cached: a rejected hydrate propagates to the
- * caller (which rejects the step promise) and the next replay re-attempts it,
- * matching the uncached behavior and avoiding a parked rejected promise.
- */
-export async function getOrHydrateStepReturnValue(cache, eventId, hydrate) {
-    if (!cache || eventId === undefined) {
-        return hydrate();
-    }
-    if (cache.has(eventId)) {
-        return cache.get(eventId);
-    }
-    const value = await hydrate();
-    // Only memoize values that are safe to return by reference across replays
-    // AND small enough to retain for the invocation. Non-primitives and
-    // oversized string/bigint values fall through and are re-hydrated fresh on
-    // every replay (see isMemoizablePrimitive / MAX_MEMOIZED_PRIMITIVE_LENGTH).
-    if (isMemoizablePrimitive(value)) {
-        cache.set(eventId, value);
-    }
-    return value;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-hydration-cache.js","sourceRoot":"","sources":["../src/step-hydration-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,IAAI,CAAC;AAElD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAc;IAClD,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAChC,MAAM,CAAC,GAAG,OAAO,KAAK,CAAC;IACvB,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,UAAU;QAAE,OAAO,KAAK,CAAC;IACrD,iEAAiE;IACjE,IAAI,CAAC,KAAK,QAAQ,EAAE,CAAC;QACnB,OAAQ,KAAgB,CAAC,MAAM,IAAI,6BAA6B,CAAC;IACnE,CAAC;IACD,IAAI,CAAC,KAAK,QAAQ,EAAE,CAAC;QACnB,OAAQ,KAAgB,CAAC,QAAQ,EAAE,CAAC,MAAM,IAAI,6BAA6B,CAAC;IAC9E,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAYD;;GAEG;AACH,MAAM,UAAU,wBAAwB;IACtC,OAAO,IAAI,GAAG,EAAE,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAC/C,KAAqC,EACrC,OAA2B,EAC3B,OAA+B;IAE/B,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QACpC,OAAO,OAAO,EAAE,CAAC;IACnB,CAAC;IAED,IAAI,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;QACvB,OAAO,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,OAAO,EAAE,CAAC;IAC9B,0EAA0E;IAC1E,oEAAoE;IACpE,2EAA2E;IAC3E,4EAA4E;IAC5E,IAAI,qBAAqB,CAAC,KAAK,CAAC,EAAE,CAAC;QACjC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["/**\n * Per-run memoization cache for hydrated step return values.\n *\n * ## Why\n *\n * The inline replay loop (`runtime.ts`) re-runs the workflow body from the top\n * on every iteration, re-consuming the full event log each time. For every\n * already-completed step, the step consumer (`step.ts`) re-runs\n * `hydrateStepReturnValue` — which AES-GCM-decrypts and devalue-parses the\n * serialized result — even though that exact result was already hydrated on\n * every prior replay. For a sequential workflow of N steps, replay K hydrates\n * K results, so the total work across a single invocation is O(N²)\n * decrypt+parse operations.\n *\n * This cache makes a completed step's hydrated result available in O(1) on\n * subsequent replays within the SAME invocation, turning the aggregate cost\n * into O(N).\n *\n * ## Scope / lifetime\n *\n * The cache is owned by the inline loop in `runtime.ts` (one per workflow run\n * invocation) and passed into `runWorkflow` so it survives across the loop's\n * iterations but never leaks across unrelated runs or process-level\n * invocations. A fresh `runWorkflow` / `WorkflowOrchestratorContext` is created\n * each iteration, so the cache must live OUTSIDE the per-iteration context.\n *\n * ## Keying\n *\n * Entries are keyed by the persisted event's `eventId` — a stable,\n * world-assigned identifier for the `step_completed` event whose serialized\n * `result` is being hydrated. The same event (same `eventId`) carries the same\n * immutable serialized bytes across every replay, so a hit is guaranteed to\n * correspond to the identical input.\n *\n * ## Identity safety (why primitives only)\n *\n * `hydrateStepReturnValue` (devalue.parse) produces a FRESH object graph on\n * every call, and each replay iteration runs in a FRESH workflow VM. The\n * current (uncached) behavior therefore hands the workflow a brand-new value\n * on every replay. If we cached and returned the SAME object reference across\n * replays, workflow code that mutates a step result (`const r = await step();\n * r.count++`) would observe the mutation from a previous replay on the next\n * replay — a non-deterministic divergence. Structured-cloning on each hit is\n * both lossy (revivers reconstruct stream handles, step-function proxies,\n * Request/Response, and AbortController/AbortSignal class instances that don't\n * survive a structured clone) and still O(size).\n *\n * So we only cache values for which returning the same reference on every\n * replay is provably indistinguishable from re-hydrating: JavaScript\n * primitives (string, number, boolean, bigint, symbol, null, undefined).\n * Primitives are immutable and compared by value, so sharing the reference is\n * byte-for-byte equivalent to re-parsing. Any non-primitive result falls\n * through to a full re-hydrate every replay, preserving current behavior\n * exactly. This trades some of the optimization away in the object-returning\n * case in exchange for keeping deterministic replay airtight.\n *\n * ## Memory characteristic\n *\n * Cached entries hold the decrypted/devalue-parsed *plaintext* of a step\n * result, which is retained for the rest of the invocation on top of the\n * serialized bytes already held in `cachedEvents`. So the residual cost is:\n *\n * - **Scoped to one workflow-run invocation.** A fresh `Map` is created per\n *   invocation (in `runtime.ts`) and is unreachable / GC'd when the invocation\n *   returns. Nothing accumulates across runs or across process-level\n *   invocations.\n * - **Bounded by the number of primitive-returning completed steps in that\n *   run** — at most one small entry per such step.\n * - **Primitives only, and additionally byte-bounded.** Most primitives\n *   (numbers, booleans, null/undefined, symbols, short ids/strings) are tiny\n *   and fixed-size. The only primitive that can be large is a string (or a\n *   pathologically long bigint), so to keep the doubled-residency worst case\n *   bounded we *do not* memoize string/bigint results whose character length\n *   exceeds {@link MAX_MEMOIZED_PRIMITIVE_LENGTH}. A large string is cheap to\n *   re-hydrate relative to its footprint, so letting it fall through to the\n *   existing per-replay re-hydrate path costs little and caps peak retained\n *   memory.\n *\n * (This is a much weaker concern than a *process-wide* cache: the dominant\n * residency — the full event log in `cachedEvents` — already exists for the\n * same lifetime, and everything here is freed together with it when the\n * invocation ends.)\n */\n\n/**\n * Upper bound, in characters, on a string/bigint primitive that may be\n * memoized. Beyond this, the value falls through to a fresh re-hydrate on every\n * replay so the cache never holds a large plaintext payload for the lifetime of\n * the invocation. 4 KiB comfortably covers ids, counts, flags, and typical\n * short string results while excluding the large-payload case the bound exists\n * to guard. Other primitive types (number, boolean, symbol, null, undefined)\n * are inherently small and are never length-checked.\n */\nexport const MAX_MEMOIZED_PRIMITIVE_LENGTH = 4096;\n\n/**\n * Returns true for values that are safe to memoize and return by reference\n * across replays: JS primitives. Objects and functions are excluded because\n * sharing a mutable reference across replays could change observable behavior.\n *\n * Strings and bigints are additionally bounded by length: a value longer than\n * {@link MAX_MEMOIZED_PRIMITIVE_LENGTH} characters is treated as non-memoizable\n * so the cache never retains a large plaintext payload for the whole invocation\n * (see the module-level \"Memory characteristic\" docs). It re-hydrates fresh on\n * every replay instead — cheap relative to its footprint.\n *\n * Note: `typeof null === 'object'`, so it is handled explicitly. `undefined`,\n * `string`, `number`, `boolean`, `bigint`, and `symbol` are all primitives.\n */\nexport function isMemoizablePrimitive(value: unknown): boolean {\n  if (value === null) return true;\n  const t = typeof value;\n  if (t === 'object' || t === 'function') return false;\n  // Bound the only primitive types that can carry a large payload.\n  if (t === 'string') {\n    return (value as string).length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;\n  }\n  if (t === 'bigint') {\n    return (value as bigint).toString().length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;\n  }\n  return true;\n}\n\n/**\n * Cache of hydrated step return values for a single workflow run invocation.\n *\n * Keyed by `step_completed` event id; the value is the already-hydrated\n * primitive result. Only successful, primitive hydrations are stored (see\n * {@link getOrHydrateStepReturnValue}), so a non-`undefined` `has(eventId)`\n * always means \"this step completed with a memoizable primitive value\".\n */\nexport type StepHydrationCache = Map<string, unknown>;\n\n/**\n * Create an empty per-invocation step hydration cache.\n */\nexport function createStepHydrationCache(): StepHydrationCache {\n  return new Map();\n}\n\n/**\n * Return the hydrated step result for `eventId`, using `cache` as a per-run\n * memo. On a hit, the cached primitive is returned without re-running the\n * expensive decrypt + devalue-parse. On a miss, `hydrate()` runs and its\n * result is memoized only when it is a small primitive (see the module docs for\n * the identity-safety rationale and the length bound on string/bigint results).\n *\n * This always returns a `Promise` and `await`s `hydrate()` even on the miss\n * path, so the caller's `await` inside its serial `promiseQueue` slot keeps the\n * same scheduling on both hit and miss — a cache hit resolves through the exact\n * same promise-chain position a re-hydrate would have, preserving the\n * deterministic delivery order that `pendingDeliveries`, the delivery barriers,\n * and `Promise.race`/`Promise.all` replay all depend on.\n *\n * `has(eventId)` is used rather than `get(eventId) !== undefined` so that a\n * legitimately memoized `undefined` step result still registers as a hit.\n *\n * When `cache` or `eventId` is absent (lightweight test harnesses, or a context\n * that predates this plumbing), this degrades to calling `hydrate()` directly\n * with no memoization — identical to the previous behavior.\n *\n * Errors are intentionally never cached: a rejected hydrate propagates to the\n * caller (which rejects the step promise) and the next replay re-attempts it,\n * matching the uncached behavior and avoiding a parked rejected promise.\n */\nexport async function getOrHydrateStepReturnValue(\n  cache: StepHydrationCache | undefined,\n  eventId: string | undefined,\n  hydrate: () => Promise<unknown>\n): Promise<unknown> {\n  if (!cache || eventId === undefined) {\n    return hydrate();\n  }\n\n  if (cache.has(eventId)) {\n    return cache.get(eventId);\n  }\n\n  const value = await hydrate();\n  // Only memoize values that are safe to return by reference across replays\n  // AND small enough to retain for the invocation. Non-primitives and\n  // oversized string/bigint values fall through and are re-hydrated fresh on\n  // every replay (see isMemoizablePrimitive / MAX_MEMOIZED_PRIMITIVE_LENGTH).\n  if (isMemoizablePrimitive(value)) {\n    cache.set(eventId, value);\n  }\n  return value;\n}\n"]}