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

package/docs/api-reference/fetch.mdx

@@ -93,7 +93,7 @@ This API is provided as a convenience to easily use `fetch` in workflow, but oft
 
 ### Customizing Fetch Behavior
 
-Here's an example of a custom fetch wrapper that provides more sophisticated error handling with custom retry logic:
+Here's an example of a custom fetch wrapper that provides more sophisticated error handling with custom retry logic. Call `globalThis.fetch` inside your own `"use step"` function — calling the workflow `fetch` imported from `workflow` would nest a step inside a step:
 
 ```typescript lineNumbers
 import { FatalError, RetryableError } from "workflow"
@@ -104,7 +104,7 @@ export async function customFetch(
 ) {
     "use step"
 
-    const response = await fetch(url, init)
+    const response = await globalThis.fetch(url, init)
 
     // Handle client errors (4xx) - don't retry
     if (response.status >= 400 && response.status < 500) {
@@ -145,7 +145,6 @@ export async function customFetch(
 
 This example demonstrates:
 
-- Setting custom `maxRetries` to 5 retries (6 total attempts including the initial attempt).
 - Throwing [`FatalError`](/docs/api-reference/workflow/fatal-error) for client errors (400-499) to prevent retries.
 - Handling 429 rate limiting by reading the `Retry-After` header and using [`RetryableError`](/docs/api-reference/workflow/retryable-error).
-- Allowing automatic retries for server errors (5xx).
+- Allowing automatic retries for server errors (5xx) by throwing a plain `Error`.

package/docs/api-reference/sleep.mdx

@@ -14,7 +14,7 @@ Suspends a workflow for a specified duration or until an end date without consum
 This is useful when you want to resume a workflow after some duration or date.
 
 <Callout>
-`sleep` is a *special* type of step function and should be called directly inside workflow functions.
+`sleep` is a built-in workflow runtime function (backed by a timer event in the event log, not a step) and should be called directly inside workflow functions.
 </Callout>
 
 ```typescript lineNumbers

package/docs/foundations/hooks.mdx

@@ -112,7 +112,7 @@ export async function orderWorkflow(orderId: string) {
 }
 ```
 
-Calling `createHook()` on its own does not register the hook — registration is only committed when the workflow suspends. Awaiting `hook.getConflict()` suspends the workflow to commit the hook registration, then resolves with `null` once the hook is registered and ready to receive payloads, or with a `Run` handle for the run that owns the token if another active hook already claimed it (see [`HookConflictError`](/docs/errors/hook-conflict)). For `hook_conflict` events persisted by older worlds that did not record the owning run's ID, `getConflict()` rejects with `HookConflictError` instead of resolving with an incomplete handle. The conflicting run's accessors are durable steps, so the workflow can inspect `await conflict.status`, wait on `await conflict.returnValue`, or cancel the owner with `await conflict.cancel()` — see [Run idempotency](/docs/foundations/idempotency#run-idempotency) for these strategies.
+Calling `createHook()` on its own does not register the hook — registration is only committed when the workflow suspends. Awaiting `hook.getConflict()` suspends the workflow to commit the hook registration, then resolves with `null` once the hook is registered and ready to receive payloads, or with a `Run` handle for the run that owns the token (see [`HookConflictError`](/docs/errors/hook-conflict)). For `hook_conflict` events persisted by older worlds that did not record the owning run's ID, `getConflict()` rejects with `HookConflictError` instead of resolving with an incomplete handle. The conflicting run's accessors are durable steps, so the workflow can inspect `await conflict.status`, wait on `await conflict.returnValue`, or cancel the owner with `await conflict.cancel()` — see [Run idempotency](/docs/foundations/idempotency#run-idempotency) for these strategies.
 
 ### Custom Tokens for Deterministic Hooks
 

package/docs/foundations/idempotency.mdx

@@ -96,7 +96,7 @@ export async function processOrder(orderId: string): Promise<OrderResult> {
 }
 ```
 
-The runtime creates the hook atomically. At most one active hook can own `order:${orderId}`, so duplicate workflow runs converge on one active owner. A duplicate run observes `getConflict()` resolving with the owner's `Run` and returns before it reaches `chargeOrder()`. The conflicting run's accessors (`status`, `returnValue`, `cancel()`, …) are durable steps, so the duplicate run can do more than report the owner — see [conflict-handling strategies](#conflict-handling-strategies) below.
+The runtime creates the hook atomically. At most one hook can own `order:${orderId}`, so duplicate workflow runs converge on one owner. A duplicate run observes `getConflict()` resolving with the owner's `Run` and returns before it reaches `chargeOrder()`. The conflicting run's accessors (`status`, `returnValue`, `cancel()`, …) are durable steps, so the duplicate run can do more than report the owner — see [conflict-handling strategies](#conflict-handling-strategies) below.
 
 Outside the workflow, try to resume the hook first. If the hook is not registered yet, start the workflow and retry the resume until the new run creates the hook:
 
@@ -149,7 +149,7 @@ export async function POST(request: Request) {
 This avoids creating a new run only after the first run has registered its hook. Because `start()` returns before the run body executes and calls `createHook()`, two concurrent requests can both observe "no hook yet" and each call `start()`. The race is resolved inside the workflow body, where the losing run observes `getConflict()` resolving with the active owner and returns without doing duplicate-sensitive work — and the route detects it by comparing the resumed hook's `runId` against the run it just started, without waiting for either run to finish. A native API for atomically starting a run and registering a hook is in the works. Until then, model recovery inside the workflow by checking `hook.getConflict()`.
 </Callout>
 
-This is active-run coordination. When the workflow completes and disposes the hook, the token can be used again. If a duplicate request after completion must return the original result instead of starting fresh work, persist that completed result under the same domain key.
+This coordinates active runs by default: the token becomes available when its workflow ends. Set `experimental_minRetention` to keep it unavailable to late duplicates. After the workflow ends, the Hook can still be found with `getHookByToken()` until retention ends, but it cannot be resumed. See [`createHook()` minimum retention](/docs/api-reference/workflow/create-hook#keep-a-token-unavailable-after-the-run-ends) for examples and supported values.
 
 ### Conflict-handling strategies
 
@@ -182,7 +182,7 @@ export async function processOrder(orderId: string) {
 }
 ```
 
-**Inspect the owner before deciding.** Branch on the owner's live state:
+**Inspect the owner before deciding.** Reuse a completed owner's result, but reject other duplicates:
 
 ```typescript lineNumbers
 import { createHook } from "workflow";
@@ -200,17 +200,17 @@ export async function processOrder(orderId: string) {
   const conflict = await request.getConflict();
   if (conflict) {
     const status = await conflict.status; // [!code highlight]
-    if (status === "running") {
-      return { status: "duplicate" as const, runId: conflict.runId };
+    if (status === "completed") {
+      return await conflict.returnValue;
     }
-    // Owner already reached a terminal state; its hook will be released.
+    return { status: "duplicate" as const, runId: conflict.runId };
   }
 
   return await processOwnedOrder(orderId);
 }
 ```
 
-**Signal the owner instead of doing the work.** The duplicate run knows the token, so it can deliver this run's input to the owner's hook from a step:
+**Signal the owner instead of doing the work.** A conflict can refer to a finished run when `experimental_minRetention` is set, so check its status before sending data to its Hook:
 
 ```typescript lineNumbers
 import { createHook } from "workflow";
@@ -230,16 +230,19 @@ export async function processOrder(orderId: string, confirmed: boolean) {
   using request = createHook<OrderRequest>({ token });
 
   const conflict = await request.getConflict();
-  if (conflict) {
+  if (conflict && ["pending", "running"].includes(await conflict.status)) {
     await forwardToOwner(token, { confirmed }); // [!code highlight]
     return { status: "forwarded" as const, runId: conflict.runId };
   }
+  if (conflict) {
+    return { status: "duplicate" as const, runId: conflict.runId };
+  }
 
   // ... own the token and do the work
 }
 ```
 
-**Supersede the owner.** Newest-wins: cancel the active run, then claim the released token. Cancellation disposes the owner's hooks; the retry loop covers the window where that disposal has not propagated yet:
+**Supersede the owner.** Without minimum retention, cancel the active run, then claim the released token. The retry loop covers the window where cancellation cleanup has not propagated yet:
 
 ```typescript lineNumbers
 import { createHook } from "workflow";
@@ -272,6 +275,10 @@ export async function processOrderNewestWins(orderId: string) {
 }
 ```
 
+<Callout type="warn">
+This pattern does not work with `experimental_minRetention`: cancelling the old run does not make its token available early.
+</Callout>
+
 If duplicate requests should only reuse the active run without sending data, use [`getHookByToken()`](/docs/api-reference/workflow-api/get-hook-by-token) as an advisory pre-check before calling `start()`. The workflow should still check `hook.getConflict()`, because the lookup and `start()` are not atomic.
 
 Because this pattern uses hooks for idempotency, duplicate requests can also inject additional data and steer the existing run. The route example above uses `resumeHook()` for that: if the hook already exists, the duplicate request resumes the active workflow; if the hook is not registered yet, the route starts the workflow and retries `resumeHook()` so the payload is not dropped.

package/docs/how-it-works/encryption.mdx

@@ -7,7 +7,7 @@ prerequisites:
   - /docs/how-it-works/event-sourcing
 related:
   - /docs/observability
-  - /docs/deploying/world/vercel-world
+  - /worlds/vercel
 ---
 
 <Callout>
@@ -38,7 +38,7 @@ Metadata such as workflow names, step names, entity IDs, timestamps, and lifecyc
 
 Each workflow run is encrypted with its own unique key, provided by the `World` implementation via `getEncryptionKeyForRun()`. How the key is generated and stored is up to the `World`.
 
-For example, the [Vercel World](/docs/deploying/world/vercel-world) provides unique keys per run and execution environment, ensuring that a given run can only decrypt data from that run itself.
+For example, the [Vercel World](/worlds/vercel) provides unique keys per run and execution environment, ensuring that a given run can only decrypt data from that run itself.
 
 ### Encryption Algorithm
 
@@ -127,4 +127,4 @@ async function lookupRunKey(
 }
 ```
 
-The [Vercel World](/docs/deploying/world/vercel-world) implementation uses HKDF derivation from a deployment-scoped key, but any consistent key management scheme will work.
+The [Vercel World](/worlds/vercel) implementation uses HKDF derivation from a deployment-scoped key, but any consistent key management scheme will work.

package/docs/how-it-works/event-sourcing.mdx

@@ -121,15 +121,15 @@ flowchart TD
 
 **Hook states:**
 
-- `active`: Ready to receive payloads (hook exists in storage)
-- `disposed`: No longer accepting payloads (hook is deleted from storage)
+- `active`: Ready to receive payloads
+- `disposed`: No longer accepting payloads
 - `conflicted`: Hook creation failed because the token is already in use by another workflow
 
-Unlike other entities, hooks don't have a `status` field—the states above are conceptual. An "active" hook is one that exists in storage, while "disposed" means the hook has been deleted. When a `hook_disposed` event is created, the hook record is removed rather than updated.
+Unlike other entities, hooks don't have a `status` field—the states above are conceptual. When a `hook_disposed` event is created, the hook record is removed rather than updated.
 
-While a hook is active, its token is reserved and cannot be used by other workflows. If a workflow attempts to create a hook with a token that is already in use by another active hook, a `hook_conflict` event is recorded instead of `hook_created`. Current worlds include the token and the run ID that currently owns it, though older persisted events or world implementations may only include the token. This causes `hook.getConflict()` to resolve with the conflicting run and the hook's payload promise to reject with a `HookConflictError`, which you can detect with `HookConflictError.is(error)`. See the [hook-conflict error](/docs/errors/hook-conflict) documentation for more details.
+While a hook is active, its token is reserved and cannot be used by other workflows. If a workflow attempts to create a hook with a token reserved by another run — either by an active hook or by `experimental_minRetention` after its run ended — a `hook_conflict` event is recorded instead of `hook_created`. Current worlds include the token and the run ID that owns it, though older persisted events or world implementations may only include the token. This causes `hook.getConflict()` to resolve with the conflicting run and the hook's payload promise to reject with a `HookConflictError`, which you can detect with `HookConflictError.is(error)`. See the [hook-conflict error](/docs/errors/hook-conflict) documentation for more details.
 
-When a hook is disposed (either explicitly or when its workflow completes), the token is released and can be claimed by future workflows. Hooks are automatically disposed when a workflow reaches a terminal state (`completed`, `failed`, or `cancelled`). The `hook_disposed` event is only needed for explicit disposal before workflow completion.
+When a workflow ends, its Hooks can no longer be resumed. They are normally removed and their tokens become available again. With `experimental_minRetention`, a Hook remains readable and its token remains unavailable until retention ends. A `hook_disposed` event removes the Hook and makes its token available immediately.
 
 See [Hooks & Webhooks](/docs/foundations/hooks) for more on how hooks and webhooks work.
 
@@ -188,7 +188,7 @@ Events are categorized by the entity type they affect. Each event contains metad
 | Event | Description |
 |-------|-------------|
 | `hook_created` | Creates a new hook in `active` state. Contains the hook token and optional metadata. |
-| `hook_conflict` | Records that hook creation failed because the token is already in use by another active hook. Contains the token and, for current worlds, the active hook owner's run ID. The hook is not created: `hook.getConflict()` resolves with the conflicting run, and awaiting the hook payload rejects with a `HookConflictError`. |
+| `hook_conflict` | Records that hook creation failed because another run owns the token. Contains the token and, for current worlds, the owner's run ID. The hook is not created: `hook.getConflict()` resolves with the conflicting run, and awaiting the hook payload rejects with a `HookConflictError`. |
 | `hook_received` | Records that a payload was delivered to the hook. The hook remains `active` and can receive more payloads. |
 | `hook_disposed` | Deletes the hook from storage (conceptually transitioning to `disposed` state). The token is released for reuse by future workflows. |
 

package/docs/how-it-works/framework-integrations.mdx

@@ -6,7 +6,7 @@ summary: Build a custom framework integration using the Workflow SDK compiler an
 prerequisites:
   - /docs/foundations/workflows-and-steps
 related:
-  - /docs/deploying/building-a-world
+  - /worlds/building-a-world
 ---
 
 <Callout>
@@ -425,7 +425,7 @@ For self-hosted or non-Vercel deployments, you are responsible for securing the
 - **Network-level security** — Deploy handlers behind a VPC, private network, or firewall rules so only your queue infrastructure can reach them
 - **Rate limiting** — Add request validation and rate limiting to prevent abuse
 
-Learn more about [building custom Worlds](/docs/deploying/building-a-world).
+Learn more about [building custom Worlds](/worlds/building-a-world).
 
 ## Testing Your Integration
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/core",
-  "version": "5.0.0-beta.35",
+  "version": "5.0.0-beta.36",
   "description": "Core runtime and engine for Workflow SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -98,12 +98,12 @@
     "semver": "7.7.4",
     "ulid": "~3.0.1",
     "zod": "~4.3.6",
-    "@workflow/errors": "5.0.0-beta.11",
+    "@workflow/errors": "5.0.0-beta.12",
     "@workflow/serde": "5.0.0-beta.2",
     "@workflow/utils": "5.0.0-beta.6",
-    "@workflow/world": "5.0.0-beta.21",
-    "@workflow/world-local": "5.0.0-beta.29",
-    "@workflow/world-vercel": "5.0.0-beta.31"
+    "@workflow/world": "5.0.0-beta.22",
+    "@workflow/world-local": "5.0.0-beta.30",
+    "@workflow/world-vercel": "5.0.0-beta.32"
   },
   "devDependencies": {
     "@opentelemetry/api": "1.9.0",

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"]}