@workflow/core 5.0.0-beta.43 → 5.0.0-beta.44

package/dist/runtime/unserializable-step.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared shape for finalizing a step whose arguments failed to serialize
+ * (used by both the node:vm suspension handler and the QuickJS entrypoint).
+ *
+ * The world requires a `step_created` before any terminal step event, and
+ * the step's real input is precisely what refused to serialize, so the
+ * finalization writes a placeholder input. The marker string makes the
+ * placeholder distinguishable from a genuine zero-argument step in
+ * `workflow inspect steps` and the observability UI: a reader sees
+ * "input unavailable" instead of "no arguments".
+ */
+export declare const UNSERIALIZABLE_STEP_INPUT_MARKER = "[input unavailable: step argument serialization failed]";
+/**
+ * The placeholder value serialized into the failed step's `step_created`
+ * input. Matches the `{ args, closureVars, thisVal }` triple
+ * `dehydrateStepArguments` / the QuickJS bootstrap produce for real steps,
+ * so every consumer hydrates it uniformly, plus the structural flag the
+ * step executor checks before running user code (see
+ * {@link isUnserializableStepInputPlaceholder}).
+ */
+export declare function unserializableStepInputPlaceholder(): Record<string, unknown>;
+/**
+ * Whether a hydrated step input is the finalization placeholder.
+ *
+ * Finalization writes `step_created` (placeholder) and `step_failed` as two
+ * separate durable writes; a crash or transient failure between them leaves
+ * a pending step whose stored input is the placeholder. Redelivery then
+ * dispatches that step through normal crash recovery: the executor calls
+ * this before running user code and completes the intended failure (a fatal
+ * SerializationError → `step_failed`) instead of silently invoking the step
+ * body with placeholder arguments.
+ */
+export declare function isUnserializableStepInputPlaceholder(hydratedInput: unknown): boolean;
+//# sourceMappingURL=unserializable-step.d.ts.map

package/dist/runtime/unserializable-step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unserializable-step.d.ts","sourceRoot":"","sources":["../../src/runtime/unserializable-step.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gCAAgC,4DACc,CAAC;AAU5D;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAO5E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oCAAoC,CAClD,aAAa,EAAE,OAAO,GACrB,OAAO,CAMT"}

package/dist/runtime/unserializable-step.js

@@ -0,0 +1,52 @@
+/**
+ * Shared shape for finalizing a step whose arguments failed to serialize
+ * (used by both the node:vm suspension handler and the QuickJS entrypoint).
+ *
+ * The world requires a `step_created` before any terminal step event, and
+ * the step's real input is precisely what refused to serialize, so the
+ * finalization writes a placeholder input. The marker string makes the
+ * placeholder distinguishable from a genuine zero-argument step in
+ * `workflow inspect steps` and the observability UI: a reader sees
+ * "input unavailable" instead of "no arguments".
+ */
+export const UNSERIALIZABLE_STEP_INPUT_MARKER = '[input unavailable: step argument serialization failed]';
+/**
+ * Structural discriminator on the placeholder's top level. The
+ * `{ args, closureVars, thisVal }` triple is built by the SDK (user code
+ * never controls its top-level keys), so this flag cannot false-positive on
+ * a legitimate input, unlike the display marker inside `args`.
+ */
+const UNSERIALIZABLE_FLAG = '__workflowUnserializableStepInput';
+/**
+ * The placeholder value serialized into the failed step's `step_created`
+ * input. Matches the `{ args, closureVars, thisVal }` triple
+ * `dehydrateStepArguments` / the QuickJS bootstrap produce for real steps,
+ * so every consumer hydrates it uniformly, plus the structural flag the
+ * step executor checks before running user code (see
+ * {@link isUnserializableStepInputPlaceholder}).
+ */
+export function unserializableStepInputPlaceholder() {
+    return {
+        args: [UNSERIALIZABLE_STEP_INPUT_MARKER],
+        closureVars: [],
+        thisVal: undefined,
+        [UNSERIALIZABLE_FLAG]: true,
+    };
+}
+/**
+ * Whether a hydrated step input is the finalization placeholder.
+ *
+ * Finalization writes `step_created` (placeholder) and `step_failed` as two
+ * separate durable writes; a crash or transient failure between them leaves
+ * a pending step whose stored input is the placeholder. Redelivery then
+ * dispatches that step through normal crash recovery: the executor calls
+ * this before running user code and completes the intended failure (a fatal
+ * SerializationError → `step_failed`) instead of silently invoking the step
+ * body with placeholder arguments.
+ */
+export function isUnserializableStepInputPlaceholder(hydratedInput) {
+    return (typeof hydratedInput === 'object' &&
+        hydratedInput !== null &&
+        hydratedInput[UNSERIALIZABLE_FLAG] === true);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5zZXJpYWxpemFibGUtc3RlcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydW50aW1lL3Vuc2VyaWFsaXphYmxlLXN0ZXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7R0FVRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdDQUFnQyxHQUMzQyx5REFBeUQsQ0FBQztBQUU1RDs7Ozs7R0FLRztBQUNILE1BQU0sbUJBQW1CLEdBQUcsbUNBQW1DLENBQUM7QUFFaEU7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSxrQ0FBa0M7SUFDaEQsT0FBTztRQUNMLElBQUksRUFBRSxDQUFDLGdDQUFnQyxDQUFDO1FBQ3hDLFdBQVcsRUFBRSxFQUFFO1FBQ2YsT0FBTyxFQUFFLFNBQVM7UUFDbEIsQ0FBQyxtQkFBbUIsQ0FBQyxFQUFFLElBQUk7S0FDNUIsQ0FBQztBQUNKLENBQUM7QUFFRDs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxVQUFVLG9DQUFvQyxDQUNsRCxhQUFzQjtJQUV0QixPQUFPLENBQ0wsT0FBTyxhQUFhLEtBQUssUUFBUTtRQUNqQyxhQUFhLEtBQUssSUFBSTtRQUNyQixhQUF5QyxDQUFDLG1CQUFtQixDQUFDLEtBQUssSUFBSSxDQUN6RSxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogU2hhcmVkIHNoYXBlIGZvciBmaW5hbGl6aW5nIGEgc3RlcCB3aG9zZSBhcmd1bWVudHMgZmFpbGVkIHRvIHNlcmlhbGl6ZVxuICogKHVzZWQgYnkgYm90aCB0aGUgbm9kZTp2bSBzdXNwZW5zaW9uIGhhbmRsZXIgYW5kIHRoZSBRdWlja0pTIGVudHJ5cG9pbnQpLlxuICpcbiAqIFRoZSB3b3JsZCByZXF1aXJlcyBhIGBzdGVwX2NyZWF0ZWRgIGJlZm9yZSBhbnkgdGVybWluYWwgc3RlcCBldmVudCwgYW5kXG4gKiB0aGUgc3RlcCdzIHJlYWwgaW5wdXQgaXMgcHJlY2lzZWx5IHdoYXQgcmVmdXNlZCB0byBzZXJpYWxpemUsIHNvIHRoZVxuICogZmluYWxpemF0aW9uIHdyaXRlcyBhIHBsYWNlaG9sZGVyIGlucHV0LiBUaGUgbWFya2VyIHN0cmluZyBtYWtlcyB0aGVcbiAqIHBsYWNlaG9sZGVyIGRpc3Rpbmd1aXNoYWJsZSBmcm9tIGEgZ2VudWluZSB6ZXJvLWFyZ3VtZW50IHN0ZXAgaW5cbiAqIGB3b3JrZmxvdyBpbnNwZWN0IHN0ZXBzYCBhbmQgdGhlIG9ic2VydmFiaWxpdHkgVUk6IGEgcmVhZGVyIHNlZXNcbiAqIFwiaW5wdXQgdW5hdmFpbGFibGVcIiBpbnN0ZWFkIG9mIFwibm8gYXJndW1lbnRzXCIuXG4gKi9cbmV4cG9ydCBjb25zdCBVTlNFUklBTElaQUJMRV9TVEVQX0lOUFVUX01BUktFUiA9XG4gICdbaW5wdXQgdW5hdmFpbGFibGU6IHN0ZXAgYXJndW1lbnQgc2VyaWFsaXphdGlvbiBmYWlsZWRdJztcblxuLyoqXG4gKiBTdHJ1Y3R1cmFsIGRpc2NyaW1pbmF0b3Igb24gdGhlIHBsYWNlaG9sZGVyJ3MgdG9wIGxldmVsLiBUaGVcbiAqIGB7IGFyZ3MsIGNsb3N1cmVWYXJzLCB0aGlzVmFsIH1gIHRyaXBsZSBpcyBidWlsdCBieSB0aGUgU0RLICh1c2VyIGNvZGVcbiAqIG5ldmVyIGNvbnRyb2xzIGl0cyB0b3AtbGV2ZWwga2V5cyksIHNvIHRoaXMgZmxhZyBjYW5ub3QgZmFsc2UtcG9zaXRpdmUgb25cbiAqIGEgbGVnaXRpbWF0ZSBpbnB1dCwgdW5saWtlIHRoZSBkaXNwbGF5IG1hcmtlciBpbnNpZGUgYGFyZ3NgLlxuICovXG5jb25zdCBVTlNFUklBTElaQUJMRV9GTEFHID0gJ19fd29ya2Zsb3dVbnNlcmlhbGl6YWJsZVN0ZXBJbnB1dCc7XG5cbi8qKlxuICogVGhlIHBsYWNlaG9sZGVyIHZhbHVlIHNlcmlhbGl6ZWQgaW50byB0aGUgZmFpbGVkIHN0ZXAncyBgc3RlcF9jcmVhdGVkYFxuICogaW5wdXQuIE1hdGNoZXMgdGhlIGB7IGFyZ3MsIGNsb3N1cmVWYXJzLCB0aGlzVmFsIH1gIHRyaXBsZVxuICogYGRlaHlkcmF0ZVN0ZXBBcmd1bWVudHNgIC8gdGhlIFF1aWNrSlMgYm9vdHN0cmFwIHByb2R1Y2UgZm9yIHJlYWwgc3RlcHMsXG4gKiBzbyBldmVyeSBjb25zdW1lciBoeWRyYXRlcyBpdCB1bmlmb3JtbHksIHBsdXMgdGhlIHN0cnVjdHVyYWwgZmxhZyB0aGVcbiAqIHN0ZXAgZXhlY3V0b3IgY2hlY2tzIGJlZm9yZSBydW5uaW5nIHVzZXIgY29kZSAoc2VlXG4gKiB7QGxpbmsgaXNVbnNlcmlhbGl6YWJsZVN0ZXBJbnB1dFBsYWNlaG9sZGVyfSkuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB1bnNlcmlhbGl6YWJsZVN0ZXBJbnB1dFBsYWNlaG9sZGVyKCk6IFJlY29yZDxzdHJpbmcsIHVua25vd24+IHtcbiAgcmV0dXJuIHtcbiAgICBhcmdzOiBbVU5TRVJJQUxJWkFCTEVfU1RFUF9JTlBVVF9NQVJLRVJdLFxuICAgIGNsb3N1cmVWYXJzOiBbXSxcbiAgICB0aGlzVmFsOiB1bmRlZmluZWQsXG4gICAgW1VOU0VSSUFMSVpBQkxFX0ZMQUddOiB0cnVlLFxuICB9O1xufVxuXG4vKipcbiAqIFdoZXRoZXIgYSBoeWRyYXRlZCBzdGVwIGlucHV0IGlzIHRoZSBmaW5hbGl6YXRpb24gcGxhY2Vob2xkZXIuXG4gKlxuICogRmluYWxpemF0aW9uIHdyaXRlcyBgc3RlcF9jcmVhdGVkYCAocGxhY2Vob2xkZXIpIGFuZCBgc3RlcF9mYWlsZWRgIGFzIHR3b1xuICogc2VwYXJhdGUgZHVyYWJsZSB3cml0ZXM7IGEgY3Jhc2ggb3IgdHJhbnNpZW50IGZhaWx1cmUgYmV0d2VlbiB0aGVtIGxlYXZlc1xuICogYSBwZW5kaW5nIHN0ZXAgd2hvc2Ugc3RvcmVkIGlucHV0IGlzIHRoZSBwbGFjZWhvbGRlci4gUmVkZWxpdmVyeSB0aGVuXG4gKiBkaXNwYXRjaGVzIHRoYXQgc3RlcCB0aHJvdWdoIG5vcm1hbCBjcmFzaCByZWNvdmVyeTogdGhlIGV4ZWN1dG9yIGNhbGxzXG4gKiB0aGlzIGJlZm9yZSBydW5uaW5nIHVzZXIgY29kZSBhbmQgY29tcGxldGVzIHRoZSBpbnRlbmRlZCBmYWlsdXJlIChhIGZhdGFsXG4gKiBTZXJpYWxpemF0aW9uRXJyb3Ig4oaSIGBzdGVwX2ZhaWxlZGApIGluc3RlYWQgb2Ygc2lsZW50bHkgaW52b2tpbmcgdGhlIHN0ZXBcbiAqIGJvZHkgd2l0aCBwbGFjZWhvbGRlciBhcmd1bWVudHMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc1Vuc2VyaWFsaXphYmxlU3RlcElucHV0UGxhY2Vob2xkZXIoXG4gIGh5ZHJhdGVkSW5wdXQ6IHVua25vd25cbik6IGJvb2xlYW4ge1xuICByZXR1cm4gKFxuICAgIHR5cGVvZiBoeWRyYXRlZElucHV0ID09PSAnb2JqZWN0JyAmJlxuICAgIGh5ZHJhdGVkSW5wdXQgIT09IG51bGwgJiZcbiAgICAoaHlkcmF0ZWRJbnB1dCBhcyBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPilbVU5TRVJJQUxJWkFCTEVfRkxBR10gPT09IHRydWVcbiAgKTtcbn1cbiJdfQ==

package/dist/runtime/vm-mode.d.ts

@@ -24,7 +24,7 @@ export type WorkflowVmMode = (typeof WORKFLOW_VMS)[number];
  *
  * Returns the configured engine, or `undefined` if unset/empty.
  * Throws {@link WorkflowRuntimeError} if the value is set but not one of
- * the known engines — catching misconfiguration early is better than
+ * the known engines, since catching misconfiguration early is better than
  * silently falling back to the default.
  */
 export declare function getWorkflowVmFromEnv(env?: NodeJS.ProcessEnv): WorkflowVmMode | undefined;

package/dist/runtime/vm-mode.js

@@ -23,7 +23,7 @@ export const WORKFLOW_VMS = ['node', 'quickjs'];
  *
  * Returns the configured engine, or `undefined` if unset/empty.
  * Throws {@link WorkflowRuntimeError} if the value is set but not one of
- * the known engines — catching misconfiguration early is better than
+ * the known engines, since catching misconfiguration early is better than
  * silently falling back to the default.
  */
 export function getWorkflowVmFromEnv(env = process.env) {
@@ -59,4 +59,4 @@ export function useQuickJSVm(workflowRun) {
     }
     return getWorkflowVmFromEnv() === 'quickjs';
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/wait-continuation.d.ts

@@ -10,7 +10,7 @@
  * The continuation is keyed on the wait's correlationId: while a wait is
  * pending, every replay pass over the run re-observes it (e.g., once per
  * step completion in `Promise.all([steps..., sleep()])`), and without
- * dedupe each pass would enqueue another delayed continuation — each one
+ * dedupe each pass would enqueue another delayed continuation: each one
  * a spurious full replay when the wait elapses, and each a fresh message
  * that resets the delivery-attempt runaway guard. A key is attached in
  * all cases: some worlds (e.g. world-postgres) serialize key-less
@@ -29,7 +29,7 @@
  * situations exist, each with its own key variation:
  *
  * - Waits longer than the maximum queue delay are chained: the delay is
- *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h — VQS messages
+ *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h: VQS messages
  *   have a 24h retention limit, and one hour of buffer matches
  *   world-vercel's own clamp for delayed re-enqueues), so the
  *   continuation intentionally fires early, re-observes the wait, and
@@ -37,7 +37,7 @@
  *   (`ceil(timeoutSeconds / maxDelay)`): stable for every re-observation
  *   within the same hop window (so passes dedupe), decremented at each
  *   hop delivery (so the chain always advances). Worlds without a delay
- *   limit (world-postgres, world-local) simply take the same ≤23h hops.
+ *   limit (world-postgres, world-local) take the same ≤23h hops.
  *
  * - Near-elapsed waits (≤2s remaining) get a second-bucketed suffix. A
  *   continuation delivered marginally early (clock skew between the
@@ -50,11 +50,25 @@
  * Mid-range waits (more than the near-elapsed threshold, at most one
  * hop) use the bare correlationId: every re-observation targets the same
  * deadline, so deduping to the first message is semantically lossless.
- * Host clock skew beyond the near-elapsed threshold could in principle
- * deliver such a continuation early enough to re-observe its wait and
- * lose the re-enqueue to the burnt key; the threshold is the skew
- * tolerance we accept for the benefit of exactly-one continuation per
- * wait.
+ *
+ * That last case used to be the one hole in the scheme, and it was not
+ * theoretical. Any delivery early enough to re-observe its own wait as
+ * pending burns the bare key on the way in: the re-enqueue is dropped by
+ * the dedupe window, nothing else is scheduled to wake the run, and no
+ * backstop exists for a wait the way inline step ownership provides one
+ * for a step. The run sleeps forever. Waits over the threshold have zero
+ * tolerance for it, which is why an infrastructure change in delivery
+ * timing was able to strand runs across every published SDK version at
+ * once, all of them keyed this way.
+ *
+ * So the key is no longer derived from the wait alone. A continuation
+ * carries the wait it was armed for and its attempt number
+ * ({@link WorkflowInvokePayload.waitContinuation}), and an invocation
+ * that recognizes itself as the continuation for a wait that is still
+ * pending arms the next one at `attempt + 1`. Attempts advance ONLY when
+ * an early delivery actually happens, so the normal path is untouched:
+ * attempt 0 keys exactly as before, and every re-observation within one
+ * attempt still collapses to a single message.
  */
 /**
  * Maximum `delaySeconds` for a single wait-continuation message. Waits
@@ -79,6 +93,14 @@ export interface WaitContinuationDispatch {
  * message. `timeoutSeconds` is the time until the wait's `resumeAt`
  * (floored at 1s by the suspension handler); `waitCorrelationId`
  * identifies the wait so repeated suspension passes dedupe.
+ *
+ * `attempt` is the number of continuations already spent on this wait, taken
+ * from the incoming message when this invocation IS one of them (see
+ * {@link WorkflowInvokePayload.waitContinuation}). It only ever moves when a
+ * continuation arrived before its wait elapsed, which is exactly when the
+ * previous key is spent and re-using it would drop the message. Attempt 0
+ * keys identically to the scheme before attempts existed, so the ordinary
+ * path — arm once, deliver once, complete — is byte-for-byte unchanged.
  */
-export declare function getWaitContinuationDispatch(timeoutSeconds: number, waitCorrelationId: string, now?: number): WaitContinuationDispatch;
+export declare function getWaitContinuationDispatch(timeoutSeconds: number, waitCorrelationId: string, now?: number, attempt?: number): WaitContinuationDispatch;
 //# sourceMappingURL=wait-continuation.d.ts.map

package/dist/runtime/wait-continuation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wait-continuation.d.ts","sourceRoot":"","sources":["../../src/runtime/wait-continuation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAIH;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC,QAAS,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC,IAAI,CAAC;AAiBrD,MAAM,WAAW,wBAAwB;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,MAAM,EACtB,iBAAiB,EAAE,MAAM,EACzB,GAAG,GAAE,MAAmB,GACvB,wBAAwB,CAyB1B"}
+{"version":3,"file":"wait-continuation.d.ts","sourceRoot":"","sources":["../../src/runtime/wait-continuation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAIH;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC,QAAS,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC,IAAI,CAAC;AAiBrD,MAAM,WAAW,wBAAwB;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,MAAM,EACtB,iBAAiB,EAAE,MAAM,EACzB,GAAG,GAAE,MAAmB,EACxB,OAAO,SAAI,GACV,wBAAwB,CAW1B"}

package/dist/runtime/wait-continuation.js

@@ -10,7 +10,7 @@
  * The continuation is keyed on the wait's correlationId: while a wait is
  * pending, every replay pass over the run re-observes it (e.g., once per
  * step completion in `Promise.all([steps..., sleep()])`), and without
- * dedupe each pass would enqueue another delayed continuation — each one
+ * dedupe each pass would enqueue another delayed continuation: each one
  * a spurious full replay when the wait elapses, and each a fresh message
  * that resets the delivery-attempt runaway guard. A key is attached in
  * all cases: some worlds (e.g. world-postgres) serialize key-less
@@ -29,7 +29,7 @@
  * situations exist, each with its own key variation:
  *
  * - Waits longer than the maximum queue delay are chained: the delay is
- *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h — VQS messages
+ *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h: VQS messages
  *   have a 24h retention limit, and one hour of buffer matches
  *   world-vercel's own clamp for delayed re-enqueues), so the
  *   continuation intentionally fires early, re-observes the wait, and
@@ -37,7 +37,7 @@
  *   (`ceil(timeoutSeconds / maxDelay)`): stable for every re-observation
  *   within the same hop window (so passes dedupe), decremented at each
  *   hop delivery (so the chain always advances). Worlds without a delay
- *   limit (world-postgres, world-local) simply take the same ≤23h hops.
+ *   limit (world-postgres, world-local) take the same ≤23h hops.
  *
  * - Near-elapsed waits (≤2s remaining) get a second-bucketed suffix. A
  *   continuation delivered marginally early (clock skew between the
@@ -50,11 +50,25 @@
  * Mid-range waits (more than the near-elapsed threshold, at most one
  * hop) use the bare correlationId: every re-observation targets the same
  * deadline, so deduping to the first message is semantically lossless.
- * Host clock skew beyond the near-elapsed threshold could in principle
- * deliver such a continuation early enough to re-observe its wait and
- * lose the re-enqueue to the burnt key; the threshold is the skew
- * tolerance we accept for the benefit of exactly-one continuation per
- * wait.
+ *
+ * That last case used to be the one hole in the scheme, and it was not
+ * theoretical. Any delivery early enough to re-observe its own wait as
+ * pending burns the bare key on the way in: the re-enqueue is dropped by
+ * the dedupe window, nothing else is scheduled to wake the run, and no
+ * backstop exists for a wait the way inline step ownership provides one
+ * for a step. The run sleeps forever. Waits over the threshold have zero
+ * tolerance for it, which is why an infrastructure change in delivery
+ * timing was able to strand runs across every published SDK version at
+ * once, all of them keyed this way.
+ *
+ * So the key is no longer derived from the wait alone. A continuation
+ * carries the wait it was armed for and its attempt number
+ * ({@link WorkflowInvokePayload.waitContinuation}), and an invocation
+ * that recognizes itself as the continuation for a wait that is still
+ * pending arms the next one at `attempt + 1`. Attempts advance ONLY when
+ * an early delivery actually happens, so the normal path is untouched:
+ * attempt 0 keys exactly as before, and every re-observation within one
+ * attempt still collapses to a single message.
  */
 import { envNumber } from '@workflow/world';
 /**
@@ -80,15 +94,32 @@ const getNearElapsedWaitThresholdSeconds = () => envNumber('WORKFLOW_NEAR_ELAPSE
  * message. `timeoutSeconds` is the time until the wait's `resumeAt`
  * (floored at 1s by the suspension handler); `waitCorrelationId`
  * identifies the wait so repeated suspension passes dedupe.
+ *
+ * `attempt` is the number of continuations already spent on this wait, taken
+ * from the incoming message when this invocation IS one of them (see
+ * {@link WorkflowInvokePayload.waitContinuation}). It only ever moves when a
+ * continuation arrived before its wait elapsed, which is exactly when the
+ * previous key is spent and re-using it would drop the message. Attempt 0
+ * keys identically to the scheme before attempts existed, so the ordinary
+ * path — arm once, deliver once, complete — is byte-for-byte unchanged.
  */
-export function getWaitContinuationDispatch(timeoutSeconds, waitCorrelationId, now = Date.now()) {
+export function getWaitContinuationDispatch(timeoutSeconds, waitCorrelationId, now = Date.now(), attempt = 0) {
+    const dispatch = waitContinuationDispatchForAttemptZero(timeoutSeconds, waitCorrelationId, now);
+    if (attempt <= 0)
+        return dispatch;
+    return {
+        delaySeconds: dispatch.delaySeconds,
+        idempotencyKey: `${dispatch.idempotencyKey}:a${attempt}`,
+    };
+}
+function waitContinuationDispatchForAttemptZero(timeoutSeconds, waitCorrelationId, now) {
     const maxDelaySeconds = getWaitContinuationMaxDelaySeconds();
     // The near-elapsed branch returns the full remaining time as the delay, so
-    // its threshold can never exceed the max delay — otherwise a wait between the
+    // its threshold can never exceed the max delay. Otherwise a wait between the
     // max and the threshold would be dispatched with a delay above the max. Cap
     // the threshold at the max so every branch yields a delay within it. (With
-    // defaults — threshold 2s, max 82_800s — this is a no-op; it only bites when
-    // the max is tuned down below the threshold for testing.)
+    // defaults, threshold 2s and max 82_800s, this is a no-op; it only bites
+    // when the max is tuned down below the threshold for testing.)
     const nearElapsedThreshold = Math.min(getNearElapsedWaitThresholdSeconds(), maxDelaySeconds);
     if (timeoutSeconds <= nearElapsedThreshold) {
         return {
@@ -102,4 +133,4 @@ export function getWaitContinuationDispatch(timeoutSeconds, waitCorrelationId, n
         idempotencyKey: hop === 1 ? waitCorrelationId : `${waitCorrelationId}:hop-${hop}`,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wait-continuation.js","sourceRoot":"","sources":["../../src/runtime/wait-continuation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,MAAM,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,CAAC;AAErD,kGAAkG;AAClG,MAAM,kCAAkC,GAAG,GAAW,EAAE,CACtD,SAAS,CACP,8CAA8C,EAC9C,mCAAmC,EACnC,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,CAC1B,CAAC;AAEJ,kGAAkG;AAClG,MAAM,kCAAkC,GAAG,GAAW,EAAE,CACtD,SAAS,CACP,8CAA8C,EAC9C,mCAAmC,CACpC,CAAC;AAOJ;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B,CACzC,cAAsB,EACtB,iBAAyB,EACzB,MAAc,IAAI,CAAC,GAAG,EAAE;IAExB,MAAM,eAAe,GAAG,kCAAkC,EAAE,CAAC;IAC7D,2EAA2E;IAC3E,8EAA8E;IAC9E,4EAA4E;IAC5E,2EAA2E;IAC3E,6EAA6E;IAC7E,0DAA0D;IAC1D,MAAM,oBAAoB,GAAG,IAAI,CAAC,GAAG,CACnC,kCAAkC,EAAE,EACpC,eAAe,CAChB,CAAC;IACF,IAAI,cAAc,IAAI,oBAAoB,EAAE,CAAC;QAC3C,OAAO;YACL,YAAY,EAAE,cAAc;YAC5B,cAAc,EAAE,GAAG,iBAAiB,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,EAAE;SACjE,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,eAAe,CAAC,CAAC;IACxD,OAAO;QACL,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,eAAe,CAAC;QACvD,cAAc,EACZ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,iBAAiB,QAAQ,GAAG,EAAE;KACpE,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Wait-continuation dispatch: delay + idempotency-key selection.\n *\n * When V2 suspension processing observes a pending wait, it enqueues a\n * delayed \"continuation\" message that fires once the wait elapses and\n * drives the next replay (which completes the wait via the \"complete\n * elapsed waits\" pass). This module decides the message's `delaySeconds`\n * and `idempotencyKey`.\n *\n * The continuation is keyed on the wait's correlationId: while a wait is\n * pending, every replay pass over the run re-observes it (e.g., once per\n * step completion in `Promise.all([steps..., sleep()])`), and without\n * dedupe each pass would enqueue another delayed continuation — each one\n * a spurious full replay when the wait elapses, and each a fresh message\n * that resets the delivery-attempt runaway guard. A key is attached in\n * all cases: some worlds (e.g. world-postgres) serialize key-less\n * workflow messages per run, which would park the continuation behind\n * the handler's own inline step execution and defeat the race semantics\n * the continuation exists to provide.\n *\n * The bare correlationId cannot be the key in every case, though: world\n * dedupe windows outlive the first delivery (VQS keeps idempotency\n * records until message-retention TTL; world-postgres keeps a\n * completed-keys cache), so once a key has been used, a later enqueue\n * under the same key is silently dropped. Any situation where a\n * continuation is delivered while its wait is still pending therefore\n * needs a fresh key for the re-enqueue, or the wait's timer is lost and\n * the run stalls until unrelated traffic happens to wake it. Two such\n * situations exist, each with its own key variation:\n *\n * - Waits longer than the maximum queue delay are chained: the delay is\n *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h — VQS messages\n *   have a 24h retention limit, and one hour of buffer matches\n *   world-vercel's own clamp for delayed re-enqueues), so the\n *   continuation intentionally fires early, re-observes the wait, and\n *   must enqueue the next hop. The key is suffixed with the hop index\n *   (`ceil(timeoutSeconds / maxDelay)`): stable for every re-observation\n *   within the same hop window (so passes dedupe), decremented at each\n *   hop delivery (so the chain always advances). Worlds without a delay\n *   limit (world-postgres, world-local) simply take the same ≤23h hops.\n *\n * - Near-elapsed waits (≤2s remaining) get a second-bucketed suffix. A\n *   continuation delivered marginally early (clock skew between the\n *   enqueuing and handling hosts; the ceil() on the delay can leave a ~0\n *   margin) re-observes the wait as pending with ~1s remaining and must\n *   be able to enqueue a fresh short-delay retry. The bucket suffix\n *   keeps that retry enqueueable (its ≥1s delay guarantees a later\n *   bucket) while still collapsing same-instant duplicates.\n *\n * Mid-range waits (more than the near-elapsed threshold, at most one\n * hop) use the bare correlationId: every re-observation targets the same\n * deadline, so deduping to the first message is semantically lossless.\n * Host clock skew beyond the near-elapsed threshold could in principle\n * deliver such a continuation early enough to re-observe its wait and\n * lose the re-enqueue to the burnt key; the threshold is the skew\n * tolerance we accept for the benefit of exactly-one continuation per\n * wait.\n */\n\nimport { envNumber } from '@workflow/world';\n\n/**\n * Maximum `delaySeconds` for a single wait-continuation message. Waits\n * longer than this are chained across multiple hops. 23 hours leaves a 1h\n * buffer under Vercel Queues' default 24h message TTL and mirrors\n * world-vercel's `MAX_DELAY_SECONDS`.\n */\nexport const WAIT_CONTINUATION_MAX_DELAY_SECONDS = 82_800;\n\n/**\n * Waits with at most this many seconds remaining use a second-bucketed\n * idempotency key so an early-delivered continuation can re-enqueue its\n * short-delay retry. This is also the host clock-skew tolerance for\n * mid-range waits keyed on the bare correlationId.\n */\nexport const NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS = 2;\n\n/** Effective max continuation delay. Override: `WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS`. */\nconst getWaitContinuationMaxDelaySeconds = (): number =>\n  envNumber(\n    'WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS',\n    WAIT_CONTINUATION_MAX_DELAY_SECONDS,\n    { integer: true, min: 1 }\n  );\n\n/** Effective near-elapsed threshold. Override: `WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS`. */\nconst getNearElapsedWaitThresholdSeconds = (): number =>\n  envNumber(\n    'WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS',\n    NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS\n  );\n\nexport interface WaitContinuationDispatch {\n  delaySeconds: number;\n  idempotencyKey: string;\n}\n\n/**\n * Computes the queue delay and idempotency key for a wait-continuation\n * message. `timeoutSeconds` is the time until the wait's `resumeAt`\n * (floored at 1s by the suspension handler); `waitCorrelationId`\n * identifies the wait so repeated suspension passes dedupe.\n */\nexport function getWaitContinuationDispatch(\n  timeoutSeconds: number,\n  waitCorrelationId: string,\n  now: number = Date.now()\n): WaitContinuationDispatch {\n  const maxDelaySeconds = getWaitContinuationMaxDelaySeconds();\n  // The near-elapsed branch returns the full remaining time as the delay, so\n  // its threshold can never exceed the max delay — otherwise a wait between the\n  // max and the threshold would be dispatched with a delay above the max. Cap\n  // the threshold at the max so every branch yields a delay within it. (With\n  // defaults — threshold 2s, max 82_800s — this is a no-op; it only bites when\n  // the max is tuned down below the threshold for testing.)\n  const nearElapsedThreshold = Math.min(\n    getNearElapsedWaitThresholdSeconds(),\n    maxDelaySeconds\n  );\n  if (timeoutSeconds <= nearElapsedThreshold) {\n    return {\n      delaySeconds: timeoutSeconds,\n      idempotencyKey: `${waitCorrelationId}:${Math.floor(now / 1000)}`,\n    };\n  }\n\n  const hop = Math.ceil(timeoutSeconds / maxDelaySeconds);\n  return {\n    delaySeconds: Math.min(timeoutSeconds, maxDelaySeconds),\n    idempotencyKey:\n      hop === 1 ? waitCorrelationId : `${waitCorrelationId}:hop-${hop}`,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wait-continuation.js","sourceRoot":"","sources":["../../src/runtime/wait-continuation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,MAAM,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,CAAC;AAErD,kGAAkG;AAClG,MAAM,kCAAkC,GAAG,GAAW,EAAE,CACtD,SAAS,CACP,8CAA8C,EAC9C,mCAAmC,EACnC,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,CAC1B,CAAC;AAEJ,kGAAkG;AAClG,MAAM,kCAAkC,GAAG,GAAW,EAAE,CACtD,SAAS,CACP,8CAA8C,EAC9C,mCAAmC,CACpC,CAAC;AAOJ;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,2BAA2B,CACzC,cAAsB,EACtB,iBAAyB,EACzB,MAAc,IAAI,CAAC,GAAG,EAAE,EACxB,OAAO,GAAG,CAAC;IAEX,MAAM,QAAQ,GAAG,sCAAsC,CACrD,cAAc,EACd,iBAAiB,EACjB,GAAG,CACJ,CAAC;IACF,IAAI,OAAO,IAAI,CAAC;QAAE,OAAO,QAAQ,CAAC;IAClC,OAAO;QACL,YAAY,EAAE,QAAQ,CAAC,YAAY;QACnC,cAAc,EAAE,GAAG,QAAQ,CAAC,cAAc,KAAK,OAAO,EAAE;KACzD,CAAC;AACJ,CAAC;AAED,SAAS,sCAAsC,CAC7C,cAAsB,EACtB,iBAAyB,EACzB,GAAW;IAEX,MAAM,eAAe,GAAG,kCAAkC,EAAE,CAAC;IAC7D,2EAA2E;IAC3E,6EAA6E;IAC7E,4EAA4E;IAC5E,2EAA2E;IAC3E,yEAAyE;IACzE,+DAA+D;IAC/D,MAAM,oBAAoB,GAAG,IAAI,CAAC,GAAG,CACnC,kCAAkC,EAAE,EACpC,eAAe,CAChB,CAAC;IACF,IAAI,cAAc,IAAI,oBAAoB,EAAE,CAAC;QAC3C,OAAO;YACL,YAAY,EAAE,cAAc;YAC5B,cAAc,EAAE,GAAG,iBAAiB,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,EAAE;SACjE,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,eAAe,CAAC,CAAC;IACxD,OAAO;QACL,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,eAAe,CAAC;QACvD,cAAc,EACZ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,iBAAiB,QAAQ,GAAG,EAAE;KACpE,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Wait-continuation dispatch: delay + idempotency-key selection.\n *\n * When V2 suspension processing observes a pending wait, it enqueues a\n * delayed \"continuation\" message that fires once the wait elapses and\n * drives the next replay (which completes the wait via the \"complete\n * elapsed waits\" pass). This module decides the message's `delaySeconds`\n * and `idempotencyKey`.\n *\n * The continuation is keyed on the wait's correlationId: while a wait is\n * pending, every replay pass over the run re-observes it (e.g., once per\n * step completion in `Promise.all([steps..., sleep()])`), and without\n * dedupe each pass would enqueue another delayed continuation: each one\n * a spurious full replay when the wait elapses, and each a fresh message\n * that resets the delivery-attempt runaway guard. A key is attached in\n * all cases: some worlds (e.g. world-postgres) serialize key-less\n * workflow messages per run, which would park the continuation behind\n * the handler's own inline step execution and defeat the race semantics\n * the continuation exists to provide.\n *\n * The bare correlationId cannot be the key in every case, though: world\n * dedupe windows outlive the first delivery (VQS keeps idempotency\n * records until message-retention TTL; world-postgres keeps a\n * completed-keys cache), so once a key has been used, a later enqueue\n * under the same key is silently dropped. Any situation where a\n * continuation is delivered while its wait is still pending therefore\n * needs a fresh key for the re-enqueue, or the wait's timer is lost and\n * the run stalls until unrelated traffic happens to wake it. Two such\n * situations exist, each with its own key variation:\n *\n * - Waits longer than the maximum queue delay are chained: the delay is\n *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h: VQS messages\n *   have a 24h retention limit, and one hour of buffer matches\n *   world-vercel's own clamp for delayed re-enqueues), so the\n *   continuation intentionally fires early, re-observes the wait, and\n *   must enqueue the next hop. The key is suffixed with the hop index\n *   (`ceil(timeoutSeconds / maxDelay)`): stable for every re-observation\n *   within the same hop window (so passes dedupe), decremented at each\n *   hop delivery (so the chain always advances). Worlds without a delay\n *   limit (world-postgres, world-local) take the same ≤23h hops.\n *\n * - Near-elapsed waits (≤2s remaining) get a second-bucketed suffix. A\n *   continuation delivered marginally early (clock skew between the\n *   enqueuing and handling hosts; the ceil() on the delay can leave a ~0\n *   margin) re-observes the wait as pending with ~1s remaining and must\n *   be able to enqueue a fresh short-delay retry. The bucket suffix\n *   keeps that retry enqueueable (its ≥1s delay guarantees a later\n *   bucket) while still collapsing same-instant duplicates.\n *\n * Mid-range waits (more than the near-elapsed threshold, at most one\n * hop) use the bare correlationId: every re-observation targets the same\n * deadline, so deduping to the first message is semantically lossless.\n *\n * That last case used to be the one hole in the scheme, and it was not\n * theoretical. Any delivery early enough to re-observe its own wait as\n * pending burns the bare key on the way in: the re-enqueue is dropped by\n * the dedupe window, nothing else is scheduled to wake the run, and no\n * backstop exists for a wait the way inline step ownership provides one\n * for a step. The run sleeps forever. Waits over the threshold have zero\n * tolerance for it, which is why an infrastructure change in delivery\n * timing was able to strand runs across every published SDK version at\n * once, all of them keyed this way.\n *\n * So the key is no longer derived from the wait alone. A continuation\n * carries the wait it was armed for and its attempt number\n * ({@link WorkflowInvokePayload.waitContinuation}), and an invocation\n * that recognizes itself as the continuation for a wait that is still\n * pending arms the next one at `attempt + 1`. Attempts advance ONLY when\n * an early delivery actually happens, so the normal path is untouched:\n * attempt 0 keys exactly as before, and every re-observation within one\n * attempt still collapses to a single message.\n */\n\nimport { envNumber } from '@workflow/world';\n\n/**\n * Maximum `delaySeconds` for a single wait-continuation message. Waits\n * longer than this are chained across multiple hops. 23 hours leaves a 1h\n * buffer under Vercel Queues' default 24h message TTL and mirrors\n * world-vercel's `MAX_DELAY_SECONDS`.\n */\nexport const WAIT_CONTINUATION_MAX_DELAY_SECONDS = 82_800;\n\n/**\n * Waits with at most this many seconds remaining use a second-bucketed\n * idempotency key so an early-delivered continuation can re-enqueue its\n * short-delay retry. This is also the host clock-skew tolerance for\n * mid-range waits keyed on the bare correlationId.\n */\nexport const NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS = 2;\n\n/** Effective max continuation delay. Override: `WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS`. */\nconst getWaitContinuationMaxDelaySeconds = (): number =>\n  envNumber(\n    'WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS',\n    WAIT_CONTINUATION_MAX_DELAY_SECONDS,\n    { integer: true, min: 1 }\n  );\n\n/** Effective near-elapsed threshold. Override: `WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS`. */\nconst getNearElapsedWaitThresholdSeconds = (): number =>\n  envNumber(\n    'WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS',\n    NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS\n  );\n\nexport interface WaitContinuationDispatch {\n  delaySeconds: number;\n  idempotencyKey: string;\n}\n\n/**\n * Computes the queue delay and idempotency key for a wait-continuation\n * message. `timeoutSeconds` is the time until the wait's `resumeAt`\n * (floored at 1s by the suspension handler); `waitCorrelationId`\n * identifies the wait so repeated suspension passes dedupe.\n *\n * `attempt` is the number of continuations already spent on this wait, taken\n * from the incoming message when this invocation IS one of them (see\n * {@link WorkflowInvokePayload.waitContinuation}). It only ever moves when a\n * continuation arrived before its wait elapsed, which is exactly when the\n * previous key is spent and re-using it would drop the message. Attempt 0\n * keys identically to the scheme before attempts existed, so the ordinary\n * path — arm once, deliver once, complete — is byte-for-byte unchanged.\n */\nexport function getWaitContinuationDispatch(\n  timeoutSeconds: number,\n  waitCorrelationId: string,\n  now: number = Date.now(),\n  attempt = 0\n): WaitContinuationDispatch {\n  const dispatch = waitContinuationDispatchForAttemptZero(\n    timeoutSeconds,\n    waitCorrelationId,\n    now\n  );\n  if (attempt <= 0) return dispatch;\n  return {\n    delaySeconds: dispatch.delaySeconds,\n    idempotencyKey: `${dispatch.idempotencyKey}:a${attempt}`,\n  };\n}\n\nfunction waitContinuationDispatchForAttemptZero(\n  timeoutSeconds: number,\n  waitCorrelationId: string,\n  now: number\n): WaitContinuationDispatch {\n  const maxDelaySeconds = getWaitContinuationMaxDelaySeconds();\n  // The near-elapsed branch returns the full remaining time as the delay, so\n  // its threshold can never exceed the max delay. Otherwise a wait between the\n  // max and the threshold would be dispatched with a delay above the max. Cap\n  // the threshold at the max so every branch yields a delay within it. (With\n  // defaults, threshold 2s and max 82_800s, this is a no-op; it only bites\n  // when the max is tuned down below the threshold for testing.)\n  const nearElapsedThreshold = Math.min(\n    getNearElapsedWaitThresholdSeconds(),\n    maxDelaySeconds\n  );\n  if (timeoutSeconds <= nearElapsedThreshold) {\n    return {\n      delaySeconds: timeoutSeconds,\n      idempotencyKey: `${waitCorrelationId}:${Math.floor(now / 1000)}`,\n    };\n  }\n\n  const hop = Math.ceil(timeoutSeconds / maxDelaySeconds);\n  return {\n    delaySeconds: Math.min(timeoutSeconds, maxDelaySeconds),\n    idempotencyKey:\n      hop === 1 ? waitCorrelationId : `${waitCorrelationId}:hop-${hop}`,\n  };\n}\n"]}

package/dist/runtime/wait-until.d.ts

@@ -3,7 +3,7 @@ export declare function waitUntil(promise: Promise<unknown>): void;
  * Schedule a background promise via `waitUntil`, guaranteeing that the
  * promise handed to `waitUntil` can never reject. Nothing consumes a
  * `waitUntil` promise, so a rejection surfaces as an `unhandledRejection`
- * and can crash the process — even when the same underlying error is
+ * and can crash the process, even when the same underlying error is
  * correctly handled by an awaited copy elsewhere.
  *
  * Expected client-disconnect errors (`AbortError` / `ResponseAborted`)

package/dist/runtime/wait-until.js

@@ -7,7 +7,7 @@ export function waitUntil(promise) {
  * Schedule a background promise via `waitUntil`, guaranteeing that the
  * promise handed to `waitUntil` can never reject. Nothing consumes a
  * `waitUntil` promise, so a rejection surfaces as an `unhandledRejection`
- * and can crash the process — even when the same underlying error is
+ * and can crash the process, even when the same underlying error is
  * correctly handled by an awaited copy elsewhere.
  *
  * Expected client-disconnect errors (`AbortError` / `ResponseAborted`)
@@ -39,4 +39,4 @@ export async function waitedUntil(fn) {
     }));
     return result;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FpdC11bnRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydW50aW1lL3dhaXQtdW50aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLFNBQVMsQ0FBQyxPQUF5QjtJQUNqRCxLQUFLLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUUsU0FBUyxFQUFFLEVBQUUsRUFBRTtRQUN0RCxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDckIsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQ7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FDM0IsT0FBeUIsRUFDekIsT0FBK0I7SUFFL0IsU0FBUyxDQUNQLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtRQUNwQixNQUFNLFlBQVksR0FDaEIsR0FBRyxFQUFFLElBQUksS0FBSyxZQUFZLElBQUksR0FBRyxFQUFFLElBQUksS0FBSyxpQkFBaUIsQ0FBQztRQUNoRSxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7WUFDbEIsSUFBSSxDQUFDO2dCQUNILE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUNmLENBQUM7WUFBQyxNQUFNLENBQUM7Z0JBQ1AsbURBQW1EO1lBQ3JELENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQyxDQUFDLENBQ0gsQ0FBQztBQUNKLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFdBQVcsQ0FBSSxFQUFvQjtJQUN2RCxNQUFNLE1BQU0sR0FBRyxFQUFFLEVBQUUsQ0FBQztJQUNwQixTQUFTLENBQ1AsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUU7UUFDaEIsZ0RBQWdEO1FBQ2hELGtEQUFrRDtRQUNsRCx5QkFBeUI7SUFDM0IsQ0FBQyxDQUFDLENBQ0gsQ0FBQztJQUNGLE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gd2FpdFVudGlsKHByb21pc2U6IFByb21pc2U8dW5rbm93bj4pOiB2b2lkIHtcbiAgdm9pZCBpbXBvcnQoJ0B2ZXJjZWwvZnVuY3Rpb25zJykudGhlbigoeyB3YWl0VW50aWwgfSkgPT4ge1xuICAgIHdhaXRVbnRpbChwcm9taXNlKTtcbiAgfSk7XG59XG5cbi8qKlxuICogU2NoZWR1bGUgYSBiYWNrZ3JvdW5kIHByb21pc2UgdmlhIGB3YWl0VW50aWxgLCBndWFyYW50ZWVpbmcgdGhhdCB0aGVcbiAqIHByb21pc2UgaGFuZGVkIHRvIGB3YWl0VW50aWxgIGNhbiBuZXZlciByZWplY3QuIE5vdGhpbmcgY29uc3VtZXMgYVxuICogYHdhaXRVbnRpbGAgcHJvbWlzZSwgc28gYSByZWplY3Rpb24gc3VyZmFjZXMgYXMgYW4gYHVuaGFuZGxlZFJlamVjdGlvbmBcbiAqIGFuZCBjYW4gY3Jhc2ggdGhlIHByb2Nlc3MsIGV2ZW4gd2hlbiB0aGUgc2FtZSB1bmRlcmx5aW5nIGVycm9yIGlzXG4gKiBjb3JyZWN0bHkgaGFuZGxlZCBieSBhbiBhd2FpdGVkIGNvcHkgZWxzZXdoZXJlLlxuICpcbiAqIEV4cGVjdGVkIGNsaWVudC1kaXNjb25uZWN0IGVycm9ycyAoYEFib3J0RXJyb3JgIC8gYFJlc3BvbnNlQWJvcnRlZGApXG4gKiBhcmUgaWdub3JlZC4gQW55IG90aGVyIGVycm9yIGlzIHBhc3NlZCB0byBgb25FcnJvcmAgYW5kIHN3YWxsb3dlZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNhZmVXYWl0VW50aWwoXG4gIHByb21pc2U6IFByb21pc2U8dW5rbm93bj4sXG4gIG9uRXJyb3I6IChlcnI6IHVua25vd24pID0+IHZvaWRcbik6IHZvaWQge1xuICB3YWl0VW50aWwoXG4gICAgcHJvbWlzZS5jYXRjaCgoZXJyKSA9PiB7XG4gICAgICBjb25zdCBpc0Fib3J0RXJyb3IgPVxuICAgICAgICBlcnI/Lm5hbWUgPT09ICdBYm9ydEVycm9yJyB8fCBlcnI/Lm5hbWUgPT09ICdSZXNwb25zZUFib3J0ZWQnO1xuICAgICAgaWYgKCFpc0Fib3J0RXJyb3IpIHtcbiAgICAgICAgdHJ5IHtcbiAgICAgICAgICBvbkVycm9yKGVycik7XG4gICAgICAgIH0gY2F0Y2gge1xuICAgICAgICAgIC8vIE5ldmVyIGxldCBvbkVycm9yIGJyZWFrIHRoZSBuby1yZWplY3QgZ3VhcmFudGVlLlxuICAgICAgICB9XG4gICAgICB9XG4gICAgfSlcbiAgKTtcbn1cblxuLyoqXG4gKiBBIHNtYWxsIHdyYXBwZXIgYXJvdW5kIGB3YWl0VW50aWxgIHRoYXQgYWxzbyByZXR1cm5zXG4gKiB0aGUgcmVzdWx0IG9mIHRoZSBhd2FpdGVkIHByb21pc2UuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB3YWl0ZWRVbnRpbDxUPihmbjogKCkgPT4gUHJvbWlzZTxUPik6IFByb21pc2U8VD4ge1xuICBjb25zdCByZXN1bHQgPSBmbigpO1xuICB3YWl0VW50aWwoXG4gICAgcmVzdWx0LmNhdGNoKCgpID0+IHtcbiAgICAgIC8vIElnbm9yZSBlcnJvciBmcm9tIHRoZSBwcm9taXNlIGJlaW5nIHJlamVjdGVkLlxuICAgICAgLy8gSXQncyBleHBlY3RlZCB0aGF0IHRoZSBpbnZva2VyIG9mIGB3YWl0ZWRVbnRpbGBcbiAgICAgIC8vIHdpbGwgaGFuZGxlIHRoZSBlcnJvci5cbiAgICB9KVxuICApO1xuICByZXR1cm4gcmVzdWx0O1xufVxuIl19

package/dist/runtime/world-compatibility.d.ts

@@ -3,18 +3,29 @@ type WorldSpecVersionMetadata = Pick<World, 'specVersion'>;
 /**
  * Rejects a World this runtime cannot speak to.
  *
- * The accepted range is `[SPEC_VERSION_CURRENT, SPEC_VERSION_MAX_SUPPORTED]`.
- * Below the current version means an old World package paired with a new
- * runtime, which cannot serve the protocol this runtime speaks. Above the
+ * The accepted range is
+ * `[SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, SPEC_VERSION_MAX_SUPPORTED]`. Below
+ * the floor means an old World package paired with a new runtime, which cannot
+ * serve the protocol this runtime speaks. A World that does not number events
+ * by position allocates ids the runtime cannot read positions out of. Above the
  * ceiling means a World built against a newer spec than this runtime knows how
  * to read.
  *
- * Both bounds are the same version today, so this currently admits exactly one.
- * It stays written as a range because the two constants answer different
- * questions and come apart while a spec bump is staged: the ceiling rises when
- * this runtime learns to read the next version, the floor when that version
- * becomes the one Worlds stamp. An equality check against either constant alone
- * would reject a World during that window.
+ * The floor is deliberately the slot-identity version rather than
+ * `SPEC_VERSION_CURRENT`, which now sits one above it at the sealed log. Two
+ * reasons, and both are about the window a spec bump is staged over:
+ *
+ * - `WORKFLOW_SEALED_LOG=0` puts a deployment back on slot identity, so its
+ *   World declares the lower version. Flooring at the version we stamp by
+ *   default would make that kill switch reject the very World it selects,
+ *   turning a rollback into a startup failure.
+ * - A World package one version behind the runtime it ships alongside is the
+ *   normal state mid-bump, and it can still serve the protocol: slot identity
+ *   is what the runtime actually requires, and sealed logs are a capability on
+ *   top of it that only the backend implements.
+ *
+ * The range narrows again when the sealed log becomes mandatory and the flag
+ * goes away, exactly as slot identity's own floor did.
  */
 export declare function assertWorldSupportsRuntimeProtocol(world: WorldSpecVersionMetadata): void;
 export {};

package/dist/runtime/world-compatibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"world-compatibility.d.ts","sourceRoot":"","sources":["../../src/runtime/world-compatibility.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAM7C,KAAK,wBAAwB,GAAG,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,wBAAwB,GAC9B,IAAI,CAkBN"}
+{"version":3,"file":"world-compatibility.d.ts","sourceRoot":"","sources":["../../src/runtime/world-compatibility.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAM7C,KAAK,wBAAwB,GAAG,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,wBAAwB,GAC9B,IAAI,CAkBN"}

package/dist/runtime/world-compatibility.js

@@ -1,33 +1,44 @@
 import { WorkflowRuntimeError } from '@workflow/errors';
-import { SPEC_VERSION_CURRENT, SPEC_VERSION_MAX_SUPPORTED, } from '@workflow/world';
+import { SPEC_VERSION_MAX_SUPPORTED, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, } from '@workflow/world';
 /**
  * Rejects a World this runtime cannot speak to.
  *
- * The accepted range is `[SPEC_VERSION_CURRENT, SPEC_VERSION_MAX_SUPPORTED]`.
- * Below the current version means an old World package paired with a new
- * runtime, which cannot serve the protocol this runtime speaks. Above the
+ * The accepted range is
+ * `[SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, SPEC_VERSION_MAX_SUPPORTED]`. Below
+ * the floor means an old World package paired with a new runtime, which cannot
+ * serve the protocol this runtime speaks. A World that does not number events
+ * by position allocates ids the runtime cannot read positions out of. Above the
  * ceiling means a World built against a newer spec than this runtime knows how
  * to read.
  *
- * Both bounds are the same version today, so this currently admits exactly one.
- * It stays written as a range because the two constants answer different
- * questions and come apart while a spec bump is staged: the ceiling rises when
- * this runtime learns to read the next version, the floor when that version
- * becomes the one Worlds stamp. An equality check against either constant alone
- * would reject a World during that window.
+ * The floor is deliberately the slot-identity version rather than
+ * `SPEC_VERSION_CURRENT`, which now sits one above it at the sealed log. Two
+ * reasons, and both are about the window a spec bump is staged over:
+ *
+ * - `WORKFLOW_SEALED_LOG=0` puts a deployment back on slot identity, so its
+ *   World declares the lower version. Flooring at the version we stamp by
+ *   default would make that kill switch reject the very World it selects,
+ *   turning a rollback into a startup failure.
+ * - A World package one version behind the runtime it ships alongside is the
+ *   normal state mid-bump, and it can still serve the protocol: slot identity
+ *   is what the runtime actually requires, and sealed logs are a capability on
+ *   top of it that only the backend implements.
+ *
+ * The range narrows again when the sealed log becomes mandatory and the flag
+ * goes away, exactly as slot identity's own floor did.
  */
 export function assertWorldSupportsRuntimeProtocol(world) {
     const declared = world.specVersion;
     if (declared !== undefined &&
         declared !== null &&
-        declared >= SPEC_VERSION_CURRENT &&
+        declared >= SPEC_VERSION_SUPPORTS_SLOT_IDENTITY &&
         declared <= SPEC_VERSION_MAX_SUPPORTED) {
         return;
     }
     const supportedVersion = declared ?? 'none';
-    throw new WorkflowRuntimeError(`This Workflow runtime supports Worlds with spec version ${SPEC_VERSION_CURRENT} ` +
+    throw new WorkflowRuntimeError(`This Workflow runtime supports Worlds with spec version ${SPEC_VERSION_SUPPORTS_SLOT_IDENTITY} ` +
         `through ${SPEC_VERSION_MAX_SUPPORTED}, ` +
         `but the configured World declares spec version ${supportedVersion}. ` +
         'Install a World package version compatible with the current Workflow runtime.');
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/world-init.d.ts

@@ -1,15 +1,15 @@
 /**
  * Server-only side-effect module that ensures `world.ts` is loaded so its
- * module-load side effect — `globalThis[GetWorldFnKey] ??= getWorld` —
+ * module-load side effect (`globalThis[GetWorldFnKey] ??= getWorld`)
  * fires in host bundles.
  *
  * # Why this exists
  *
  * `getWorldLazy()` in `./get-world-lazy.ts` checks the globalThis cache
  * populated by `world.ts`'s module-load side effect. When a server route
- * only consumes a helper that goes through `getWorldLazy` — for example
- * `start` from `workflow/api`, or `defineHook().resume()` from `workflow`
- * — webpack/turbopack can tree-shake the named import `{ getWorld }` out
+ * only consumes a helper that goes through `getWorldLazy` (for example
+ * `start` from `workflow/api`, or `defineHook().resume()` from `workflow`),
+ * webpack/turbopack can tree-shake the named import `{ getWorld }` out
  * of `runtime.ts`, taking `world.ts`'s module evaluation with it. The
  * globalThis registration never fires.
  *
@@ -41,7 +41,7 @@
  *
  * If you add another `getWorldLazy()` consumer that's reachable from a
  * host route without going through `workflow` or `workflow/api`, make
- * sure that entry also imports this module — or that it transitively
+ * sure that entry also imports this module, or that it transitively
  * reaches `world.ts` via a non-tree-shakeable path. Adding a regression
  * test in `world-init.test.ts` is preferred to relying on careful manual
  * tracing.