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

package/dist/runtime/step-ownership.js

@@ -0,0 +1,114 @@
+import { getInlineOwnershipLeaseSeconds } from './constants.js';
+/**
+ * Inline step ownership helpers for the pending-step dispatch decision table
+ * in runtime.ts (workflow#2780). Ownership state itself is derived per-replay
+ * from the event log by the step consumer in step.ts and surfaced on
+ * StepInvocationQueueItem; these functions interpret that state at dispatch
+ * time.
+ */
+/**
+ * Whether inline step ownership is active for a pending step: created,
+ * latest `step_started` carries an owner stamp, and no `step_retrying` has
+ * been observed (from `step_retrying` on, the step is queue-owned by its
+ * delayed retry handoff / replay requeue, so ownership is permanently
+ * lapsed for the correlation ID).
+ */
+export function isStepOwnershipActive(step) {
+    return (step.hasCreatedEvent === true &&
+        step.ownerMessageId !== undefined &&
+        step.sawRetrying !== true);
+}
+/**
+ * Seconds left on an owned step's liveness lease, anchored at its latest
+ * `step_started`. 0 means the lease has expired (or the start timestamp is
+ * missing, the degraded mode for worlds whose events lack usable
+ * timestamps), in which case dispatch falls back to the immediate enqueue.
+ *
+ * The result is clamped to the configured lease: `lastStartedAt` is the
+ * server-stamped event `createdAt` while `nowMs` is the local clock, so a
+ * client running behind the server would otherwise compute a remainder
+ * LONGER than the lease itself, and with the lease tuned to the 900s cap,
+ * a `delaySeconds` above the queue's per-message maximum, which SQS-backed
+ * worlds reject outright (the wake replay's enqueue would throw and ride
+ * the redelivery loop). The clamp makes skew strictly harmless; remaining
+ * time can never legitimately exceed the full lease anyway.
+ */
+export function stepLeaseRemainingSeconds(step, nowMs) {
+    if (step.lastStartedAt === undefined)
+        return 0;
+    const leaseSeconds = getInlineOwnershipLeaseSeconds();
+    const remainingMs = step.lastStartedAt + leaseSeconds * 1000 - nowMs;
+    return Math.min(leaseSeconds, Math.max(0, Math.ceil(remainingMs / 1000)));
+}
+/**
+ * Idempotency key for the delayed backstop wake of an inline-owned step.
+ *
+ * The key is scoped to the current OWNERSHIP EPOCH (the timestamp of the
+ * latest `step_started`), not just the correlation ID. Within one epoch,
+ * every wake replay derives the same key, so fan-out stays capped at one
+ * pending backstop per step. But when owner recovery re-stamps the step
+ * (queue redelivery of the owning message → new `step_started` → new
+ * `lastStartedAt`), the key CHANGES. This is load-bearing for liveness:
+ * queues dedupe an idempotency key for the lifetime of the original
+ * message (including while a delivery of it is in flight), so a backstop
+ * that fires during a refreshed lease and tries to re-arm under a fixed key
+ * would dedupe against ITSELF and be dropped, leaving no escape hatch if
+ * the recovered owner later dies without further redeliveries. The epoch
+ * suffix gives the re-arm a fresh key. Pending backstops are bounded by the
+ * number of ownership epochs, i.e. the queue's redelivery budget for the
+ * owning message.
+ *
+ * The epoch value comes from the persisted event's `createdAt`, so every
+ * replayer derives the same key. Callers only build backstops when the
+ * lease has time remaining, which requires `lastStartedAt` to be set.
+ *
+ * The key must also never be the step message's own `idempotencyKey`
+ * (the bare correlation ID): the owner's retry handoff enqueues the step
+ * under that key with a short backoff, and a pending backstop sharing it
+ * would absorb the retry, turning a 1s backoff into a full-lease stall.
+ */
+export function backstopIdempotencyKey(step) {
+    return `${step.correlationId}:backstop:${step.lastStartedAt}`;
+}
+/**
+ * Whether any of the given pending correlation IDs is inline-owned by
+ * `messageId` per the raw event log: its LATEST `step_started` carries
+ * `ownerMessageId === messageId` and no `step_retrying` follows it. Used by
+ * the background-step fast path, which sees raw events (not the replay's
+ * queueItems), to decide whether to fall through to the main loop so this
+ * invocation can recover a step it owns instead of returning and leaving it
+ * to the delayed backstop.
+ */
+export function hasPendingStepOwnedByMessage(events, pendingCorrelationIds, messageId) {
+    // Latest-wins scan: events are in log order, so later entries overwrite.
+    // A step_retrying lapses ownership permanently (matching the sawRetrying
+    // semantics of the replay consumer in step.ts): from that point the step
+    // is queue-owned, whatever starts follow.
+    const latestOwner = new Map();
+    const sawRetrying = new Set();
+    for (const e of events) {
+        if (e.correlationId === undefined)
+            continue;
+        if (e.eventType === 'step_started') {
+            const owner = 'eventData' in e &&
+                e.eventData &&
+                'ownerMessageId' in e.eventData &&
+                typeof e.eventData.ownerMessageId === 'string'
+                ? e.eventData.ownerMessageId
+                : undefined;
+            latestOwner.set(e.correlationId, owner);
+        }
+        else if (e.eventType === 'step_retrying') {
+            sawRetrying.add(e.correlationId);
+        }
+    }
+    for (const id of pendingCorrelationIds) {
+        if (id !== undefined &&
+            !sawRetrying.has(id) &&
+            latestOwner.get(id) === messageId) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-ownership.js","sourceRoot":"","sources":["../../src/runtime/step-ownership.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,8BAA8B,EAAE,MAAM,gBAAgB,CAAC;AAEhE;;;;;;GAMG;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAA6B;IACjE,OAAO,CACL,IAAI,CAAC,eAAe,KAAK,IAAI;QAC7B,IAAI,CAAC,cAAc,KAAK,SAAS;QACjC,IAAI,CAAC,WAAW,KAAK,IAAI,CAC1B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,yBAAyB,CACvC,IAA6B,EAC7B,KAAa;IAEb,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS;QAAE,OAAO,CAAC,CAAC;IAC/C,MAAM,YAAY,GAAG,8BAA8B,EAAE,CAAC;IACtD,MAAM,WAAW,GAAG,IAAI,CAAC,aAAa,GAAG,YAAY,GAAG,IAAI,GAAG,KAAK,CAAC;IACrE,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAA6B;IAClE,OAAO,GAAG,IAAI,CAAC,aAAa,aAAa,IAAI,CAAC,aAAa,EAAE,CAAC;AAChE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,4BAA4B,CAC1C,MAAe,EACf,qBAA8C,EAC9C,SAAiB;IAEjB,yEAAyE;IACzE,yEAAyE;IACzE,yEAAyE;IACzE,0CAA0C;IAC1C,MAAM,WAAW,GAAG,IAAI,GAAG,EAA8B,CAAC;IAC1D,MAAM,WAAW,GAAG,IAAI,GAAG,EAAU,CAAC;IACtC,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,IAAI,CAAC,CAAC,aAAa,KAAK,SAAS;YAAE,SAAS;QAC5C,IAAI,CAAC,CAAC,SAAS,KAAK,cAAc,EAAE,CAAC;YACnC,MAAM,KAAK,GACT,WAAW,IAAI,CAAC;gBAChB,CAAC,CAAC,SAAS;gBACX,gBAAgB,IAAI,CAAC,CAAC,SAAS;gBAC/B,OAAO,CAAC,CAAC,SAAS,CAAC,cAAc,KAAK,QAAQ;gBAC5C,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,cAAc;gBAC5B,CAAC,CAAC,SAAS,CAAC;YAChB,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;QAC1C,CAAC;aAAM,IAAI,CAAC,CAAC,SAAS,KAAK,eAAe,EAAE,CAAC;YAC3C,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IACD,KAAK,MAAM,EAAE,IAAI,qBAAqB,EAAE,CAAC;QACvC,IACE,EAAE,KAAK,SAAS;YAChB,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;YACpB,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,SAAS,EACjC,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import type { Event } from '@workflow/world';\nimport type { StepInvocationQueueItem } from '../global.js';\nimport { getInlineOwnershipLeaseSeconds } from './constants.js';\n\n/**\n * Inline step ownership helpers for the pending-step dispatch decision table\n * in runtime.ts (workflow#2780). Ownership state itself is derived per-replay\n * from the event log by the step consumer in step.ts and surfaced on\n * StepInvocationQueueItem; these functions interpret that state at dispatch\n * time.\n */\n\n/**\n * Whether inline step ownership is active for a pending step: created,\n * latest `step_started` carries an owner stamp, and no `step_retrying` has\n * been observed (from `step_retrying` on, the step is queue-owned by its\n * delayed retry handoff / replay requeue, so ownership is permanently\n * lapsed for the correlation ID).\n */\nexport function isStepOwnershipActive(step: StepInvocationQueueItem): boolean {\n  return (\n    step.hasCreatedEvent === true &&\n    step.ownerMessageId !== undefined &&\n    step.sawRetrying !== true\n  );\n}\n\n/**\n * Seconds left on an owned step's liveness lease, anchored at its latest\n * `step_started`. 0 means the lease has expired (or the start timestamp is\n * missing, the degraded mode for worlds whose events lack usable\n * timestamps), in which case dispatch falls back to the immediate enqueue.\n *\n * The result is clamped to the configured lease: `lastStartedAt` is the\n * server-stamped event `createdAt` while `nowMs` is the local clock, so a\n * client running behind the server would otherwise compute a remainder\n * LONGER than the lease itself, and with the lease tuned to the 900s cap,\n * a `delaySeconds` above the queue's per-message maximum, which SQS-backed\n * worlds reject outright (the wake replay's enqueue would throw and ride\n * the redelivery loop). The clamp makes skew strictly harmless; remaining\n * time can never legitimately exceed the full lease anyway.\n */\nexport function stepLeaseRemainingSeconds(\n  step: StepInvocationQueueItem,\n  nowMs: number\n): number {\n  if (step.lastStartedAt === undefined) return 0;\n  const leaseSeconds = getInlineOwnershipLeaseSeconds();\n  const remainingMs = step.lastStartedAt + leaseSeconds * 1000 - nowMs;\n  return Math.min(leaseSeconds, Math.max(0, Math.ceil(remainingMs / 1000)));\n}\n\n/**\n * Idempotency key for the delayed backstop wake of an inline-owned step.\n *\n * The key is scoped to the current OWNERSHIP EPOCH (the timestamp of the\n * latest `step_started`), not just the correlation ID. Within one epoch,\n * every wake replay derives the same key, so fan-out stays capped at one\n * pending backstop per step. But when owner recovery re-stamps the step\n * (queue redelivery of the owning message → new `step_started` → new\n * `lastStartedAt`), the key CHANGES. This is load-bearing for liveness:\n * queues dedupe an idempotency key for the lifetime of the original\n * message (including while a delivery of it is in flight), so a backstop\n * that fires during a refreshed lease and tries to re-arm under a fixed key\n * would dedupe against ITSELF and be dropped, leaving no escape hatch if\n * the recovered owner later dies without further redeliveries. The epoch\n * suffix gives the re-arm a fresh key. Pending backstops are bounded by the\n * number of ownership epochs, i.e. the queue's redelivery budget for the\n * owning message.\n *\n * The epoch value comes from the persisted event's `createdAt`, so every\n * replayer derives the same key. Callers only build backstops when the\n * lease has time remaining, which requires `lastStartedAt` to be set.\n *\n * The key must also never be the step message's own `idempotencyKey`\n * (the bare correlation ID): the owner's retry handoff enqueues the step\n * under that key with a short backoff, and a pending backstop sharing it\n * would absorb the retry, turning a 1s backoff into a full-lease stall.\n */\nexport function backstopIdempotencyKey(step: StepInvocationQueueItem): string {\n  return `${step.correlationId}:backstop:${step.lastStartedAt}`;\n}\n\n/**\n * Whether any of the given pending correlation IDs is inline-owned by\n * `messageId` per the raw event log: its LATEST `step_started` carries\n * `ownerMessageId === messageId` and no `step_retrying` follows it. Used by\n * the background-step fast path, which sees raw events (not the replay's\n * queueItems), to decide whether to fall through to the main loop so this\n * invocation can recover a step it owns instead of returning and leaving it\n * to the delayed backstop.\n */\nexport function hasPendingStepOwnedByMessage(\n  events: Event[],\n  pendingCorrelationIds: Set<string | undefined>,\n  messageId: string\n): boolean {\n  // Latest-wins scan: events are in log order, so later entries overwrite.\n  // A step_retrying lapses ownership permanently (matching the sawRetrying\n  // semantics of the replay consumer in step.ts): from that point the step\n  // is queue-owned, whatever starts follow.\n  const latestOwner = new Map<string, string | undefined>();\n  const sawRetrying = new Set<string>();\n  for (const e of events) {\n    if (e.correlationId === undefined) continue;\n    if (e.eventType === 'step_started') {\n      const owner =\n        'eventData' in e &&\n        e.eventData &&\n        'ownerMessageId' in e.eventData &&\n        typeof e.eventData.ownerMessageId === 'string'\n          ? e.eventData.ownerMessageId\n          : undefined;\n      latestOwner.set(e.correlationId, owner);\n    } else if (e.eventType === 'step_retrying') {\n      sawRetrying.add(e.correlationId);\n    }\n  }\n  for (const id of pendingCorrelationIds) {\n    if (\n      id !== undefined &&\n      !sawRetrying.has(id) &&\n      latestOwner.get(id) === messageId\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n"]}

package/dist/runtime/step-single-flight.d.ts

@@ -0,0 +1,12 @@
+import type { StepExecutionResult } from './step-executor.js';
+/**
+ * Run `execute` unless an execution for the same run + step correlation ID is
+ * already in flight in this process. The winner's result is returned to the
+ * winner; a loser awaits the winner's settlement (success OR failure) and
+ * then returns `{ type: 'skipped' }` so its caller acks without running the
+ * body. A winner failure is not propagated to the loser: the winner's own
+ * queue message redelivers and drives the retry, so exactly one message
+ * keeps owning the outcome.
+ */
+export declare function runStepSingleFlight(runId: string, correlationId: string, execute: () => Promise<StepExecutionResult>): Promise<StepExecutionResult>;
+//# sourceMappingURL=step-single-flight.d.ts.map

package/dist/runtime/step-single-flight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-single-flight.d.ts","sourceRoot":"","sources":["../../src/runtime/step-single-flight.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAyC9D;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,OAAO,CAAC,mBAAmB,CAAC,GAC1C,OAAO,CAAC,mBAAmB,CAAC,CA8B9B"}

package/dist/runtime/step-single-flight.js

@@ -0,0 +1,75 @@
+import { globalSingleton } from '@workflow/utils';
+import { runtimeLogger } from '../logger.js';
+/**
+ * In-process single-flight for step body execution, keyed by
+ * `runId:correlationId`.
+ *
+ * This is a required companion to inline step ownership (see
+ * `isInlineOwnershipEnabled` in constants.ts): the ownership lease is a
+ * *death proof* only on platforms with a bounded invocation lifetime. On
+ * worlds without an invocation kill bound (world-local's single process,
+ * self-hosted deployments) a delayed backstop can fire while the owning
+ * execution is still mid-body, in the same process. This map absorbs that
+ * race: the loser awaits the winner's settlement and then acks WITHOUT
+ * executing. On Vercel Fluid compute it also absorbs same-instance races
+ * between an owner redelivery and a backstop.
+ *
+ * The loser must not ack-and-skip early (before the winner settles): a crash
+ * after an early ack would consume the loser's queue message while the
+ * winner's outcome is still unknown, potentially orphaning the step with no
+ * message left to drive it. Awaiting settlement first keeps the at-least-once
+ * envelope intact: if the loser's own invocation hits its deadline while
+ * waiting, its message redelivers and re-checks, degrading gracefully to
+ * polling.
+ *
+ * Cross-instance duplicates (two separate processes racing the same step)
+ * are out of scope here; that is what the ownership lease bounds on
+ * platforms where it is a death proof, and the documented residual risk on
+ * multi-instance self-hosted worlds (mitigate by raising
+ * `WORKFLOW_INLINE_OWNERSHIP_LEASE_SECONDS`).
+ */
+// On `globalThis` (see `globalSingleton`), not module scope: a per-copy map is
+// not single-flight. Two invocations reaching this module through different
+// bundler layers would each believe they were the only one in the process and
+// both run the step body, degrading in-process dedup to the cross-process
+// residual the doc above scopes out.
+const singleFlight = globalSingleton('@workflow/core//stepSingleFlight', 1, () => ({ inFlight: new Map() }));
+/**
+ * Run `execute` unless an execution for the same run + step correlation ID is
+ * already in flight in this process. The winner's result is returned to the
+ * winner; a loser awaits the winner's settlement (success OR failure) and
+ * then returns `{ type: 'skipped' }` so its caller acks without running the
+ * body. A winner failure is not propagated to the loser: the winner's own
+ * queue message redelivers and drives the retry, so exactly one message
+ * keeps owning the outcome.
+ */
+export async function runStepSingleFlight(runId, correlationId, execute) {
+    const key = `${runId}:${correlationId}`;
+    const existing = singleFlight.inFlight.get(key);
+    if (existing) {
+        // warn (always printed, unlike debug/info): the single-flight is
+        // absorbing what would have been a duplicate execution, typically a
+        // delayed backstop or retry message landing in the same process while
+        // the owner is still mid-body. Rare by design; a burst of these means
+        // leases are expiring under live executions (raise
+        // WORKFLOW_INLINE_OWNERSHIP_LEASE_SECONDS).
+        runtimeLogger.warn('Step execution already in flight in this process; awaiting its settlement instead of executing again', { workflowRunId: runId, stepId: correlationId });
+        try {
+            await existing;
+        }
+        catch {
+            // The winner failed (typically a transient world error). Its own queue
+            // message redelivers and retries; this loser still skips.
+        }
+        return { type: 'skipped' };
+    }
+    const promise = execute();
+    singleFlight.inFlight.set(key, promise);
+    try {
+        return await promise;
+    }
+    finally {
+        singleFlight.inFlight.delete(key);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/suspension-handler.d.ts

@@ -1,12 +1,89 @@
 import type { Span } from '@opentelemetry/api';
-import { type WorkflowRun, type World } from '@workflow/world';
+import { type SerializedData, type TraceCarrier, type ValidQueueName, type WorkflowRun, type World } from '@workflow/world';
 import type { StepInvocationQueueItem, WorkflowSuspension } from '../global.js';
+import { type GuestCodeExecution } from '../serialization/hardened.js';
+import { type LoadedEventLog } from './helpers.js';
+import { ReplayRecoveryReporter } from './replay-recovery-reporter.js';
+import type { PreclaimedInlineStart } from './step-executor.js';
 export interface SuspensionHandlerParams {
     suspension: WorkflowSuspension;
     world: World;
     run: WorkflowRun;
     span?: Span;
     requestId?: string;
+    /**
+     * The runtime's loaded event log. Every event creation this suspension makes
+     * names the position it was derived from, so a backend that has recorded
+     * events the replay did not see can report them back on the write, or, if
+     * it would rather refuse than report, reject it with a 412. A rejection is
+     * not retried here: the event's correlation id was minted by *this* replay's
+     * seeded sequence, so re-committing it against a corrected log would persist
+     * an event no correct replay produces. The caller restarts the replay
+     * instead.
+     *
+     * Extended in place by what those writes report back — the events on slots
+     * they skipped over, and (on the hook create) the inline delta since its
+     * cursor. Whether the log is complete afterwards is answered by
+     * {@link SuspensionHandlerResult.eventLogCarriedForward}.
+     */
+    eventLog?: LoadedEventLog;
+    /**
+     * Turbo mode only: a promise that resolves once the backgrounded
+     * `run_started` has landed (the run exists). When present, every world write
+     * this suspension performs (`hook_created`, `wait_created`, eager overflow
+     * `step_created`, …) is gated on it so the write never races ahead of the
+     * run's creation. The pure inline hot path defers all of its steps and writes
+     * nothing here, so it never awaits this barrier. `undefined` outside turbo,
+     * where `run_started` was already awaited up front.
+     */
+    runReadyBarrier?: Promise<unknown>;
+    /** One-shot telemetry reporter, activated only after replay has recovered. */
+    replayRecoveryReporter?: ReplayRecoveryReporter;
+    /**
+     * Resilient step dispatch: when provided (and the per-step eligibility gates
+     * pass, see the step ops below), each newly created non-inline step's
+     * `step_created` write is parallelized with its step-execution queue
+     * publish, and the queue message carries the serialized step input
+     * (`stepInput`) so the consumer can idempotently re-ensure the event if the
+     * direct write failed transiently. Steps queued this way are reported in
+     * {@link SuspensionHandlerResult.queuedStepCorrelationIds} so the caller
+     * skips them in its own dispatch pass. Omitted by callers that must not
+     * queue (terminal drain, tests); creates then behave exactly as before.
+     */
+    stepDispatch?: {
+        /** The unified workflow queue this run's step messages are published to. */
+        queueName: ValidQueueName;
+        /**
+         * Lazily resolves the trace carrier to stamp on the step messages.
+         * Called at most once per suspension (memoized here).
+         */
+        getTraceCarrier: () => Promise<TraceCarrier>;
+    };
+    /**
+     * Inline step ownership: the queue message ID of the invocation this
+     * suspension runs in (the queue handler's meta). When present AND the
+     * batched fan-out engages, the lazy-inline steps' deferred writes are
+     * folded into the batch as `step_created` + `step_started` pairs (the
+     * started row stamped with this ID, exactly like the lazy claim it
+     * replaces), pre-claiming the steps the caller is about to run inline. See
+     * {@link SuspensionHandlerResult.inlineClaims}. Callers that never
+     * inline-execute (terminal drain) omit it, keeping their lazy steps on the
+     * plain deferred path.
+     */
+    ownerMessageId?: string;
+    /**
+     * Lets the batched fan-out return before every chunk has committed: only
+     * the chunk carrying the pre-claimed inline pairs gates the handler's
+     * return (its claims are what the caller starts bodies from), while the
+     * trailing chunks' commits (and every chunk's in-flush step-message
+     * publishes) ride {@link SuspensionHandlerResult.deferredBatchWork}. A
+     * caller that opts in MUST await that promise before acking its delivery:
+     * the durability contract ("every create durable before ack") moves from
+     * the handler's return to that join, and nothing else re-drives a lost
+     * trailing chunk. Callers that don't opt in (terminal drain, default)
+     * keep the everything-durable-at-return behavior.
+     */
+    allowDeferredBatchWork?: boolean;
 }
 /**
  * Result of handling a suspension. Returns pending step items so the caller
@@ -19,24 +96,209 @@ export interface SuspensionHandlerResult {
      * Correlation IDs for which this suspension call actually wrote the
      * step_created event (as opposed to catching EntityConflictError because
      * a concurrent handler wrote it first). Only the handler that wrote the
-     * step_created event should queue / inline-execute the step — this
+     * step_created event should queue / inline-execute the step; this
      * guarantees a single owner per step, even when multiple handlers race
      * into the same batch boundary.
      */
     createdStepCorrelationIds: Set<string>;
-    /** Timeout from waits, if any */
-    timeoutSeconds?: number;
-    /** Whether a hook conflict was detected (should re-invoke immediately) */
+    /**
+     * Correlation IDs of steps whose arguments failed to serialize. Each was
+     * finalized here as `step_created` (with a placeholder input; the real
+     * input is precisely what refused to serialize) followed by `step_failed`
+     * carrying the SerializationError, so the next replay rejects the step's
+     * promise and a try/catch around the step call observes the error,
+     * exactly like a step-body failure. No step-execution message is
+     * dispatched for these, so the caller MUST force an in-process replay:
+     * when the failed step was the only pending work, nothing else will ever
+     * re-invoke the run to observe the terminal event.
+     */
+    failedStepCorrelationIds: Set<string>;
+    /**
+     * Correlation IDs of steps this suspension call already published
+     * step-execution queue messages for, via resilient step dispatch (the
+     * `step_created` write parallelized with a `stepInput`-carrying queue
+     * publish). The caller MUST NOT dispatch these again: the message is
+     * already out (a duplicate would be deduped by its idempotency key, but
+     * costs a wasted round-trip). Empty when {@link SuspensionHandlerParams.stepDispatch}
+     * was not provided or no step was eligible.
+     */
+    queuedStepCorrelationIds: Set<string>;
+    /**
+     * How many events this phase's writes reported back as occupying slots they
+     * skipped over, already merged into the caller's `eventLog.events`. Nonzero
+     * means the array was reordered to restore slot order, so any index the
+     * caller cached into it (payload prewarm scan position) is stale.
+     */
+    reportedEventCount: number;
+    /**
+     * The steps whose `step_created` writes were intentionally deferred so the
+     * caller can run them inline via lazy `step_started` events (which create
+     * the step on the fly), saving one world round-trip per inline step. Up to
+     * `getMaxInlineSteps()` steps are deferred; the caller runs them inline in
+     * parallel and queues the rest. Empty when no step was deferred (nothing
+     * pending, or a `hook.getConflict()` awaiter is present so nothing is
+     * executed inline). The caller passes each `dehydratedInput` straight to
+     * `executeStep`, which sends it as the `step_started` payload. The atomic
+     * create-claim inside each `step_started` is the exactly-one-owner gate that
+     * the standalone `step_created` provided before: the loser of the race gets
+     * `EntityConflictError` → `skipped` and does not run the body.
+     */
+    lazyInlineSteps: Array<{
+        correlationId: string;
+        stepName: string;
+        dehydratedInput: SerializedData;
+    }>;
+    /**
+     * Pre-claimed inline starts, by correlation id: the per-step verdicts of
+     * the `step_created` + `step_started` pairs the batched fan-out committed
+     * for the lazy-inline steps. A step with an entry here is passed to
+     * `executeStep` as `preclaimedStart` INSTEAD of `lazyStepInput`: its
+     * input already rode the pair, and the claim is settled: `owned: true`
+     * carries the started attempt-1 entity (input re-attached) so the body
+     * runs straight off the batch commit with no start write of its own;
+     * `owned: false` lost the pair's atomic create-claim to a concurrent
+     * writer, and executeStep returns `skipped` without running the body,
+     * the same outcome as losing the lazy claim. Empty whenever the fold did
+     * not engage (batching off, no `ownerMessageId`, or the lone-inline case,
+     * which keeps the optimistic lazy path and its claim/body overlap).
+     *
+     * Crash window: the pair commits before the caller runs the body, so a
+     * crash between them leaves a started step stamped with this message's
+     * ID. Redelivery of the same message re-executes it via the owned-recovery
+     * path, the exact machinery the lazy claim's crash window already uses.
+     */
+    inlineClaims: Map<string, PreclaimedInlineStart>;
+    /**
+     * The highest slot the batched fan-out committed, when it ran. The batch's
+     * own events are not in the caller's loaded log (the next reload picks
+     * them up), so the caller folds this ceiling into the slot snapshot it
+     * hands the inline executions; otherwise every inline terminal write
+     * would name a pre-batch position and be answered with a skipped-slot
+     * report echoing the events this suspension just wrote. Under
+     * {@link SuspensionHandlerParams.allowDeferredBatchWork} this covers the
+     * chunks that had committed by the handler's return (always the pair
+     * chunk); a trailing chunk that commits later is echoed back on the
+     * terminal writes like any foreign event: reports the executor reads for
+     * position and discards.
+     *
+     * So the echo is only fully suppressed for a SINGLE-chunk fold. On a
+     * multi-chunk fan-out the bodies start off the pair chunk while trailing
+     * chunks are still in flight, and an inline terminal write issued in that
+     * window still names a position below them and still draws a report for
+     * their events. Bounded (trailing chunks only, large fan-outs only) and
+     * self-correcting on the next reload, and recorded so a report seen there
+     * reads as expected rather than as a bug.
+     */
+    batchCommittedSlotCeiling?: number;
+    /**
+     * The batched fan-out's deferred work, present only when the caller opted
+     * in via {@link SuspensionHandlerParams.allowDeferredBatchWork} and
+     * trailing work exists: the commits of every chunk except the pair chunk,
+     * plus every chunk's step-message publishes (each chained on ITS OWN
+     * chunk's commit, so publish-after-create holds per step). The caller
+     * MUST await it before acking: a rejection here is a failed suspension
+     * write and fails the delivery exactly as it would have at the handler's
+     * return. Steps whose messages this work publishes are already in
+     * {@link queuedStepCorrelationIds} at return time.
+     */
+    deferredBatchWork?: Promise<void>;
+    /**
+     * The soonest pending wait, if any: seconds until it elapses and the
+     * correlationId of the wait that produced that timeout. The
+     * correlationId seeds the idempotency key for the wait-continuation
+     * queue message so that repeated suspension passes over the same
+     * pending wait collapse into a single delayed continuation.
+     */
+    waitTimeout?: {
+        seconds: number;
+        correlationId: string;
+    };
+    /**
+     * Whether a hook create committed a `hook_conflict` — the token was already
+     * claimed, so this run's hook was never created and the workflow must
+     * observe the conflict before anything else this suspension scheduled runs.
+     * The caller answers it by advancing the workflow over the committed event.
+     */
     hasHookConflict: boolean;
+    /** Whether a `hook.getConflict()` awaiter needs the workflow to continue immediately */
+    hasAwaitedHookCreation: boolean;
+    /**
+     * Correlation ids of the hooks this suspension committed a `hook_created`
+     * for while a `hook.getConflict()` awaiter was waiting on it — the events
+     * that resolve those awaiters on the next pass. Empty exactly when
+     * {@link hasAwaitedHookCreation} is false.
+     *
+     * Reported by id, not just counted, so a caller that continues in this
+     * process can tell a continuation that got somewhere from one that is
+     * repeating: a workflow may create one awaited hook after another, and each
+     * new id is a pass that made progress, while the same id coming back means
+     * the pass ran over a log that still did not hold its event and continuing
+     * again cannot change that.
+     */
+    awaitedHookCorrelationIds: string[];
+    /**
+     * Correlation ids of the hooks whose create committed a `hook_conflict`.
+     * Empty exactly when {@link hasHookConflict} is false.
+     *
+     * By id for the same reason as {@link awaitedHookCorrelationIds}, and
+     * against the same hazard: a conflict is resolved by the `hook_conflict`
+     * this suspension committed, and until the workflow observes it the hook
+     * stays in the invocations queue and the next pass writes the create again.
+     * A fresh id is progress; the same id coming back is a pass that ran over a
+     * log which still did not hold the event, so continuing again cannot change
+     * that.
+     */
+    hookConflictCorrelationIds: string[];
+    /**
+     * Whether the caller's `eventLog` now holds every event this suspension
+     * committed, so a caller that continues in this process can replay — or
+     * resume a retained VM — straight off it with no read.
+     *
+     * True only when the hook create's inline delta came back complete and was
+     * folded in (see `hookDeltaCursor` below), and nothing else in this
+     * suspension wrote an event. False whenever a read is needed first: no
+     * delta was asked for or returned, it was truncated, or a step / wait /
+     * attribute / abort write landed above it and is therefore not in it.
+     *
+     * Indifferent to which event the create committed: the delta is the slice
+     * of the log after the caller's cursor either way, so it carries a
+     * `hook_conflict` exactly as it carries a `hook_created`.
+     */
+    eventLogCarriedForward: boolean;
+    /** Whether native workflow attribute events were written for replay. */
+    hasAttributeEvents: boolean;
+    /**
+     * Whether this suspension created any hook (`hook_created`) events. Unlike
+     * `hasHookConflict` / `hasAwaitedHookCreation`, this is true even for a plain
+     * fire-and-forget hook with no conflict and no awaiter. Turbo mode uses it to
+     * detect "a hook was created this suspension" and stop forcing optimistic
+     * inline start (a hook introduces later resume invocations that could race).
+     */
+    hasHookEvents: boolean;
+    /**
+     * Wall-clock ms spent committing this suspension's `hook_created` events
+     * (0 when it created none). The caller accumulates this across iterations
+     * and subtracts it from the TTFS latency measurement, so time spent
+     * durably creating the user's hooks doesn't count as runtime overhead.
+     */
+    hookCreationMs: number;
+    /** Exact number of workflow-code executions observed during serialization. */
+    serializationBlockerCount: number;
+    /** Bounded sample used only for retention diagnostics. */
+    serializationBlockers: SuspensionSerializationBlocker[];
+}
+export interface SuspensionSerializationBlocker extends GuestCodeExecution {
+    source: 'step_input' | 'hook_metadata' | 'hook_abort';
+    correlationId: string;
 }
 /**
  * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).
- * Creates events for all operations but does NOT queue step messages — returns the pending
+ * Creates events for all operations but does NOT queue step messages; returns the pending
  * steps so the caller can decide which to execute inline vs queue to background.
  *
  * Processing order:
  * 1. Hooks are processed first to prevent race conditions with webhook receivers
  * 2. Step events and wait events are created in parallel
  */
-export declare function handleSuspension({ suspension, world, run, span, requestId, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
+export declare function handleSuspension({ suspension, world, run, span, requestId, eventLog, runReadyBarrier, replayRecoveryReporter, stepDispatch, ownerMessageId, allowDeferredBatchWork, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
 //# sourceMappingURL=suspension-handler.d.ts.map

package/dist/runtime/suspension-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAO/C,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAEV,uBAAuB,EAEvB,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAMtB,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,WAAW,CAAC;IACjB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,4DAA4D;IAC5D,YAAY,EAAE,uBAAuB,EAAE,CAAC;IACxC;;;;;;;OAOG;IACH,yBAAyB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC,iCAAiC;IACjC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,GACV,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAyU5D"}
+{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"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"}