@workflow/core 5.0.0-beta.4 → 5.0.0-beta.41

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,0EAA0E;IAC1E,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":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAgC9D;;;;;;;;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,69 @@
+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`).
+ */
+const inFlightSteps = 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 = inFlightSteps.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 just skips.
+        }
+        return { type: 'skipped' };
+    }
+    const promise = execute();
+    inFlightSteps.set(key, promise);
+    try {
+        return await promise;
+    }
+    finally {
+        inFlightSteps.delete(key);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,24 +1,126 @@
 import type { Span } from '@opentelemetry/api';
-import { type WorkflowRun, type World } from '@workflow/world';
-import type { WorkflowSuspension } from '../global.js';
+import { type SerializedData, type WorkflowRun, type World } from '@workflow/world';
+import type { StepInvocationQueueItem, WorkflowSuspension } from '../global.js';
+import { type LoadedEventLog } from './helpers.js';
+import { ReplayRecoveryReporter } from './replay-recovery-reporter.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
+     * is sent with the precondition snapshot derived from it, so a backend that
+     * has recorded an event the replay did not see rejects the write with a 412
+     * instead of accepting a divergent event. The 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.
+     */
+    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;
 }
+/**
+ * Result of handling a suspension. Returns pending step items so the caller
+ * can decide which to execute inline vs queue to background.
+ */
 export interface SuspensionHandlerResult {
-    timeoutSeconds?: number;
+    /** Pending step items with events created but NOT queued */
+    pendingSteps: StepInvocationQueueItem[];
+    /**
+     * 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
+     * guarantees a single owner per step, even when multiple handlers race
+     * into the same batch boundary.
+     */
+    createdStepCorrelationIds: 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;
+    }>;
+    /**
+     * 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 conflict was detected (should re-invoke immediately) */
+    hasHookConflict: boolean;
+    /** Whether a `hook.getConflict()` awaiter needs the workflow to continue immediately */
+    hasAwaitedHookCreation: 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;
+    /**
+     * Whether serializing this suspension's new step inputs was passive (did
+     * not execute workflow-owned code such as getters, proxy traps, or custom
+     * serializers). `false` means the retained VM may have diverged from what
+     * a cold replay would compute, so the caller must demote to replay.
+     */
+    retainedStepInputsSafe: boolean;
 }
 /**
  * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).
- * Uses an event-sourced architecture where entities (steps, hooks) are created atomically
- * with their corresponding events via events.create().
+ * 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. Steps and waits are processed in parallel after hooks complete
+ * 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, }: 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,EAIV,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAwBtB,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,MAAM,WAAW,uBAAuB;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,GACV,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAgS5D"}
+{"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;AAS/C,OAAO,EAKL,KAAK,cAAc,EAGnB,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAGV,uBAAuB,EAEvB,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAOtB,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEvE,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;IACnB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,8EAA8E;IAC9E,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CACjD;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;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;;;OAYG;IACH,eAAe,EAAE,KAAK,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,EAAE,cAAc,CAAC;KACjC,CAAC,CAAC;IACH;;;;;;OAMG;IACH,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IACzD,0EAA0E;IAC1E,eAAe,EAAE,OAAO,CAAC;IACzB,wFAAwF;IACxF,sBAAsB,EAAE,OAAO,CAAC;IAChC,wEAAwE;IACxE,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,sBAAsB,EAAE,OAAO,CAAC;CACjC;AA6ED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,eAAe,EACf,sBAAsB,GACvB,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAgnB5D"}