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

package/dist/private.js

@@ -87,51 +87,172 @@ export function getStepFunction(stepId) {
     return undefined;
 }
 /**
- * Awaits, in strict event-log order, every still-registered delivery whose
- * index is earlier than `eventIndex` AND whose kind is in `deferBehindKinds`,
- * so that this resolution is handed to the workflow only after all relevant
- * earlier-in-log deliveries have been. This is what keeps a `Promise.race`
- * deterministic and aligned with the committed event log, independent of
- * microtask-hop counts, hydration time, or race-argument order.
+ * Which earlier kinds each delivery kind defers behind. Chosen so that no kind
+ * blocks on a peer it does not need to:
  *
- * `deferBehindKinds` is the opposite kind(s): a hook defers behind earlier
- * WAITS (not earlier hooks — those are sequential same-entity payloads), a
- * wait defers behind earlier HOOKS.
+ *  - a hook defers behind earlier WAITS and STEPS — not earlier hooks, which
+ *    are sequential same-entity payloads and must not block one another;
+ *  - a wait defers behind earlier HOOKS and STEPS — not earlier waits, since a
+ *    wait never needs to queue behind another wait;
+ *  - a step defers behind earlier WAITS, HOOKS and STEPS.
+ *
+ * The step-behind-step edge is not redundant with the serial `promiseQueue`.
+ * The queue fixes the order in which step results are HYDRATED, but a step no
+ * longer resolves inside its queue slot — it captures the outcome there and
+ * resolves from a detached continuation once its barrier clears. Two steps
+ * agree on that continuation's ordering only while they defer behind the same
+ * set, which holds when they are consumed in the same drain window but not
+ * across windows: a step consumed later can miss a wait/hook barrier that an
+ * earlier step is still parked on, because the barrier retired in between. The
+ * earlier step is then waiting out the macrotask yield below while the later
+ * one resolves on microtasks, and overtakes it — see
+ * `delivery-barrier-coverage.test.ts`. Deferring behind earlier steps
+ * closes that window structurally: the earlier step's barrier is still
+ * registered precisely because it has not delivered yet.
+ *
+ * Every edge points from a later log index to a strictly earlier one, so the
+ * wait-for graph can never contain a cycle.
+ */
+const DEFER_BEHIND = {
+    hook: ['wait', 'step'],
+    wait: ['hook', 'step'],
+    step: ['wait', 'hook', 'step'],
+};
+/**
+ * Whether `entry` will resolve on its own — it is armed, and every earlier
+ * delivery it defers behind will likewise resolve on its own.
+ *
+ * A step delivery is always self-resolving: it skips uncommitted deliveries
+ * (see {@link awaitEarlierDeliveries}), and the earlier steps it does defer
+ * behind are self-resolving by the same argument, inducting down on index.
+ *
+ * Recursion terminates because every edge points to a strictly smaller index.
+ * `memo` is required rather than an optimization: without it the walk is
+ * exponential in the number of live hook/wait barriers (each armed entry
+ * re-walks every earlier entry of the opposite kind, T(n) = Σ T(j)), and the
+ * registry is not small by construction — `EventsConsumer` drains
+ * consecutively consumable events synchronously while barriers only retire on
+ * microtask-driven deliveries, so a fan-out of `Promise.race([hook, sleep])`
+ * branches accumulates one barrier per branch per kind. Memoized, the walk is
+ * linear in registry size. The memo MUST be per-call: `armed` mutates between
+ * calls as buffered payloads are claimed.
  */
-export async function awaitEarlierDeliveries(ctx, eventIndex, deferBehindKinds) {
+function resolvesOnItsOwn(barriers, index, entry, memo) {
+    const cached = memo.get(index);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = computeResolvesOnItsOwn(barriers, index, entry, memo);
+    memo.set(index, result);
+    return result;
+}
+function computeResolvesOnItsOwn(barriers, index, entry, memo) {
+    if (!entry.armed) {
+        return false;
+    }
+    if (entry.kind === 'step') {
+        return true;
+    }
+    const deferBehind = DEFER_BEHIND[entry.kind];
+    for (const [otherIndex, other] of barriers) {
+        if (otherIndex < index &&
+            deferBehind.includes(other.kind) &&
+            !resolvesOnItsOwn(barriers, otherIndex, other, memo)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Awaits, in strict event-log order, every still-registered delivery that is
+ * earlier in the log than `eventIndex` and that a delivery of `kind` defers
+ * behind (see {@link DEFER_BEHIND}), so that this resolution is handed to the
+ * workflow only after all relevant earlier-in-log deliveries have been. This
+ * is what keeps a `Promise.race` — or the ULID a follow-up `useStep` draws on
+ * a concurrent branch — deterministic and aligned with the committed event
+ * log, independent of microtask-hop counts, hydration time, or race-argument
+ * order. When this delivery does have to wait, it also yields a macrotask
+ * afterwards so the earlier delivery's consumer can run to its own next
+ * suspension point first; see the comment at that `await` for why ordering the
+ * `resolve()` calls alone is not enough.
+ *
+ * One asymmetry: a STEP result additionally skips any earlier delivery that
+ * will not resolve on its own, i.e. one blocked (directly or transitively) on
+ * a buffered hook payload no consumer has claimed. Such a payload is delivered
+ * only when the workflow next reads the hook, and reaching that read very
+ * commonly requires the step result itself (`await stepX()` before the read).
+ * Gating the step on it would stall the workflow until the barrier's idle
+ * safety net fires, which then releases every delivery queued behind that
+ * payload at once — losing exactly the race this ordering exists to protect.
+ * Waits and hooks keep gating on unclaimed payloads: for them, waiting for the
+ * claim IS the ordering guarantee (a `wait_completed` must not preempt a
+ * payload the log ordered first).
+ */
+export async function awaitEarlierDeliveries(ctx, eventIndex, kind) {
     // Defensive: tolerate contexts that predate this field (test harnesses).
     if (eventIndex === undefined ||
         !ctx.pendingDeliveryBarriers ||
         ctx.pendingDeliveryBarriers.size === 0) {
         return;
     }
+    const barriers = ctx.pendingDeliveryBarriers;
+    const deferBehind = DEFER_BEHIND[kind];
     const earlier = [];
-    for (const [index, entry] of ctx.pendingDeliveryBarriers) {
-        if (index < eventIndex && deferBehindKinds.includes(entry.kind)) {
-            earlier.push(entry.delivered);
+    // Shared across this call only — see `resolvesOnItsOwn`.
+    const selfResolving = new Map();
+    for (const [index, entry] of barriers) {
+        if (index >= eventIndex || !deferBehind.includes(entry.kind)) {
+            continue;
+        }
+        if (kind === 'step' &&
+            !resolvesOnItsOwn(barriers, index, entry, selfResolving)) {
+            continue;
         }
+        earlier.push(entry.delivered);
     }
     if (earlier.length > 0) {
         await Promise.all(earlier);
+        // An earlier delivery being "delivered" only means its `resolve()` ran.
+        // The branch it woke may need an arbitrary number of further microtask
+        // hops before it reaches its next `useStep` call and draws a ULID — a
+        // `for await` over a hook, for instance, resumes the generator, settles
+        // the promise from `next()`, and only then runs the loop body. Resolving
+        // this delivery on a microtask would let it overtake that branch and
+        // reorder the ULID allocation anyway, turning the guarantee below into a
+        // hop-count race that holds only for the shortest consumers.
+        //
+        // Yielding a macrotask lets the earlier branch's entire microtask chain
+        // drain first, whatever its length, so log order survives regardless of
+        // how the workflow consumes the earlier delivery. Only deliveries that
+        // actually had to defer pay this, so the common single-delivery drain is
+        // unaffected.
+        await new Promise((resolve) => setTimeout(resolve, 0));
     }
 }
 /**
  * Register a branch-deciding delivery at its event-log index so that later
- * opposite-kind deliveries can be ordered strictly after it. Returns an inert
- * handle when `pendingDeliveryBarriers` is not initialized.
+ * deliveries can be ordered strictly after it. Returns an inert handle when
+ * `pendingDeliveryBarriers` is not initialized.
+ *
+ * Pass `armed: false` for a delivery whose resolution waits on workflow code
+ * asking for it (a buffered hook payload); call `arm()` when it does.
  *
  * To guarantee a later delivery gated on this one can never hang when this
  * delivery is abandoned (the workflow took a different branch or is
  * suspending and never observes it), the barrier auto-resolves at idle.
  */
-export function registerDeliveryBarrier(ctx, eventIndex, kind) {
+export function registerDeliveryBarrier(ctx, eventIndex, kind, options = {}) {
     const barriers = ctx.pendingDeliveryBarriers;
     if (!barriers || eventIndex === undefined) {
-        return { markDelivered: () => { } };
+        return { markDelivered: () => { }, arm: () => { } };
     }
     let done = false;
     const { promise, resolve } = withResolvers();
-    const entry = { kind, delivered: promise };
+    const entry = {
+        kind,
+        delivered: promise,
+        armed: options.armed ?? true,
+    };
     barriers.set(eventIndex, entry);
     const finish = () => {
         if (done) {
@@ -144,11 +265,17 @@ export function registerDeliveryBarrier(ctx, eventIndex, kind) {
         resolve();
     };
     // Safety net: if this delivery is never delivered to the workflow (its
-    // branch was not taken / the run is suspending), resolve at idle so a
-    // later opposite-kind delivery gated on it cannot deadlock and the
+    // branch was not taken / the run is suspending, or a buffered hook payload
+    // is only claimed after a later delivery the workflow is still waiting on),
+    // resolve at idle so a later delivery gated on it cannot deadlock and the
     // registry cannot leak an entry per abandoned delivery.
     scheduleWhenIdle(ctx, finish);
-    return { markDelivered: finish };
+    return {
+        markDelivered: finish,
+        arm: () => {
+            entry.armed = true;
+        },
+    };
 }
 /**
  * Schedule a callback to fire only after all pending data deliveries
@@ -184,4 +311,4 @@ export function scheduleWhenIdle(ctx, fn) {
     };
     setTimeout(check, 0);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"private.js","sourceRoot":"","sources":["../src/private.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Utils used by the bundler when transforming code\n */\n\nimport { withResolvers } from '@workflow/utils';\nimport type { WorldCapabilities } from '@workflow/world';\nimport type { CryptoKey } from './encryption.js';\nimport type { EventsConsumer } from './events-consumer.js';\nimport type { QueueItem } from './global.js';\nimport type { ReplayPayloadCache } from './replay-payload-cache.js';\nimport type { Serializable } from './schemas.js';\n\nexport type StepFunction<\n  Args extends Serializable[] = any[],\n  Result extends Serializable | unknown = unknown,\n> = ((...args: Args) => Promise<Result>) & {\n  maxRetries?: number;\n  stepId?: string;\n};\n\nconst RegisteredStepsKey = Symbol.for('@workflow/core//registeredSteps');\n\nconst globalSymbols: typeof globalThis & {\n  [RegisteredStepsKey]?: Map<string, StepFunction>;\n} = globalThis;\n\n// biome-ignore lint/suspicious/noAssignInExpressions: /\nconst registeredSteps = (globalSymbols[RegisteredStepsKey] ??= new Map<\n  string,\n  StepFunction\n>());\n\nconst BUILTIN_RESPONSE_STEP_NAMES = new Set([\n  '__builtin_response_array_buffer',\n  '__builtin_response_json',\n  '__builtin_response_text',\n]);\n\nfunction getStepIdAliasCandidates(stepId: string): string[] {\n  const parts = stepId.split('//');\n  if (parts.length !== 3 || parts[0] !== 'step') {\n    return [];\n  }\n\n  const modulePath = parts[1];\n  const fnName = parts[2];\n  const modulePathAliases = new Set<string>();\n\n  const addAlias = (aliasModulePath: string) => {\n    if (aliasModulePath !== modulePath) {\n      modulePathAliases.add(aliasModulePath);\n    }\n  };\n\n  if (modulePath.startsWith('./workflows/')) {\n    const workflowRelativePath = modulePath.slice('./'.length);\n    addAlias(`./example/${workflowRelativePath}`);\n    addAlias(`./src/${workflowRelativePath}`);\n  } else if (modulePath.startsWith('./example/workflows/')) {\n    const workflowRelativePath = modulePath.slice('./example/'.length);\n    addAlias(`./${workflowRelativePath}`);\n    addAlias(`./src/${workflowRelativePath}`);\n  } else if (modulePath.startsWith('./src/workflows/')) {\n    const workflowRelativePath = modulePath.slice('./src/'.length);\n    addAlias(`./${workflowRelativePath}`);\n    addAlias(`./example/${workflowRelativePath}`);\n  }\n\n  return Array.from(\n    modulePathAliases,\n    (aliasModulePath) => `step//${aliasModulePath}//${fnName}`\n  );\n}\n\nfunction getBuiltinResponseStepAlias(stepId: string): StepFunction | undefined {\n  if (!BUILTIN_RESPONSE_STEP_NAMES.has(stepId)) {\n    return undefined;\n  }\n\n  for (const [registeredStepId, stepFn] of registeredSteps.entries()) {\n    if (registeredStepId.endsWith(`//${stepId}`)) {\n      return stepFn;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Register a step function to be served in the server bundle.\n * Also sets the stepId property on the function for serialization support.\n *\n * Note: The SWC compiler plugin no longer generates calls to this function.\n * Step registration is now inlined as a self-contained IIFE that writes\n * directly to the global Map at Symbol.for(\"@workflow/core//registeredSteps\").\n * This function is kept for internal/test use only.\n */\nexport function registerStepFunction(stepId: string, stepFn: StepFunction) {\n  registeredSteps.set(stepId, stepFn);\n  stepFn.stepId = stepId;\n}\n\n/**\n * Find a registered step function by name\n */\nexport function getStepFunction(stepId: string): StepFunction | undefined {\n  const directMatch = registeredSteps.get(stepId);\n  if (directMatch) {\n    return directMatch;\n  }\n\n  // Support equivalent workflow path aliases in mixed symlink environments.\n  for (const aliasStepId of getStepIdAliasCandidates(stepId)) {\n    const aliasMatch = registeredSteps.get(aliasStepId);\n    if (aliasMatch) {\n      return aliasMatch;\n    }\n  }\n\n  const builtinAliasMatch = getBuiltinResponseStepAlias(stepId);\n  if (builtinAliasMatch) {\n    return builtinAliasMatch;\n  }\n\n  return undefined;\n}\n\n// Note: __private_getClosureVars is no longer re-exported here.\n// The SWC compiler plugin now inlines closure variable access as a\n// self-contained IIFE that reads directly from the global AsyncLocalStorage\n// at Symbol.for(\"WORKFLOW_STEP_CONTEXT_STORAGE\").\n\nexport interface WorkflowOrchestratorContext {\n  runId: string;\n  encryptionKey: CryptoKey | undefined;\n  worldCapabilities?: WorldCapabilities;\n  globalThis: typeof globalThis;\n  eventsConsumer: EventsConsumer;\n  /**\n   * Map of pending invocations keyed by correlationId.\n   * Using Map instead of Array for O(1) lookup/delete operations.\n   */\n  invocationsQueue: Map<string, QueueItem>;\n  onWorkflowError: (error: Error) => void;\n  generateUlid: () => string;\n  generateNanoid: () => string;\n  /**\n   * Sequential promise queue that ensures all event-driven promise resolutions\n   * (step results, hook payloads, failures, suspensions) happen in event log\n   * order. Every resolve, reject, or workflow error is chained through this\n   * queue so that even if individual operations take variable time (e.g.,\n   * async decryption), promises resolve deterministically.\n   */\n  promiseQueue: Promise<void>;\n  /**\n   * Counter of in-flight async data delivery operations (step result\n   * hydration, hook payload hydration, abort signal hydration). Suspensions\n   * must wait for this to reach 0 before firing, to avoid preempting data\n   * delivery — e.g. dehydrating a step's arguments while an abort that should\n   * be reflected in those arguments is still hydrating its reason.\n   */\n  pendingDeliveries: number;\n  /**\n   * Ordered registry of in-flight \"branch-deciding\" deliveries — the\n   * resolutions a workflow typically `Promise.race`s on: buffered hook\n   * payloads (`hook_received`) and wait completions (`wait_completed`).\n   * Keyed by the delivery's position (index) in the consumed event log.\n   *\n   * The problem: a buffered hook payload is observed via the async hook\n   * iterator (`yield await this`), costing extra microtask hops, while a\n   * `wait_completed` resolves with fewer hops — and a reused sleep can\n   * resolve in an entirely earlier loop iteration. Either way, the\n   * resolution that the committed event log ordered first can lose a\n   * `Promise.race` to a faster- or already-resolved competitor, diverging\n   * from the log and surfacing as `CorruptedEventLogError`.\n   *\n   * The fix is a strict, deterministic delivery order anchored on\n   * event-log position: a delivery does not resolve to the workflow until\n   * every earlier-in-log delivery of the OPPOSITE kind has been delivered.\n   * (Opposite kind only: sequential same-kind hook payloads must not block\n   * one another, and a wait need not wait behind a later wait.) Because the\n   * gate is \"the earlier delivery resolved\", not \"won a timing race\", the\n   * outcome is independent of microtask hops, hydration/decryption time,\n   * and `Promise.race` argument order.\n   *\n   * Index is used rather than the `eventId` string because `eventId` is an\n   * opaque, world-assigned value not guaranteed to sort in creation order\n   * (only the bundled ULID worlds happen to).\n   *\n   * Optional so older/out-of-tree contexts (and lightweight test harnesses)\n   * that do not initialize it degrade gracefully to the previous behavior.\n   */\n  pendingDeliveryBarriers?: Map<number, DeliveryBarrierEntry>;\n  /**\n   * Invocation-scoped cache of prepared serialized payloads and immutable final\n   * values. Prepared bytes survive fresh replay VMs; object graphs do not.\n   */\n  replayPayloadCache: ReplayPayloadCache;\n}\n\n/** The kind of branch-deciding delivery a barrier represents. */\nexport type DeliveryKind = 'hook' | 'wait';\n\ninterface DeliveryBarrierEntry {\n  kind: DeliveryKind;\n  /** Resolves once this delivery has resolved to the workflow. */\n  delivered: Promise<void>;\n}\n\n/**\n * Awaits, in strict event-log order, every still-registered delivery whose\n * index is earlier than `eventIndex` AND whose kind is in `deferBehindKinds`,\n * so that this resolution is handed to the workflow only after all relevant\n * earlier-in-log deliveries have been. This is what keeps a `Promise.race`\n * deterministic and aligned with the committed event log, independent of\n * microtask-hop counts, hydration time, or race-argument order.\n *\n * `deferBehindKinds` is the opposite kind(s): a hook defers behind earlier\n * WAITS (not earlier hooks — those are sequential same-entity payloads), a\n * wait defers behind earlier HOOKS.\n */\nexport async function awaitEarlierDeliveries(\n  ctx: WorkflowOrchestratorContext,\n  eventIndex: number | undefined,\n  deferBehindKinds: readonly DeliveryKind[]\n): Promise<void> {\n  // Defensive: tolerate contexts that predate this field (test harnesses).\n  if (\n    eventIndex === undefined ||\n    !ctx.pendingDeliveryBarriers ||\n    ctx.pendingDeliveryBarriers.size === 0\n  ) {\n    return;\n  }\n  const earlier: Promise<void>[] = [];\n  for (const [index, entry] of ctx.pendingDeliveryBarriers) {\n    if (index < eventIndex && deferBehindKinds.includes(entry.kind)) {\n      earlier.push(entry.delivered);\n    }\n  }\n  if (earlier.length > 0) {\n    await Promise.all(earlier);\n  }\n}\n\n/** Handle for a registered branch-deciding delivery barrier. */\nexport interface DeliveryBarrier {\n  /**\n   * Mark this delivery as delivered to the workflow. Resolves its\n   * `delivered` promise so any later-in-log opposite-kind delivery gated on\n   * it (via {@link awaitEarlierDeliveries}) may proceed, and removes it from\n   * the registry. Idempotent.\n   */\n  markDelivered: () => void;\n}\n\n/**\n * Register a branch-deciding delivery at its event-log index so that later\n * opposite-kind deliveries can be ordered strictly after it. Returns an inert\n * handle when `pendingDeliveryBarriers` is not initialized.\n *\n * To guarantee a later delivery gated on this one can never hang when this\n * delivery is abandoned (the workflow took a different branch or is\n * suspending and never observes it), the barrier auto-resolves at idle.\n */\nexport function registerDeliveryBarrier(\n  ctx: WorkflowOrchestratorContext,\n  eventIndex: number | undefined,\n  kind: DeliveryKind\n): DeliveryBarrier {\n  const barriers = ctx.pendingDeliveryBarriers;\n  if (!barriers || eventIndex === undefined) {\n    return { markDelivered: () => {} };\n  }\n\n  let done = false;\n  const { promise, resolve } = withResolvers<void>();\n  const entry: DeliveryBarrierEntry = { kind, delivered: promise };\n  barriers.set(eventIndex, entry);\n\n  const finish = () => {\n    if (done) {\n      return;\n    }\n    done = true;\n    if (barriers.get(eventIndex) === entry) {\n      barriers.delete(eventIndex);\n    }\n    resolve();\n  };\n\n  // Safety net: if this delivery is never delivered to the workflow (its\n  // branch was not taken / the run is suspending), resolve at idle so a\n  // later opposite-kind delivery gated on it cannot deadlock and the\n  // registry cannot leak an entry per abandoned delivery.\n  scheduleWhenIdle(ctx, finish);\n\n  return { markDelivered: finish };\n}\n\n/**\n * Schedule a callback to fire only after all pending data deliveries\n * (step results, hook payloads) and async deserialization have completed.\n * Uses a polling loop: setTimeout(0) → check pendingDeliveries →\n * if > 0, wait for promiseQueue → repeat. This handles the multi-round\n * delivery pattern where each hook payload delivery cycle appends new\n * async work to the promiseQueue.\n *\n * The initial `setTimeout(0)` macrotask is load-bearing and must NOT be\n * downgraded to a microtask (`queueMicrotask`/`Promise.resolve().then`).\n * `pendingDeliveries` only guards the host-side hydration window; between a\n * delivery's `resolve()` and the workflow VM body running its continuation to\n * register the next subscriber, `pendingDeliveries` is already 0 even though\n * the VM is mid-reaction. Node does not guarantee a microtask scheduled in\n * the host context settles after the cross-VM promise chain (resolve in host\n * → workflow code in VM → subscribe back in host); the macrotask boundary\n * gives that chain time to run, so the suspension does not preempt a sibling\n * delivery still in flight. Empirically, replacing it with `queueMicrotask`\n * breaks hook/sleep `Promise.race` ordering (CorruptedEventLogError).\n */\nexport function scheduleWhenIdle(\n  ctx: WorkflowOrchestratorContext,\n  fn: () => void\n): void {\n  const check = () => {\n    if (ctx.pendingDeliveries > 0) {\n      // Still delivering data — wait for queue to drain, then re-check\n      ctx.promiseQueue.then(() => {\n        setTimeout(check, 0);\n      });\n    } else {\n      fn();\n    }\n  };\n  setTimeout(check, 0);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"private.js","sourceRoot":"","sources":["../src/private.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Utils used by the bundler when transforming code\n */\n\nimport { withResolvers } from '@workflow/utils';\nimport type { WorldCapabilities } from '@workflow/world';\nimport type { PayloadKey } from './serialization/encryption.js';\nimport type { EventsConsumer } from './events-consumer.js';\nimport type { QueueItem } from './global.js';\nimport type { ReplayPayloadCache } from './replay-payload-cache.js';\nimport type { Serializable } from './schemas.js';\n\nexport type StepFunction<\n  Args extends Serializable[] = any[],\n  Result extends Serializable | unknown = unknown,\n> = ((...args: Args) => Promise<Result>) & {\n  maxRetries?: number;\n  stepId?: string;\n};\n\nconst RegisteredStepsKey = Symbol.for('@workflow/core//registeredSteps');\n\nconst globalSymbols: typeof globalThis & {\n  [RegisteredStepsKey]?: Map<string, StepFunction>;\n} = globalThis;\n\n// biome-ignore lint/suspicious/noAssignInExpressions: /\nconst registeredSteps = (globalSymbols[RegisteredStepsKey] ??= new Map<\n  string,\n  StepFunction\n>());\n\nconst BUILTIN_RESPONSE_STEP_NAMES = new Set([\n  '__builtin_response_array_buffer',\n  '__builtin_response_json',\n  '__builtin_response_text',\n]);\n\nfunction getStepIdAliasCandidates(stepId: string): string[] {\n  const parts = stepId.split('//');\n  if (parts.length !== 3 || parts[0] !== 'step') {\n    return [];\n  }\n\n  const modulePath = parts[1];\n  const fnName = parts[2];\n  const modulePathAliases = new Set<string>();\n\n  const addAlias = (aliasModulePath: string) => {\n    if (aliasModulePath !== modulePath) {\n      modulePathAliases.add(aliasModulePath);\n    }\n  };\n\n  if (modulePath.startsWith('./workflows/')) {\n    const workflowRelativePath = modulePath.slice('./'.length);\n    addAlias(`./example/${workflowRelativePath}`);\n    addAlias(`./src/${workflowRelativePath}`);\n  } else if (modulePath.startsWith('./example/workflows/')) {\n    const workflowRelativePath = modulePath.slice('./example/'.length);\n    addAlias(`./${workflowRelativePath}`);\n    addAlias(`./src/${workflowRelativePath}`);\n  } else if (modulePath.startsWith('./src/workflows/')) {\n    const workflowRelativePath = modulePath.slice('./src/'.length);\n    addAlias(`./${workflowRelativePath}`);\n    addAlias(`./example/${workflowRelativePath}`);\n  }\n\n  return Array.from(\n    modulePathAliases,\n    (aliasModulePath) => `step//${aliasModulePath}//${fnName}`\n  );\n}\n\nfunction getBuiltinResponseStepAlias(stepId: string): StepFunction | undefined {\n  if (!BUILTIN_RESPONSE_STEP_NAMES.has(stepId)) {\n    return undefined;\n  }\n\n  for (const [registeredStepId, stepFn] of registeredSteps.entries()) {\n    if (registeredStepId.endsWith(`//${stepId}`)) {\n      return stepFn;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Register a step function to be served in the server bundle.\n * Also sets the stepId property on the function for serialization support.\n *\n * Note: The SWC compiler plugin no longer generates calls to this function.\n * Step registration is now inlined as a self-contained IIFE that writes\n * directly to the global Map at Symbol.for(\"@workflow/core//registeredSteps\").\n * This function is kept for internal/test use only.\n */\nexport function registerStepFunction(stepId: string, stepFn: StepFunction) {\n  registeredSteps.set(stepId, stepFn);\n  stepFn.stepId = stepId;\n}\n\n/**\n * Find a registered step function by name\n */\nexport function getStepFunction(stepId: string): StepFunction | undefined {\n  const directMatch = registeredSteps.get(stepId);\n  if (directMatch) {\n    return directMatch;\n  }\n\n  // Support equivalent workflow path aliases in mixed symlink environments.\n  for (const aliasStepId of getStepIdAliasCandidates(stepId)) {\n    const aliasMatch = registeredSteps.get(aliasStepId);\n    if (aliasMatch) {\n      return aliasMatch;\n    }\n  }\n\n  const builtinAliasMatch = getBuiltinResponseStepAlias(stepId);\n  if (builtinAliasMatch) {\n    return builtinAliasMatch;\n  }\n\n  return undefined;\n}\n\n// Note: __private_getClosureVars is no longer re-exported here.\n// The SWC compiler plugin now inlines closure variable access as a\n// self-contained IIFE that reads directly from the global AsyncLocalStorage\n// at Symbol.for(\"WORKFLOW_STEP_CONTEXT_STORAGE\").\n\nexport interface WorkflowOrchestratorContext {\n  runId: string;\n  encryptionKey: PayloadKey | undefined;\n  worldCapabilities?: WorldCapabilities;\n  globalThis: typeof globalThis;\n  eventsConsumer: EventsConsumer;\n  /**\n   * Map of pending invocations keyed by correlationId.\n   * Using Map instead of Array for O(1) lookup/delete operations.\n   */\n  invocationsQueue: Map<string, QueueItem>;\n  onWorkflowError: (error: Error) => void;\n  generateUlid: () => string;\n  generateNanoid: () => string;\n  /**\n   * Sequential promise queue that ensures all event-driven promise resolutions\n   * (step results, hook payloads, failures, suspensions) happen in event log\n   * order. Every resolve, reject, or workflow error is chained through this\n   * queue so that even if individual operations take variable time (e.g.,\n   * async decryption), promises resolve deterministically.\n   */\n  promiseQueue: Promise<void>;\n  /**\n   * Counter of in-flight async data delivery operations (step result\n   * hydration, hook payload hydration, abort signal hydration). Suspensions\n   * must wait for this to reach 0 before firing, to avoid preempting data\n   * delivery — e.g. dehydrating a step's arguments while an abort that should\n   * be reflected in those arguments is still hydrating its reason.\n   */\n  pendingDeliveries: number;\n  /**\n   * Ordered registry of in-flight \"branch-deciding\" deliveries — the\n   * resolutions a workflow typically `Promise.race`s on, or awaits from\n   * independent concurrent branches: hook payloads (`hook_received`), wait\n   * completions (`wait_completed`), and step results (`step_completed` /\n   * `step_failed`). Keyed by the delivery's position (index) in the consumed\n   * event log.\n   *\n   * The problem: each of these resolutions reaches workflow code after a\n   * different, workload-dependent number of microtask hops. A buffered hook\n   * payload is observed via the async hook iterator (`yield await this`),\n   * costing extra hops; a `wait_completed` resolves with fewer, and a reused\n   * sleep can resolve in an entirely earlier loop iteration; a step result is\n   * gated on hydration whose cost varies between replays of the SAME\n   * invocation — the first replay pays the full decrypt/decompress/revive,\n   * while later replays sharing the invocation's `ReplayPayloadCache`\n   * memo-hit small primitive results and resolve in one or two hops. Either\n   * way, the resolution that the committed event log ordered first can lose a\n   * `Promise.race` (or a `useStep` ULID allocation) to a faster- or\n   * already-resolved competitor, diverging from the log and surfacing as\n   * `CorruptedEventLogError`.\n   *\n   * The fix is a strict, deterministic delivery order anchored on\n   * event-log position: a delivery does not resolve to the workflow until\n   * every relevant earlier-in-log delivery has been delivered. Because the\n   * gate is \"the earlier delivery resolved\", not \"won a timing race\", the\n   * outcome is independent of microtask hops, hydration/decryption time,\n   * and `Promise.race` argument order. Which earlier kinds a delivery defers\n   * behind is spelled out on {@link awaitEarlierDeliveries}.\n   *\n   * Index is used rather than the `eventId` string because `eventId` is an\n   * opaque, world-assigned value not guaranteed to sort in creation order\n   * (only the bundled ULID worlds happen to).\n   *\n   * Optional so older/out-of-tree contexts (and lightweight test harnesses)\n   * that do not initialize it degrade gracefully to the previous behavior.\n   */\n  pendingDeliveryBarriers?: Map<number, DeliveryBarrierEntry>;\n  /**\n   * Invocation-scoped cache of prepared serialized payloads and immutable final\n   * values. Prepared bytes survive fresh replay VMs; object graphs do not.\n   */\n  replayPayloadCache: ReplayPayloadCache;\n}\n\n/** The kind of branch-deciding delivery a barrier represents. */\nexport type DeliveryKind = 'hook' | 'wait' | 'step';\n\ninterface DeliveryBarrierEntry {\n  kind: DeliveryKind;\n  /** Resolves once this delivery has resolved to the workflow. */\n  delivered: Promise<void>;\n  /**\n   * Whether this delivery is committed to reaching the workflow without any\n   * further action by workflow code. True for wait completions and step\n   * results, which always resolve from their own chain, and for a hook payload\n   * that already had a waiting consumer when it was consumed.\n   *\n   * False for a BUFFERED hook payload no consumer has claimed yet: it is\n   * delivered by `claim()`, i.e. whenever the workflow next reads the hook —\n   * which may be causally *after* a later-in-log delivery. `arm()` flips it\n   * once a consumer takes the payload.\n   */\n  armed: boolean;\n}\n\n/**\n * Which earlier kinds each delivery kind defers behind. Chosen so that no kind\n * blocks on a peer it does not need to:\n *\n *  - a hook defers behind earlier WAITS and STEPS — not earlier hooks, which\n *    are sequential same-entity payloads and must not block one another;\n *  - a wait defers behind earlier HOOKS and STEPS — not earlier waits, since a\n *    wait never needs to queue behind another wait;\n *  - a step defers behind earlier WAITS, HOOKS and STEPS.\n *\n * The step-behind-step edge is not redundant with the serial `promiseQueue`.\n * The queue fixes the order in which step results are HYDRATED, but a step no\n * longer resolves inside its queue slot — it captures the outcome there and\n * resolves from a detached continuation once its barrier clears. Two steps\n * agree on that continuation's ordering only while they defer behind the same\n * set, which holds when they are consumed in the same drain window but not\n * across windows: a step consumed later can miss a wait/hook barrier that an\n * earlier step is still parked on, because the barrier retired in between. The\n * earlier step is then waiting out the macrotask yield below while the later\n * one resolves on microtasks, and overtakes it — see\n * `delivery-barrier-coverage.test.ts`. Deferring behind earlier steps\n * closes that window structurally: the earlier step's barrier is still\n * registered precisely because it has not delivered yet.\n *\n * Every edge points from a later log index to a strictly earlier one, so the\n * wait-for graph can never contain a cycle.\n */\nconst DEFER_BEHIND: Record<DeliveryKind, readonly DeliveryKind[]> = {\n  hook: ['wait', 'step'],\n  wait: ['hook', 'step'],\n  step: ['wait', 'hook', 'step'],\n};\n\n/**\n * Whether `entry` will resolve on its own — it is armed, and every earlier\n * delivery it defers behind will likewise resolve on its own.\n *\n * A step delivery is always self-resolving: it skips uncommitted deliveries\n * (see {@link awaitEarlierDeliveries}), and the earlier steps it does defer\n * behind are self-resolving by the same argument, inducting down on index.\n *\n * Recursion terminates because every edge points to a strictly smaller index.\n * `memo` is required rather than an optimization: without it the walk is\n * exponential in the number of live hook/wait barriers (each armed entry\n * re-walks every earlier entry of the opposite kind, T(n) = Σ T(j)), and the\n * registry is not small by construction — `EventsConsumer` drains\n * consecutively consumable events synchronously while barriers only retire on\n * microtask-driven deliveries, so a fan-out of `Promise.race([hook, sleep])`\n * branches accumulates one barrier per branch per kind. Memoized, the walk is\n * linear in registry size. The memo MUST be per-call: `armed` mutates between\n * calls as buffered payloads are claimed.\n */\nfunction resolvesOnItsOwn(\n  barriers: Map<number, DeliveryBarrierEntry>,\n  index: number,\n  entry: DeliveryBarrierEntry,\n  memo: Map<number, boolean>\n): boolean {\n  const cached = memo.get(index);\n  if (cached !== undefined) {\n    return cached;\n  }\n  const result = computeResolvesOnItsOwn(barriers, index, entry, memo);\n  memo.set(index, result);\n  return result;\n}\n\nfunction computeResolvesOnItsOwn(\n  barriers: Map<number, DeliveryBarrierEntry>,\n  index: number,\n  entry: DeliveryBarrierEntry,\n  memo: Map<number, boolean>\n): boolean {\n  if (!entry.armed) {\n    return false;\n  }\n  if (entry.kind === 'step') {\n    return true;\n  }\n  const deferBehind = DEFER_BEHIND[entry.kind];\n  for (const [otherIndex, other] of barriers) {\n    if (\n      otherIndex < index &&\n      deferBehind.includes(other.kind) &&\n      !resolvesOnItsOwn(barriers, otherIndex, other, memo)\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Awaits, in strict event-log order, every still-registered delivery that is\n * earlier in the log than `eventIndex` and that a delivery of `kind` defers\n * behind (see {@link DEFER_BEHIND}), so that this resolution is handed to the\n * workflow only after all relevant earlier-in-log deliveries have been. This\n * is what keeps a `Promise.race` — or the ULID a follow-up `useStep` draws on\n * a concurrent branch — deterministic and aligned with the committed event\n * log, independent of microtask-hop counts, hydration time, or race-argument\n * order. When this delivery does have to wait, it also yields a macrotask\n * afterwards so the earlier delivery's consumer can run to its own next\n * suspension point first; see the comment at that `await` for why ordering the\n * `resolve()` calls alone is not enough.\n *\n * One asymmetry: a STEP result additionally skips any earlier delivery that\n * will not resolve on its own, i.e. one blocked (directly or transitively) on\n * a buffered hook payload no consumer has claimed. Such a payload is delivered\n * only when the workflow next reads the hook, and reaching that read very\n * commonly requires the step result itself (`await stepX()` before the read).\n * Gating the step on it would stall the workflow until the barrier's idle\n * safety net fires, which then releases every delivery queued behind that\n * payload at once — losing exactly the race this ordering exists to protect.\n * Waits and hooks keep gating on unclaimed payloads: for them, waiting for the\n * claim IS the ordering guarantee (a `wait_completed` must not preempt a\n * payload the log ordered first).\n */\nexport async function awaitEarlierDeliveries(\n  ctx: WorkflowOrchestratorContext,\n  eventIndex: number | undefined,\n  kind: DeliveryKind\n): Promise<void> {\n  // Defensive: tolerate contexts that predate this field (test harnesses).\n  if (\n    eventIndex === undefined ||\n    !ctx.pendingDeliveryBarriers ||\n    ctx.pendingDeliveryBarriers.size === 0\n  ) {\n    return;\n  }\n  const barriers = ctx.pendingDeliveryBarriers;\n  const deferBehind = DEFER_BEHIND[kind];\n  const earlier: Promise<void>[] = [];\n  // Shared across this call only — see `resolvesOnItsOwn`.\n  const selfResolving = new Map<number, boolean>();\n  for (const [index, entry] of barriers) {\n    if (index >= eventIndex || !deferBehind.includes(entry.kind)) {\n      continue;\n    }\n    if (\n      kind === 'step' &&\n      !resolvesOnItsOwn(barriers, index, entry, selfResolving)\n    ) {\n      continue;\n    }\n    earlier.push(entry.delivered);\n  }\n  if (earlier.length > 0) {\n    await Promise.all(earlier);\n    // An earlier delivery being \"delivered\" only means its `resolve()` ran.\n    // The branch it woke may need an arbitrary number of further microtask\n    // hops before it reaches its next `useStep` call and draws a ULID — a\n    // `for await` over a hook, for instance, resumes the generator, settles\n    // the promise from `next()`, and only then runs the loop body. Resolving\n    // this delivery on a microtask would let it overtake that branch and\n    // reorder the ULID allocation anyway, turning the guarantee below into a\n    // hop-count race that holds only for the shortest consumers.\n    //\n    // Yielding a macrotask lets the earlier branch's entire microtask chain\n    // drain first, whatever its length, so log order survives regardless of\n    // how the workflow consumes the earlier delivery. Only deliveries that\n    // actually had to defer pay this, so the common single-delivery drain is\n    // unaffected.\n    await new Promise<void>((resolve) => setTimeout(resolve, 0));\n  }\n}\n\n/** Handle for a registered branch-deciding delivery barrier. */\nexport interface DeliveryBarrier {\n  /**\n   * Mark this delivery as delivered to the workflow. Resolves its\n   * `delivered` promise so any later-in-log delivery gated on it (via\n   * {@link awaitEarlierDeliveries}) may proceed, and removes it from the\n   * registry. Idempotent.\n   */\n  markDelivered: () => void;\n  /**\n   * Mark this delivery as committed to happening, for a barrier registered\n   * unarmed (a buffered hook payload) once a consumer has claimed it. From\n   * then on a later step result may be ordered behind it. Idempotent.\n   */\n  arm: () => void;\n}\n\n/**\n * Register a branch-deciding delivery at its event-log index so that later\n * deliveries can be ordered strictly after it. Returns an inert handle when\n * `pendingDeliveryBarriers` is not initialized.\n *\n * Pass `armed: false` for a delivery whose resolution waits on workflow code\n * asking for it (a buffered hook payload); call `arm()` when it does.\n *\n * To guarantee a later delivery gated on this one can never hang when this\n * delivery is abandoned (the workflow took a different branch or is\n * suspending and never observes it), the barrier auto-resolves at idle.\n */\nexport function registerDeliveryBarrier(\n  ctx: WorkflowOrchestratorContext,\n  eventIndex: number | undefined,\n  kind: DeliveryKind,\n  options: { armed?: boolean } = {}\n): DeliveryBarrier {\n  const barriers = ctx.pendingDeliveryBarriers;\n  if (!barriers || eventIndex === undefined) {\n    return { markDelivered: () => {}, arm: () => {} };\n  }\n\n  let done = false;\n  const { promise, resolve } = withResolvers<void>();\n  const entry: DeliveryBarrierEntry = {\n    kind,\n    delivered: promise,\n    armed: options.armed ?? true,\n  };\n  barriers.set(eventIndex, entry);\n\n  const finish = () => {\n    if (done) {\n      return;\n    }\n    done = true;\n    if (barriers.get(eventIndex) === entry) {\n      barriers.delete(eventIndex);\n    }\n    resolve();\n  };\n\n  // Safety net: if this delivery is never delivered to the workflow (its\n  // branch was not taken / the run is suspending, or a buffered hook payload\n  // is only claimed after a later delivery the workflow is still waiting on),\n  // resolve at idle so a later delivery gated on it cannot deadlock and the\n  // registry cannot leak an entry per abandoned delivery.\n  scheduleWhenIdle(ctx, finish);\n\n  return {\n    markDelivered: finish,\n    arm: () => {\n      entry.armed = true;\n    },\n  };\n}\n\n/**\n * Schedule a callback to fire only after all pending data deliveries\n * (step results, hook payloads) and async deserialization have completed.\n * Uses a polling loop: setTimeout(0) → check pendingDeliveries →\n * if > 0, wait for promiseQueue → repeat. This handles the multi-round\n * delivery pattern where each hook payload delivery cycle appends new\n * async work to the promiseQueue.\n *\n * The initial `setTimeout(0)` macrotask is load-bearing and must NOT be\n * downgraded to a microtask (`queueMicrotask`/`Promise.resolve().then`).\n * `pendingDeliveries` only guards the host-side hydration window; between a\n * delivery's `resolve()` and the workflow VM body running its continuation to\n * register the next subscriber, `pendingDeliveries` is already 0 even though\n * the VM is mid-reaction. Node does not guarantee a microtask scheduled in\n * the host context settles after the cross-VM promise chain (resolve in host\n * → workflow code in VM → subscribe back in host); the macrotask boundary\n * gives that chain time to run, so the suspension does not preempt a sibling\n * delivery still in flight. Empirically, replacing it with `queueMicrotask`\n * breaks hook/sleep `Promise.race` ordering (CorruptedEventLogError).\n */\nexport function scheduleWhenIdle(\n  ctx: WorkflowOrchestratorContext,\n  fn: () => void\n): void {\n  const check = () => {\n    if (ctx.pendingDeliveries > 0) {\n      // Still delivering data — wait for queue to drain, then re-check\n      ctx.promiseQueue.then(() => {\n        setTimeout(check, 0);\n      });\n    } else {\n      fn();\n    }\n  };\n  setTimeout(check, 0);\n}\n"]}

package/dist/replay-payload-cache.d.ts

@@ -1,5 +1,5 @@
 import type { Event, WorkflowRun } from '@workflow/world';
-import type { CryptoKey } from './encryption.js';
+import type { PayloadKey } from './serialization/encryption.js';
 import { type PreparedReplayPayload, type ReplayPayloadPreparer } from './serialization.js';
 type ReplayPayloadField = 'result' | 'error' | 'payload';
 /**
@@ -19,7 +19,8 @@ export declare class ReplayPayloadCache {
     private readonly preparer;
     private readonly preparedPayloads;
     private readonly primitiveStepResults;
-    constructor(encryptionKey: CryptoKey | undefined, preparer?: ReplayPayloadPreparer);
+    private nextUnscannedEventIndex;
+    constructor(encryptionKey: PayloadKey | undefined, preparer?: ReplayPayloadPreparer);
     /**
      * Start every missing binary preparation before workflow execution. Failures
      * are intentionally retained: the ordered event consumer must observe the

package/dist/replay-payload-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replay-payload-cache.d.ts","sourceRoot":"","sources":["../src/replay-payload-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EACL,KAAK,qBAAqB,EAE1B,KAAK,qBAAqB,EAC3B,MAAM,oBAAoB,CAAC;AAG5B,KAAK,kBAAkB,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;AAezD;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAkB;IAQ3B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAR3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAG7B;IACJ,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA8B;gBAGhD,aAAa,EAAE,SAAS,GAAG,SAAS,EACpC,QAAQ,GAAE,qBAA4C;IAGzE;;;;OAIG;IACG,OAAO,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA2CvE,oEAAoE;IACpE,oBAAoB,CAClB,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,qBAAqB,CAAC;IAOjC;;;;OAIG;IACH,mBAAmB,CACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,kBAAkB,EACzB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,qBAAqB,CAAC;IAIjC;;;;OAIG;IACG,aAAa,CACjB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAC9B,OAAO,CAAC,OAAO,CAAC;IAYnB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAe1B,oEAAoE;IACpE,OAAO,CAAC,iBAAiB;IAYzB,gFAAgF;YAClE,cAAc;IAI5B,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,eAAe;CAGxB"}
+{"version":3,"file":"replay-payload-cache.d.ts","sourceRoot":"","sources":["../src/replay-payload-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EACL,KAAK,qBAAqB,EAE1B,KAAK,qBAAqB,EAC3B,MAAM,oBAAoB,CAAC;AAG5B,KAAK,kBAAkB,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;AAezD;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAkB;IAS3B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAT3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAG7B;IACJ,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA8B;IACnE,OAAO,CAAC,uBAAuB,CAAK;gBAGjB,aAAa,EAAE,UAAU,GAAG,SAAS,EACrC,QAAQ,GAAE,qBAA4C;IAGzE;;;;OAIG;IACG,OAAO,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAoDvE,oEAAoE;IACpE,oBAAoB,CAClB,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,qBAAqB,CAAC;IAOjC;;;;OAIG;IACH,mBAAmB,CACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,kBAAkB,EACzB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,qBAAqB,CAAC;IAIjC;;;;OAIG;IACG,aAAa,CACjB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAC9B,OAAO,CAAC,OAAO,CAAC;IAYnB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAe1B,oEAAoE;IACpE,OAAO,CAAC,iBAAiB;IAYzB,gFAAgF;YAClE,cAAc;IAI5B,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,eAAe;CAGxB"}

package/dist/replay-payload-cache.js

@@ -31,6 +31,7 @@ export class ReplayPayloadCache {
     preparer;
     preparedPayloads = new Map();
     primitiveStepResults = new Map();
+    nextUnscannedEventIndex = 0;
     constructor(encryptionKey, preparer = prepareReplayPayload) {
         this.encryptionKey = encryptionKey;
         this.preparer = preparer;
@@ -55,7 +56,11 @@ export class ReplayPayloadCache {
             preparations.push(this.ensurePreparation(cacheKey, value));
         };
         start(this.workflowInputKey(workflowRun.runId), workflowRun.input);
-        for (const event of events) {
+        // This cache is scoped to one invocation and its append-only event log.
+        // Full snapshot reloads preserve the already-seen prefix, so its length is
+        // enough to locate events appended since the previous replay.
+        for (let index = this.nextUnscannedEventIndex; index < events.length; index++) {
+            const event = events[index];
             switch (event.eventType) {
                 case 'step_completed':
                     start(this.eventPayloadKey(event.eventId, 'result'), event.eventData?.result);
@@ -68,6 +73,7 @@ export class ReplayPayloadCache {
                     break;
             }
         }
+        this.nextUnscannedEventIndex = events.length;
         // Prewarming is speculative and must not fail replay before the matching
         // event is consumed. allSettled also attaches rejection handlers eagerly.
         await Promise.allSettled(preparations);
@@ -134,4 +140,4 @@ export class ReplayPayloadCache {
         return `event:${eventId}:${field}`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"replay-payload-cache.js","sourceRoot":"","sources":["../src/replay-payload-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Event, WorkflowRun } from '@workflow/world';\nimport type { CryptoKey } from './encryption.js';\nimport {\n  type PreparedReplayPayload,\n  prepareReplayPayload,\n  type ReplayPayloadPreparer,\n} from './serialization.js';\n\nconst MAX_MEMOIZED_PRIMITIVE_LENGTH = 4096;\ntype ReplayPayloadField = 'result' | 'error' | 'payload';\n\nfunction isMemoizablePrimitive(value: unknown): boolean {\n  if (value === null) return true;\n  const type = typeof value;\n  if (type === 'object' || type === 'function') return false;\n  if (type === 'string') {\n    return (value as string).length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;\n  }\n  if (type === 'bigint') {\n    return (value as bigint).toString().length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;\n  }\n  return true;\n}\n\n/**\n * Invocation-scoped cache for replay payload hydration.\n *\n * A workflow invocation may replay the same event log through several fresh\n * VMs. This cache keeps the VM-independent decrypt/decompress result across\n * those replays. Deserialization still runs against each VM's globals so every\n * replay receives fresh object graphs and correctly revived Workflow objects.\n *\n * Successful prepared plaintext remains resident for the invocation lifetime.\n * Its memory cost is the sum of decrypted and decompressed payload sizes, but\n * it never crosses workflow runs or queue deliveries.\n */\nexport class ReplayPayloadCache {\n  private readonly preparedPayloads = new Map<\n    string,\n    Promise<PreparedReplayPayload>\n  >();\n  private readonly primitiveStepResults = new Map<string, unknown>();\n\n  constructor(\n    private readonly encryptionKey: CryptoKey | undefined,\n    private readonly preparer: ReplayPayloadPreparer = prepareReplayPayload\n  ) {}\n\n  /**\n   * Start every missing binary preparation before workflow execution. Failures\n   * are intentionally retained: the ordered event consumer must observe the\n   * original rejection before that entry becomes retryable.\n   */\n  async prewarm(workflowRun: WorkflowRun, events: Event[]): Promise<void> {\n    const preparations: Promise<PreparedReplayPayload>[] = [];\n    const start = (cacheKey: string, value: unknown): void => {\n      // Legacy flattened values may be mutated by devalue's unflatten and are\n      // therefore prepared only by their eventual consumer, never cached.\n      if (!(value instanceof Uint8Array)) return;\n\n      // Each replay scans the full event log, so awaiting cached promises here\n      // would add O(N^2) promise reactions over an N-step invocation. Only wait\n      // for preparations first discovered by this prewarm pass.\n      if (this.preparedPayloads.has(cacheKey)) return;\n      preparations.push(this.ensurePreparation(cacheKey, value));\n    };\n\n    start(this.workflowInputKey(workflowRun.runId), workflowRun.input);\n    for (const event of events) {\n      switch (event.eventType) {\n        case 'step_completed':\n          start(\n            this.eventPayloadKey(event.eventId, 'result'),\n            event.eventData?.result\n          );\n          break;\n        case 'step_failed':\n          start(\n            this.eventPayloadKey(event.eventId, 'error'),\n            event.eventData?.error\n          );\n          break;\n        case 'hook_received':\n          start(\n            this.eventPayloadKey(event.eventId, 'payload'),\n            event.eventData?.payload\n          );\n          break;\n      }\n    }\n\n    // Prewarming is speculative and must not fail replay before the matching\n    // event is consumed. allSettled also attaches rejection handlers eagerly.\n    await Promise.allSettled(preparations);\n  }\n\n  /** Return the workflow input after shared host-side preparation. */\n  prepareWorkflowInput(\n    workflowRun: WorkflowRun\n  ): Promise<PreparedReplayPayload> {\n    return this.consumePreparation(\n      this.workflowInputKey(workflowRun.runId),\n      workflowRun.input\n    );\n  }\n\n  /**\n   * Return an event payload after shared host-side preparation. A rejected\n   * preparation is evicted only after this ordered consumer requests it, so a\n   * later replay can retry without hiding the original failure.\n   */\n  prepareEventPayload(\n    eventId: string,\n    field: ReplayPayloadField,\n    value: unknown\n  ): Promise<PreparedReplayPayload> {\n    return this.consumePreparation(this.eventPayloadKey(eventId, field), value);\n  }\n\n  /**\n   * Reuse final step values only when sharing them across VMs is unobservable.\n   * Objects and large strings/bigints always run `hydrate` again, producing a\n   * fresh VM-specific value from the separately cached prepared payload.\n   */\n  async getStepResult(\n    eventId: string,\n    hydrate: () => Promise<unknown>\n  ): Promise<unknown> {\n    if (this.primitiveStepResults.has(eventId)) {\n      return this.primitiveStepResults.get(eventId);\n    }\n\n    const value = await hydrate();\n    if (isMemoizablePrimitive(value)) {\n      this.primitiveStepResults.set(eventId, value);\n    }\n    return value;\n  }\n\n  /**\n   * Consumer-facing lookup. Binary payloads share preparation; legacy values\n   * bypass the cache because their flattened representation may be mutated.\n   */\n  private consumePreparation(\n    cacheKey: string,\n    value: unknown\n  ): Promise<PreparedReplayPayload> {\n    if (!(value instanceof Uint8Array)) return this.runPreparation(value);\n\n    const preparation = this.ensurePreparation(cacheKey, value);\n    void preparation.catch(() => {\n      if (this.preparedPayloads.get(cacheKey) === preparation) {\n        this.preparedPayloads.delete(cacheKey);\n      }\n    });\n    return preparation;\n  }\n\n  /** Start preparation once and share the exact in-flight promise. */\n  private ensurePreparation(\n    cacheKey: string,\n    value: Uint8Array\n  ): Promise<PreparedReplayPayload> {\n    const cached = this.preparedPayloads.get(cacheKey);\n    if (cached) return cached;\n\n    const preparation = this.runPreparation(value);\n    this.preparedPayloads.set(cacheKey, preparation);\n    return preparation;\n  }\n\n  /** Normalize synchronous and asynchronous preparers to one promise contract. */\n  private async runPreparation(value: unknown): Promise<PreparedReplayPayload> {\n    return this.preparer(value, this.encryptionKey);\n  }\n\n  private workflowInputKey(runId: string): string {\n    return `run:${runId}:input`;\n  }\n\n  private eventPayloadKey(eventId: string, field: ReplayPayloadField): string {\n    return `event:${eventId}:${field}`;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"replay-payload-cache.js","sourceRoot":"","sources":["../src/replay-payload-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Event, WorkflowRun } from '@workflow/world';\nimport type { PayloadKey } from './serialization/encryption.js';\nimport {\n  type PreparedReplayPayload,\n  prepareReplayPayload,\n  type ReplayPayloadPreparer,\n} from './serialization.js';\n\nconst MAX_MEMOIZED_PRIMITIVE_LENGTH = 4096;\ntype ReplayPayloadField = 'result' | 'error' | 'payload';\n\nfunction isMemoizablePrimitive(value: unknown): boolean {\n  if (value === null) return true;\n  const type = typeof value;\n  if (type === 'object' || type === 'function') return false;\n  if (type === 'string') {\n    return (value as string).length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;\n  }\n  if (type === 'bigint') {\n    return (value as bigint).toString().length <= MAX_MEMOIZED_PRIMITIVE_LENGTH;\n  }\n  return true;\n}\n\n/**\n * Invocation-scoped cache for replay payload hydration.\n *\n * A workflow invocation may replay the same event log through several fresh\n * VMs. This cache keeps the VM-independent decrypt/decompress result across\n * those replays. Deserialization still runs against each VM's globals so every\n * replay receives fresh object graphs and correctly revived Workflow objects.\n *\n * Successful prepared plaintext remains resident for the invocation lifetime.\n * Its memory cost is the sum of decrypted and decompressed payload sizes, but\n * it never crosses workflow runs or queue deliveries.\n */\nexport class ReplayPayloadCache {\n  private readonly preparedPayloads = new Map<\n    string,\n    Promise<PreparedReplayPayload>\n  >();\n  private readonly primitiveStepResults = new Map<string, unknown>();\n  private nextUnscannedEventIndex = 0;\n\n  constructor(\n    private readonly encryptionKey: PayloadKey | undefined,\n    private readonly preparer: ReplayPayloadPreparer = prepareReplayPayload\n  ) {}\n\n  /**\n   * Start every missing binary preparation before workflow execution. Failures\n   * are intentionally retained: the ordered event consumer must observe the\n   * original rejection before that entry becomes retryable.\n   */\n  async prewarm(workflowRun: WorkflowRun, events: Event[]): Promise<void> {\n    const preparations: Promise<PreparedReplayPayload>[] = [];\n    const start = (cacheKey: string, value: unknown): void => {\n      // Legacy flattened values may be mutated by devalue's unflatten and are\n      // therefore prepared only by their eventual consumer, never cached.\n      if (!(value instanceof Uint8Array)) return;\n\n      // Each replay scans the full event log, so awaiting cached promises here\n      // would add O(N^2) promise reactions over an N-step invocation. Only wait\n      // for preparations first discovered by this prewarm pass.\n      if (this.preparedPayloads.has(cacheKey)) return;\n      preparations.push(this.ensurePreparation(cacheKey, value));\n    };\n\n    start(this.workflowInputKey(workflowRun.runId), workflowRun.input);\n    // This cache is scoped to one invocation and its append-only event log.\n    // Full snapshot reloads preserve the already-seen prefix, so its length is\n    // enough to locate events appended since the previous replay.\n    for (\n      let index = this.nextUnscannedEventIndex;\n      index < events.length;\n      index++\n    ) {\n      const event = events[index];\n      switch (event.eventType) {\n        case 'step_completed':\n          start(\n            this.eventPayloadKey(event.eventId, 'result'),\n            event.eventData?.result\n          );\n          break;\n        case 'step_failed':\n          start(\n            this.eventPayloadKey(event.eventId, 'error'),\n            event.eventData?.error\n          );\n          break;\n        case 'hook_received':\n          start(\n            this.eventPayloadKey(event.eventId, 'payload'),\n            event.eventData?.payload\n          );\n          break;\n      }\n    }\n    this.nextUnscannedEventIndex = events.length;\n\n    // Prewarming is speculative and must not fail replay before the matching\n    // event is consumed. allSettled also attaches rejection handlers eagerly.\n    await Promise.allSettled(preparations);\n  }\n\n  /** Return the workflow input after shared host-side preparation. */\n  prepareWorkflowInput(\n    workflowRun: WorkflowRun\n  ): Promise<PreparedReplayPayload> {\n    return this.consumePreparation(\n      this.workflowInputKey(workflowRun.runId),\n      workflowRun.input\n    );\n  }\n\n  /**\n   * Return an event payload after shared host-side preparation. A rejected\n   * preparation is evicted only after this ordered consumer requests it, so a\n   * later replay can retry without hiding the original failure.\n   */\n  prepareEventPayload(\n    eventId: string,\n    field: ReplayPayloadField,\n    value: unknown\n  ): Promise<PreparedReplayPayload> {\n    return this.consumePreparation(this.eventPayloadKey(eventId, field), value);\n  }\n\n  /**\n   * Reuse final step values only when sharing them across VMs is unobservable.\n   * Objects and large strings/bigints always run `hydrate` again, producing a\n   * fresh VM-specific value from the separately cached prepared payload.\n   */\n  async getStepResult(\n    eventId: string,\n    hydrate: () => Promise<unknown>\n  ): Promise<unknown> {\n    if (this.primitiveStepResults.has(eventId)) {\n      return this.primitiveStepResults.get(eventId);\n    }\n\n    const value = await hydrate();\n    if (isMemoizablePrimitive(value)) {\n      this.primitiveStepResults.set(eventId, value);\n    }\n    return value;\n  }\n\n  /**\n   * Consumer-facing lookup. Binary payloads share preparation; legacy values\n   * bypass the cache because their flattened representation may be mutated.\n   */\n  private consumePreparation(\n    cacheKey: string,\n    value: unknown\n  ): Promise<PreparedReplayPayload> {\n    if (!(value instanceof Uint8Array)) return this.runPreparation(value);\n\n    const preparation = this.ensurePreparation(cacheKey, value);\n    void preparation.catch(() => {\n      if (this.preparedPayloads.get(cacheKey) === preparation) {\n        this.preparedPayloads.delete(cacheKey);\n      }\n    });\n    return preparation;\n  }\n\n  /** Start preparation once and share the exact in-flight promise. */\n  private ensurePreparation(\n    cacheKey: string,\n    value: Uint8Array\n  ): Promise<PreparedReplayPayload> {\n    const cached = this.preparedPayloads.get(cacheKey);\n    if (cached) return cached;\n\n    const preparation = this.runPreparation(value);\n    this.preparedPayloads.set(cacheKey, preparation);\n    return preparation;\n  }\n\n  /** Normalize synchronous and asynchronous preparers to one promise contract. */\n  private async runPreparation(value: unknown): Promise<PreparedReplayPayload> {\n    return this.preparer(value, this.encryptionKey);\n  }\n\n  private workflowInputKey(runId: string): string {\n    return `run:${runId}:input`;\n  }\n\n  private eventPayloadKey(eventId: string, field: ReplayPayloadField): string {\n    return `event:${eventId}:${field}`;\n  }\n}\n"]}

package/dist/runtime/count-step-started-events.d.ts

@@ -0,0 +1,52 @@
+import type { Event } from '@workflow/world';
+/**
+ * Scope for {@link countStepStartedEvents}:
+ * - `{ type: 'ownedBy', messageId }` counts only starts whose
+ *   `eventData.ownerMessageId` matches — i.e. attempts performed by that
+ *   owning queue message (inline lazy starts and owned-recovery re-stamps).
+ * - `{ type: 'totalAttempts' }` estimates the step's genuine attempt total
+ *   across its whole lifecycle: unstamped (bare) starts — which only real
+ *   queue-dispatched background deliveries write — plus the starts of the
+ *   single most-started owner. A genuine lifecycle has at most one inline
+ *   owner phase (ownership is claimed atomically at step creation and
+ *   lapses permanently at `step_retrying` or on any bare start), so taking
+ *   the max over owners counts that phase's real attempts while invocations
+ *   racing on the same batch — which stamp their own one-off message IDs —
+ *   contribute at most their single largest count instead of accumulating.
+ */
+export type StepStartScope = {
+    type: 'ownedBy';
+    messageId: string;
+} | {
+    type: 'totalAttempts';
+};
+/**
+ * Number of `step_started` events already recorded for a step, used as the
+ * authoritative attempt count for the maxRetries ceiling (the only bound for
+ * steps that time out without writing a `step_failed`).
+ *
+ * IMPORTANT: the raw (unscoped) count is NOT a reliable attempt number.
+ * Concurrent invocations racing on the same pending batch (stale replays,
+ * wake replays, a step message dispatched by a replay that lost the
+ * create-claim race, ...) can each write a `step_started` for the same
+ * logical attempt — worlds without an atomic start guard (world-local) let
+ * all of them through. Counting those duplicates as "attempts" made the
+ * maxRetries ceiling fire on healthy runs and fail them with a false
+ * "exceeded max retries" (see workflow#3069).
+ *
+ * Callers therefore scope the count to the starts their ceiling is actually
+ * about via `scope`:
+ * - the inline owned-recovery ceiling counts only THIS message's starts
+ *   (`ownedBy`) — each real (re)delivery of the owning message stamps its
+ *   `ownerMessageId` on the start it writes, while racing invocations stamp
+ *   their own IDs (or none), so they no longer inflate the count;
+ * - the background-step ceiling counts the lifecycle attempt total
+ *   (`totalAttempts`: bare starts plus the largest single owner's starts) —
+ *   so a step that exhausted part of its budget under inline ownership
+ *   before transitioning to queued/bare retries still trips the combined
+ *   ceiling, while racers' one-off stamped duplicates don't accumulate, and
+ *   throttle/too-early redeliveries (which write no start at all) stay
+ *   excluded as before.
+ */
+export declare function countStepStartedEvents(events: Event[] | null | undefined, stepId: string, scope?: StepStartScope): number;
+//# sourceMappingURL=count-step-started-events.d.ts.map

package/dist/runtime/count-step-started-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-step-started-events.d.ts","sourceRoot":"","sources":["../../src/runtime/count-step-started-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,CAAC;AAU9B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,GAAG,SAAS,EAClC,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,cAAc,GACrB,MAAM,CAmCR"}

package/dist/runtime/count-step-started-events.js

@@ -0,0 +1,72 @@
+const ownerOf = (e) => 'eventData' in e &&
+    e.eventData &&
+    'ownerMessageId' in e.eventData &&
+    typeof e.eventData.ownerMessageId === 'string'
+    ? e.eventData.ownerMessageId
+    : undefined;
+/**
+ * Number of `step_started` events already recorded for a step, used as the
+ * authoritative attempt count for the maxRetries ceiling (the only bound for
+ * steps that time out without writing a `step_failed`).
+ *
+ * IMPORTANT: the raw (unscoped) count is NOT a reliable attempt number.
+ * Concurrent invocations racing on the same pending batch (stale replays,
+ * wake replays, a step message dispatched by a replay that lost the
+ * create-claim race, ...) can each write a `step_started` for the same
+ * logical attempt — worlds without an atomic start guard (world-local) let
+ * all of them through. Counting those duplicates as "attempts" made the
+ * maxRetries ceiling fire on healthy runs and fail them with a false
+ * "exceeded max retries" (see workflow#3069).
+ *
+ * Callers therefore scope the count to the starts their ceiling is actually
+ * about via `scope`:
+ * - the inline owned-recovery ceiling counts only THIS message's starts
+ *   (`ownedBy`) — each real (re)delivery of the owning message stamps its
+ *   `ownerMessageId` on the start it writes, while racing invocations stamp
+ *   their own IDs (or none), so they no longer inflate the count;
+ * - the background-step ceiling counts the lifecycle attempt total
+ *   (`totalAttempts`: bare starts plus the largest single owner's starts) —
+ *   so a step that exhausted part of its budget under inline ownership
+ *   before transitioning to queued/bare retries still trips the combined
+ *   ceiling, while racers' one-off stamped duplicates don't accumulate, and
+ *   throttle/too-early redeliveries (which write no start at all) stay
+ *   excluded as before.
+ */
+export function countStepStartedEvents(events, stepId, scope) {
+    if (!events) {
+        return 0;
+    }
+    let bare = 0;
+    const byOwner = new Map();
+    for (const e of events) {
+        if (e.eventType !== 'step_started' || e.correlationId !== stepId) {
+            continue;
+        }
+        const owner = ownerOf(e);
+        if (owner === undefined) {
+            bare++;
+        }
+        else {
+            byOwner.set(owner, (byOwner.get(owner) ?? 0) + 1);
+        }
+    }
+    if (scope === undefined) {
+        let total = bare;
+        for (const count of byOwner.values()) {
+            total += count;
+        }
+        return total;
+    }
+    if (scope.type === 'ownedBy') {
+        return byOwner.get(scope.messageId) ?? 0;
+    }
+    // totalAttempts
+    let maxOwner = 0;
+    for (const count of byOwner.values()) {
+        if (count > maxOwner) {
+            maxOwner = count;
+        }
+    }
+    return bare + maxOwner;
+}
+//# sourceMappingURL=data:application/json;base64,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