@workflow/core 5.0.0-beta.19 → 5.0.0-beta.20

package/dist/runtime/constants.js

@@ -102,8 +102,86 @@ export function _resetReplayTimeoutWarnCacheForTests() {
 // handler exits without writing run_failed so the queue retries the message.
 // On the next attempt the run is marked as failed.
 export const REPLAY_TIMEOUT_MAX_RETRIES = 3;
+/**
+ * Default maximum number of steps the owned-inline path runs inline (in
+ * parallel) per suspension. The rest are queued to background handlers. Each
+ * inline step is created lazily — its `step_created` is folded into the
+ * `step_started` that `executeStep` sends — so inlining N steps saves N queue
+ * round-trips for a `Promise.all`-style fan-out. `1` reproduces the
+ * single-inline-step behavior exactly (useful kill-switch).
+ *
+ * Override via `WORKFLOW_MAX_INLINE_STEPS` (clamped to
+ * `MIN_MAX_INLINE_STEPS`..`MAX_MAX_INLINE_STEPS`).
+ */
+export const MAX_INLINE_STEPS = 3;
+/** Lower bound for the inline-steps env override (1 = single inline step). */
+export const MIN_MAX_INLINE_STEPS = 1;
+/**
+ * Upper bound for the inline-steps env override. Inline bodies run in parallel
+ * within one function invocation, so this caps memory/CPU fan-out per handler.
+ */
+export const MAX_MAX_INLINE_STEPS = 16;
+// Warn-once cache for WORKFLOW_MAX_INLINE_STEPS, keyed by raw env value.
+const warnedMaxInlineStepsValues = new Set();
+/**
+ * Resolve the effective max number of inline steps for the current process.
+ *
+ * Reads `process.env.WORKFLOW_MAX_INLINE_STEPS` lazily so tests and
+ * deployments can override per invocation. Invalid / out-of-range values fall
+ * back to a safe value (no throw — the env var is an escape hatch) and emit a
+ * one-time warning so misconfiguration is observable.
+ */
+export function getMaxInlineSteps() {
+    const raw = process.env.WORKFLOW_MAX_INLINE_STEPS;
+    if (!raw)
+        return MAX_INLINE_STEPS;
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        if (!warnedMaxInlineStepsValues.has(raw)) {
+            warnedMaxInlineStepsValues.add(raw);
+            runtimeLogger.warn('Ignoring WORKFLOW_MAX_INLINE_STEPS: not a positive integer; using default', { raw, defaultValue: MAX_INLINE_STEPS });
+        }
+        return MAX_INLINE_STEPS;
+    }
+    if (parsed < MIN_MAX_INLINE_STEPS)
+        return MIN_MAX_INLINE_STEPS;
+    if (parsed > MAX_MAX_INLINE_STEPS) {
+        if (!warnedMaxInlineStepsValues.has(raw)) {
+            warnedMaxInlineStepsValues.add(raw);
+            runtimeLogger.warn('WORKFLOW_MAX_INLINE_STEPS above maximum; clamped', {
+                raw,
+                clampedValue: MAX_MAX_INLINE_STEPS,
+                maxValue: MAX_MAX_INLINE_STEPS,
+            });
+        }
+        return MAX_MAX_INLINE_STEPS;
+    }
+    return parsed;
+}
+/**
+ * Whether optimistic inline step start is enabled. When on, the owned-inline
+ * path begins running a brand-new step's body *before* its lazy `step_started`
+ * network call resolves (the input is already known locally), awaiting the
+ * `step_started` only before the terminal write.
+ *
+ * This can run a step body more than once when handlers race for the same
+ * step's create-claim — both run the body before one wins. That is unsafe for
+ * steps with non-idempotent side effects; in particular, two concurrent runs
+ * of a step that writes to the workflow stream (e.g. an AI agent streaming
+ * tokens) can interleave and corrupt the stream data. So the optimization is
+ * **off by default** and must be explicitly opted into per deployment.
+ *
+ * Reads `process.env.WORKFLOW_OPTIMISTIC_INLINE_START` lazily. Default OFF;
+ * enabled only by an explicit `'1'` / `'true'`.
+ */
+export function isOptimisticInlineStartEnabled() {
+    const raw = process.env.WORKFLOW_OPTIMISTIC_INLINE_START;
+    if (raw === undefined || raw === '')
+        return false;
+    return raw === '1' || raw.toLowerCase() === 'true';
+}
 // A replay-consumer mismatch can be caused by a transient divergent replay
 // rather than an invalid persisted history. Queue bounded recovery replays
 // before recording terminal corruption for a run that cannot replay.
 export const REPLAY_DIVERGENCE_MAX_RETRIES = 3;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,4EAA4E;AAC5E,4EAA4E;AAC5E,yEAAyE;AACzE,oDAAoD;AACpD,EAAE;AACF,kDAAkD;AAClD,2EAA2E;AAC3E,+DAA+D;AAC/D,wEAAwE;AACxE,EAAE;AACF,4EAA4E;AAC5E,qDAAqD;AACrD,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,OAAO,CAAC;AAEzC,2DAA2D;AAC3D,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,OAAO,CAAC;AAE7C,2EAA2E;AAC3E,2EAA2E;AAC3E,MAAM,yBAAyB,GAAG,IAAI,GAAG,EAAU,CAAC;AAEpD,SAAS,QAAQ,CACf,GAAW,EACX,OAAe,EACf,IAA6B;IAE7B,IAAI,yBAAyB,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO;IAC/C,yBAAyB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACnC,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC;IACnD,IAAI,CAAC,GAAG;QAAE,OAAO,iBAAiB,CAAC;IACnC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;QAC5C,QAAQ,CACN,GAAG,EACH,kFAAkF,EAClF,EAAE,GAAG,EAAE,SAAS,EAAE,iBAAiB,EAAE,CACtC,CAAC;QACF,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IACD,IAAI,MAAM,GAAG,qBAAqB,EAAE,CAAC;QACnC,QAAQ,CAAC,GAAG,EAAE,mDAAmD,EAAE;YACjE,GAAG;YACH,SAAS,EAAE,qBAAqB;YAChC,KAAK,EAAE,qBAAqB;SAC7B,CAAC,CAAC;QACH,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IACD,IAAI,MAAM,GAAG,qBAAqB,EAAE,CAAC;QACnC,QAAQ,CAAC,GAAG,EAAE,mDAAmD,EAAE;YACjE,GAAG;YACH,SAAS,EAAE,qBAAqB;YAChC,KAAK,EAAE,qBAAqB;SAC7B,CAAC,CAAC;QACH,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oCAAoC;IAClD,yBAAyB,CAAC,KAAK,EAAE,CAAC;AACpC,CAAC;AAED,8EAA8E;AAC9E,yEAAyE;AACzE,6EAA6E;AAC7E,mDAAmD;AACnD,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC;AAE5C,2EAA2E;AAC3E,2EAA2E;AAC3E,qEAAqE;AACrE,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC","sourcesContent":["import { runtimeLogger } from '../logger.js';\n\n// Maximum number of queue delivery attempts before the handler gives up and\n// gracefully fails the run/step. This must be bounded under the VQS message\n// max visibility window (24 hours) so that our handler-side failure path\n// reliably executes before VQS expires the message.\n//\n// VQS retry schedule (with retryAfterSeconds: 5):\n//   Attempts 1–32:  linear backoff at 5s each  → 32 × 5s = 160s (~2.7 min)\n//   Attempts 33+:   exponential backoff: 60s × 2^(attempt-32),\n//                   capped at 7,200s (2h), floored at retryAfterSeconds\n//\n// At 48 attempts the total elapsed time is approximately 20 hours, which is\n// safely under the 24-hour message visibility limit.\nexport const MAX_QUEUE_DELIVERIES = 48;\n\n/**\n * Default maximum time allowed for the *replay* portion of a single workflow\n * handler invocation (in ms). This budget only covers deterministic-replay\n * and workflow-VM execution between step boundaries — inline step bodies\n * (`\"use step\"` functions invoked via `executeStep`) do NOT count against\n * it. Step bodies are bounded separately by the platform's function\n * `maxDuration` (e.g. 800s on Vercel Pro Fluid) and `NO_INLINE_REPLAY_AFTER_MS`.\n *\n * If the non-step (\"replay\") time within a single invocation exceeds this\n * budget, the handler exits so the queue can retry. After\n * `REPLAY_TIMEOUT_MAX_RETRIES` exhausted attempts the run is failed with\n * `RUN_ERROR_CODES.REPLAY_TIMEOUT`.\n *\n * Note that on Vercel Hobby (standard functions), the platform `maxDuration`\n * is 60s — well below this budget, so the platform SIGTERM will fire first\n * and the queue will re-deliver until the visibility window expires. With\n * Fluid Compute on Hobby the per-function ceiling rises to 300s, still\n * under the default budget.\n *\n * Override via the `WORKFLOW_REPLAY_TIMEOUT_MS` env var (clamped to\n * `MIN_REPLAY_TIMEOUT_MS`..`MAX_REPLAY_TIMEOUT_MS`).\n */\nexport const REPLAY_TIMEOUT_MS = 240_000;\n\n/** Lower bound for the replay-timeout env var override. */\nexport const MIN_REPLAY_TIMEOUT_MS = 30_000;\n\n/**\n * Upper bound for the replay-timeout env var override. 780s leaves ≥20s of\n * headroom under Vercel Pro Fluid's 800s function ceiling so the handler\n * can write `run_failed` before SIGTERM.\n */\nexport const MAX_REPLAY_TIMEOUT_MS = 780_000;\n\n// Track which raw env var values we've already warned about so the warning\n// log only fires once per process (the function may be called many times).\nconst warnedReplayTimeoutValues = new Set<string>();\n\nfunction warnOnce(\n  raw: string,\n  message: string,\n  data: Record<string, unknown>\n): void {\n  if (warnedReplayTimeoutValues.has(raw)) return;\n  warnedReplayTimeoutValues.add(raw);\n  runtimeLogger.warn(message, data);\n}\n\n/**\n * Resolve the effective replay-timeout budget for the current process.\n *\n * Reads `process.env.WORKFLOW_REPLAY_TIMEOUT_MS` lazily so tests and\n * deployments can override per invocation. Invalid / out-of-range values\n * fall back to a safe value (no throw — the env var is an escape hatch,\n * not a hard requirement) and emit a one-time warning so misconfiguration\n * is observable.\n */\nexport function getReplayTimeoutMs(): number {\n  const raw = process.env.WORKFLOW_REPLAY_TIMEOUT_MS;\n  if (!raw) return REPLAY_TIMEOUT_MS;\n  const parsed = Number(raw);\n  if (!Number.isFinite(parsed) || parsed <= 0) {\n    warnOnce(\n      raw,\n      'Ignoring WORKFLOW_REPLAY_TIMEOUT_MS: not a positive finite number; using default',\n      { raw, defaultMs: REPLAY_TIMEOUT_MS }\n    );\n    return REPLAY_TIMEOUT_MS;\n  }\n  if (parsed < MIN_REPLAY_TIMEOUT_MS) {\n    warnOnce(raw, 'WORKFLOW_REPLAY_TIMEOUT_MS below minimum; clamped', {\n      raw,\n      clampedMs: MIN_REPLAY_TIMEOUT_MS,\n      minMs: MIN_REPLAY_TIMEOUT_MS,\n    });\n    return MIN_REPLAY_TIMEOUT_MS;\n  }\n  if (parsed > MAX_REPLAY_TIMEOUT_MS) {\n    warnOnce(raw, 'WORKFLOW_REPLAY_TIMEOUT_MS above maximum; clamped', {\n      raw,\n      clampedMs: MAX_REPLAY_TIMEOUT_MS,\n      maxMs: MAX_REPLAY_TIMEOUT_MS,\n    });\n    return MAX_REPLAY_TIMEOUT_MS;\n  }\n  return parsed;\n}\n\n/**\n * Reset the warn-once cache. Test-only — exported so unit tests can\n * exercise the warn path repeatedly without sharing state.\n *\n * @internal\n */\nexport function _resetReplayTimeoutWarnCacheForTests(): void {\n  warnedReplayTimeoutValues.clear();\n}\n\n// Number of queue delivery attempts to allow before permanently failing a run\n// due to a replay timeout. On attempts 1 through this value, the timeout\n// handler exits without writing run_failed so the queue retries the message.\n// On the next attempt the run is marked as failed.\nexport const REPLAY_TIMEOUT_MAX_RETRIES = 3;\n\n// A replay-consumer mismatch can be caused by a transient divergent replay\n// rather than an invalid persisted history. Queue bounded recovery replays\n// before recording terminal corruption for a run that cannot replay.\nexport const REPLAY_DIVERGENCE_MAX_RETRIES = 3;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,4EAA4E;AAC5E,4EAA4E;AAC5E,yEAAyE;AACzE,oDAAoD;AACpD,EAAE;AACF,kDAAkD;AAClD,2EAA2E;AAC3E,+DAA+D;AAC/D,wEAAwE;AACxE,EAAE;AACF,4EAA4E;AAC5E,qDAAqD;AACrD,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,OAAO,CAAC;AAEzC,2DAA2D;AAC3D,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,OAAO,CAAC;AAE7C,2EAA2E;AAC3E,2EAA2E;AAC3E,MAAM,yBAAyB,GAAG,IAAI,GAAG,EAAU,CAAC;AAEpD,SAAS,QAAQ,CACf,GAAW,EACX,OAAe,EACf,IAA6B;IAE7B,IAAI,yBAAyB,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO;IAC/C,yBAAyB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACnC,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC;IACnD,IAAI,CAAC,GAAG;QAAE,OAAO,iBAAiB,CAAC;IACnC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;QAC5C,QAAQ,CACN,GAAG,EACH,kFAAkF,EAClF,EAAE,GAAG,EAAE,SAAS,EAAE,iBAAiB,EAAE,CACtC,CAAC;QACF,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IACD,IAAI,MAAM,GAAG,qBAAqB,EAAE,CAAC;QACnC,QAAQ,CAAC,GAAG,EAAE,mDAAmD,EAAE;YACjE,GAAG;YACH,SAAS,EAAE,qBAAqB;YAChC,KAAK,EAAE,qBAAqB;SAC7B,CAAC,CAAC;QACH,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IACD,IAAI,MAAM,GAAG,qBAAqB,EAAE,CAAC;QACnC,QAAQ,CAAC,GAAG,EAAE,mDAAmD,EAAE;YACjE,GAAG;YACH,SAAS,EAAE,qBAAqB;YAChC,KAAK,EAAE,qBAAqB;SAC7B,CAAC,CAAC;QACH,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oCAAoC;IAClD,yBAAyB,CAAC,KAAK,EAAE,CAAC;AACpC,CAAC;AAED,8EAA8E;AAC9E,yEAAyE;AACzE,6EAA6E;AAC7E,mDAAmD;AACnD,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC;AAElC,8EAA8E;AAC9E,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAEtC;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEvC,yEAAyE;AACzE,MAAM,0BAA0B,GAAG,IAAI,GAAG,EAAU,CAAC;AAErD;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB;IAC/B,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC;IAClD,IAAI,CAAC,GAAG;QAAE,OAAO,gBAAgB,CAAC;IAClC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;QAC7C,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACzC,0BAA0B,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACpC,aAAa,CAAC,IAAI,CAChB,2EAA2E,EAC3E,EAAE,GAAG,EAAE,YAAY,EAAE,gBAAgB,EAAE,CACxC,CAAC;QACJ,CAAC;QACD,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IACD,IAAI,MAAM,GAAG,oBAAoB;QAAE,OAAO,oBAAoB,CAAC;IAC/D,IAAI,MAAM,GAAG,oBAAoB,EAAE,CAAC;QAClC,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACzC,0BAA0B,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACpC,aAAa,CAAC,IAAI,CAAC,kDAAkD,EAAE;gBACrE,GAAG;gBACH,YAAY,EAAE,oBAAoB;gBAClC,QAAQ,EAAE,oBAAoB;aAC/B,CAAC,CAAC;QACL,CAAC;QACD,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,8BAA8B;IAC5C,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,gCAAgC,CAAC;IACzD,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,EAAE;QAAE,OAAO,KAAK,CAAC;IAClD,OAAO,GAAG,KAAK,GAAG,IAAI,GAAG,CAAC,WAAW,EAAE,KAAK,MAAM,CAAC;AACrD,CAAC;AAED,2EAA2E;AAC3E,2EAA2E;AAC3E,qEAAqE;AACrE,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC","sourcesContent":["import { runtimeLogger } from '../logger.js';\n\n// Maximum number of queue delivery attempts before the handler gives up and\n// gracefully fails the run/step. This must be bounded under the VQS message\n// max visibility window (24 hours) so that our handler-side failure path\n// reliably executes before VQS expires the message.\n//\n// VQS retry schedule (with retryAfterSeconds: 5):\n//   Attempts 1–32:  linear backoff at 5s each  → 32 × 5s = 160s (~2.7 min)\n//   Attempts 33+:   exponential backoff: 60s × 2^(attempt-32),\n//                   capped at 7,200s (2h), floored at retryAfterSeconds\n//\n// At 48 attempts the total elapsed time is approximately 20 hours, which is\n// safely under the 24-hour message visibility limit.\nexport const MAX_QUEUE_DELIVERIES = 48;\n\n/**\n * Default maximum time allowed for the *replay* portion of a single workflow\n * handler invocation (in ms). This budget only covers deterministic-replay\n * and workflow-VM execution between step boundaries — inline step bodies\n * (`\"use step\"` functions invoked via `executeStep`) do NOT count against\n * it. Step bodies are bounded separately by the platform's function\n * `maxDuration` (e.g. 800s on Vercel Pro Fluid) and `NO_INLINE_REPLAY_AFTER_MS`.\n *\n * If the non-step (\"replay\") time within a single invocation exceeds this\n * budget, the handler exits so the queue can retry. After\n * `REPLAY_TIMEOUT_MAX_RETRIES` exhausted attempts the run is failed with\n * `RUN_ERROR_CODES.REPLAY_TIMEOUT`.\n *\n * Note that on Vercel Hobby (standard functions), the platform `maxDuration`\n * is 60s — well below this budget, so the platform SIGTERM will fire first\n * and the queue will re-deliver until the visibility window expires. With\n * Fluid Compute on Hobby the per-function ceiling rises to 300s, still\n * under the default budget.\n *\n * Override via the `WORKFLOW_REPLAY_TIMEOUT_MS` env var (clamped to\n * `MIN_REPLAY_TIMEOUT_MS`..`MAX_REPLAY_TIMEOUT_MS`).\n */\nexport const REPLAY_TIMEOUT_MS = 240_000;\n\n/** Lower bound for the replay-timeout env var override. */\nexport const MIN_REPLAY_TIMEOUT_MS = 30_000;\n\n/**\n * Upper bound for the replay-timeout env var override. 780s leaves ≥20s of\n * headroom under Vercel Pro Fluid's 800s function ceiling so the handler\n * can write `run_failed` before SIGTERM.\n */\nexport const MAX_REPLAY_TIMEOUT_MS = 780_000;\n\n// Track which raw env var values we've already warned about so the warning\n// log only fires once per process (the function may be called many times).\nconst warnedReplayTimeoutValues = new Set<string>();\n\nfunction warnOnce(\n  raw: string,\n  message: string,\n  data: Record<string, unknown>\n): void {\n  if (warnedReplayTimeoutValues.has(raw)) return;\n  warnedReplayTimeoutValues.add(raw);\n  runtimeLogger.warn(message, data);\n}\n\n/**\n * Resolve the effective replay-timeout budget for the current process.\n *\n * Reads `process.env.WORKFLOW_REPLAY_TIMEOUT_MS` lazily so tests and\n * deployments can override per invocation. Invalid / out-of-range values\n * fall back to a safe value (no throw — the env var is an escape hatch,\n * not a hard requirement) and emit a one-time warning so misconfiguration\n * is observable.\n */\nexport function getReplayTimeoutMs(): number {\n  const raw = process.env.WORKFLOW_REPLAY_TIMEOUT_MS;\n  if (!raw) return REPLAY_TIMEOUT_MS;\n  const parsed = Number(raw);\n  if (!Number.isFinite(parsed) || parsed <= 0) {\n    warnOnce(\n      raw,\n      'Ignoring WORKFLOW_REPLAY_TIMEOUT_MS: not a positive finite number; using default',\n      { raw, defaultMs: REPLAY_TIMEOUT_MS }\n    );\n    return REPLAY_TIMEOUT_MS;\n  }\n  if (parsed < MIN_REPLAY_TIMEOUT_MS) {\n    warnOnce(raw, 'WORKFLOW_REPLAY_TIMEOUT_MS below minimum; clamped', {\n      raw,\n      clampedMs: MIN_REPLAY_TIMEOUT_MS,\n      minMs: MIN_REPLAY_TIMEOUT_MS,\n    });\n    return MIN_REPLAY_TIMEOUT_MS;\n  }\n  if (parsed > MAX_REPLAY_TIMEOUT_MS) {\n    warnOnce(raw, 'WORKFLOW_REPLAY_TIMEOUT_MS above maximum; clamped', {\n      raw,\n      clampedMs: MAX_REPLAY_TIMEOUT_MS,\n      maxMs: MAX_REPLAY_TIMEOUT_MS,\n    });\n    return MAX_REPLAY_TIMEOUT_MS;\n  }\n  return parsed;\n}\n\n/**\n * Reset the warn-once cache. Test-only — exported so unit tests can\n * exercise the warn path repeatedly without sharing state.\n *\n * @internal\n */\nexport function _resetReplayTimeoutWarnCacheForTests(): void {\n  warnedReplayTimeoutValues.clear();\n}\n\n// Number of queue delivery attempts to allow before permanently failing a run\n// due to a replay timeout. On attempts 1 through this value, the timeout\n// handler exits without writing run_failed so the queue retries the message.\n// On the next attempt the run is marked as failed.\nexport const REPLAY_TIMEOUT_MAX_RETRIES = 3;\n\n/**\n * Default maximum number of steps the owned-inline path runs inline (in\n * parallel) per suspension. The rest are queued to background handlers. Each\n * inline step is created lazily — its `step_created` is folded into the\n * `step_started` that `executeStep` sends — so inlining N steps saves N queue\n * round-trips for a `Promise.all`-style fan-out. `1` reproduces the\n * single-inline-step behavior exactly (useful kill-switch).\n *\n * Override via `WORKFLOW_MAX_INLINE_STEPS` (clamped to\n * `MIN_MAX_INLINE_STEPS`..`MAX_MAX_INLINE_STEPS`).\n */\nexport const MAX_INLINE_STEPS = 3;\n\n/** Lower bound for the inline-steps env override (1 = single inline step). */\nexport const MIN_MAX_INLINE_STEPS = 1;\n\n/**\n * Upper bound for the inline-steps env override. Inline bodies run in parallel\n * within one function invocation, so this caps memory/CPU fan-out per handler.\n */\nexport const MAX_MAX_INLINE_STEPS = 16;\n\n// Warn-once cache for WORKFLOW_MAX_INLINE_STEPS, keyed by raw env value.\nconst warnedMaxInlineStepsValues = new Set<string>();\n\n/**\n * Resolve the effective max number of inline steps for the current process.\n *\n * Reads `process.env.WORKFLOW_MAX_INLINE_STEPS` lazily so tests and\n * deployments can override per invocation. Invalid / out-of-range values fall\n * back to a safe value (no throw — the env var is an escape hatch) and emit a\n * one-time warning so misconfiguration is observable.\n */\nexport function getMaxInlineSteps(): number {\n  const raw = process.env.WORKFLOW_MAX_INLINE_STEPS;\n  if (!raw) return MAX_INLINE_STEPS;\n  const parsed = Number(raw);\n  if (!Number.isInteger(parsed) || parsed <= 0) {\n    if (!warnedMaxInlineStepsValues.has(raw)) {\n      warnedMaxInlineStepsValues.add(raw);\n      runtimeLogger.warn(\n        'Ignoring WORKFLOW_MAX_INLINE_STEPS: not a positive integer; using default',\n        { raw, defaultValue: MAX_INLINE_STEPS }\n      );\n    }\n    return MAX_INLINE_STEPS;\n  }\n  if (parsed < MIN_MAX_INLINE_STEPS) return MIN_MAX_INLINE_STEPS;\n  if (parsed > MAX_MAX_INLINE_STEPS) {\n    if (!warnedMaxInlineStepsValues.has(raw)) {\n      warnedMaxInlineStepsValues.add(raw);\n      runtimeLogger.warn('WORKFLOW_MAX_INLINE_STEPS above maximum; clamped', {\n        raw,\n        clampedValue: MAX_MAX_INLINE_STEPS,\n        maxValue: MAX_MAX_INLINE_STEPS,\n      });\n    }\n    return MAX_MAX_INLINE_STEPS;\n  }\n  return parsed;\n}\n\n/**\n * Whether optimistic inline step start is enabled. When on, the owned-inline\n * path begins running a brand-new step's body *before* its lazy `step_started`\n * network call resolves (the input is already known locally), awaiting the\n * `step_started` only before the terminal write.\n *\n * This can run a step body more than once when handlers race for the same\n * step's create-claim — both run the body before one wins. That is unsafe for\n * steps with non-idempotent side effects; in particular, two concurrent runs\n * of a step that writes to the workflow stream (e.g. an AI agent streaming\n * tokens) can interleave and corrupt the stream data. So the optimization is\n * **off by default** and must be explicitly opted into per deployment.\n *\n * Reads `process.env.WORKFLOW_OPTIMISTIC_INLINE_START` lazily. Default OFF;\n * enabled only by an explicit `'1'` / `'true'`.\n */\nexport function isOptimisticInlineStartEnabled(): boolean {\n  const raw = process.env.WORKFLOW_OPTIMISTIC_INLINE_START;\n  if (raw === undefined || raw === '') return false;\n  return raw === '1' || raw.toLowerCase() === 'true';\n}\n\n// A replay-consumer mismatch can be caused by a transient divergent replay\n// rather than an invalid persisted history. Queue bounded recovery replays\n// before recording terminal corruption for a run that cannot replay.\nexport const REPLAY_DIVERGENCE_MAX_RETRIES = 3;\n"]}

package/dist/runtime/get-port-lazy.d.ts

@@ -7,4 +7,19 @@
  * dependency is invisible to bundler static analysis.
  */
 export declare function getPortLazy(): Promise<number | undefined>;
+/**
+ * Resets the per-process port cache. Intended for tests; not used on the hot
+ * path. Callers must let any in-flight lookup settle (await the pending
+ * `getPortLazy()` call) before resetting: clearing `_inFlight` here does not
+ * cancel an already-scheduled resolution, so a late `.then` could otherwise
+ * repopulate `_cachedPort` after the reset and bleed into the next test.
+ */
+export declare function resetPortCacheForTesting(): void;
+/**
+ * Installs a fake port resolver and clears the cache. Test-only seam: the real
+ * resolver is loaded via `createRequire` with a runtime-built specifier (to
+ * hide it from bundlers), which also defeats module mocking, so injection is
+ * the only deterministic way to exercise the caching contract.
+ */
+export declare function setPortResolverForTesting(fn: () => Promise<number | undefined>): void;
 //# sourceMappingURL=get-port-lazy.d.ts.map

package/dist/runtime/get-port-lazy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-port-lazy.d.ts","sourceRoot":"","sources":["../../src/runtime/get-port-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAkB/D"}
+{"version":3,"file":"get-port-lazy.d.ts","sourceRoot":"","sources":["../../src/runtime/get-port-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAuBH,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA4C/D;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GACpC,IAAI,CAIN"}

package/dist/runtime/get-port-lazy.js

@@ -9,7 +9,30 @@
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 let _getPort;
+// Per-process cache of the resolved port. The workflow dev server listens on a
+// stable port for the lifetime of the process, but `getPort()` rediscovers it
+// on every call by querying the OS for the process's listening sockets — on
+// macOS that shells out to `lsof` (~60ms), which the runtime pays on EVERY
+// workflow replay (the non-Vercel branch of `runWorkflow`). Since the port does
+// not change within a process, resolve it once and reuse it. `_inFlight`
+// dedupes concurrent first calls so discovery never runs more than once.
+//
+// The first concrete port is pinned for the lifetime of the process — there is
+// no per-call re-resolution. This is safe because the runtime only runs inside
+// the already-listening dev-server process, and `getPort()` -> `getAllPorts()`
+// returns a deterministic order, so repeated calls would resolve the same port
+// anyway.
+let _cachedPort;
+let _inFlight;
 export async function getPortLazy() {
+    // Fast path: already resolved a concrete port for this process.
+    if (_cachedPort !== undefined) {
+        return _cachedPort;
+    }
+    // A discovery is already running — share it rather than starting a second.
+    if (_inFlight) {
+        return _inFlight;
+    }
     if (!_getPort) {
         try {
             // Construct specifier at runtime to defeat bundler static analysis.
@@ -25,6 +48,45 @@ export async function getPortLazy() {
             _getPort = async () => undefined;
         }
     }
-    return _getPort();
+    // `_getPort` is always assigned by the block above; the fallback keeps the
+    // type non-nullable without a non-null assertion.
+    const resolver = _getPort ?? (async () => undefined);
+    _inFlight = resolver()
+        .then((port) => {
+        // Only cache a concrete port. A transient `undefined` (e.g. the server is
+        // not listening yet on the very first replay) must not poison the cache —
+        // leaving it unset lets the next call retry discovery.
+        if (typeof port === 'number') {
+            _cachedPort = port;
+        }
+        return port;
+    })
+        .finally(() => {
+        _inFlight = undefined;
+    });
+    return _inFlight;
+}
+/**
+ * Resets the per-process port cache. Intended for tests; not used on the hot
+ * path. Callers must let any in-flight lookup settle (await the pending
+ * `getPortLazy()` call) before resetting: clearing `_inFlight` here does not
+ * cancel an already-scheduled resolution, so a late `.then` could otherwise
+ * repopulate `_cachedPort` after the reset and bleed into the next test.
+ */
+export function resetPortCacheForTesting() {
+    _getPort = undefined;
+    _cachedPort = undefined;
+    _inFlight = undefined;
+}
+/**
+ * Installs a fake port resolver and clears the cache. Test-only seam: the real
+ * resolver is loaded via `createRequire` with a runtime-built specifier (to
+ * hide it from bundlers), which also defeats module mocking, so injection is
+ * the only deterministic way to exercise the caching contract.
+ */
+export function setPortResolverForTesting(fn) {
+    _getPort = fn;
+    _cachedPort = undefined;
+    _inFlight = undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXBvcnQtbGF6eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydW50aW1lL2dldC1wb3J0LWxhenkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUVILE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDNUMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUV6QyxJQUFJLFFBQXlELENBQUM7QUFFOUQsK0VBQStFO0FBQy9FLDhFQUE4RTtBQUM5RSw0RUFBNEU7QUFDNUUsMkVBQTJFO0FBQzNFLGdGQUFnRjtBQUNoRix5RUFBeUU7QUFDekUseUVBQXlFO0FBQ3pFLEVBQUU7QUFDRiwrRUFBK0U7QUFDL0UsK0VBQStFO0FBQy9FLCtFQUErRTtBQUMvRSwrRUFBK0U7QUFDL0UsVUFBVTtBQUNWLElBQUksV0FBK0IsQ0FBQztBQUNwQyxJQUFJLFNBQWtELENBQUM7QUFFdkQsTUFBTSxDQUFDLEtBQUssVUFBVSxXQUFXO0lBQy9CLGdFQUFnRTtJQUNoRSxJQUFJLFdBQVcsS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUM5QixPQUFPLFdBQVcsQ0FBQztJQUNyQixDQUFDO0lBQ0QsMkVBQTJFO0lBQzNFLElBQUksU0FBUyxFQUFFLENBQUM7UUFDZCxPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0lBRUQsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ2QsSUFBSSxDQUFDO1lBQ0gsb0VBQW9FO1lBQ3BFLE1BQU0sSUFBSSxHQUFHLENBQUMsaUJBQWlCLEVBQUUsVUFBVSxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3ZELG1FQUFtRTtZQUNuRSw0REFBNEQ7WUFDNUQsTUFBTSxRQUFRLEdBQUcsYUFBYSxDQUM1QixhQUFhLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxHQUFHLGVBQWUsQ0FBQyxDQUFDLElBQUksQ0FDcEQsQ0FBQztZQUNGLE1BQU0sR0FBRyxHQUFHLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUMzQixRQUFRLEdBQUcsR0FBRyxDQUFDLE9BQU8sQ0FBQztRQUN6QixDQUFDO1FBQUMsTUFBTSxDQUFDO1lBQ1AsOERBQThEO1lBQzlELFFBQVEsR0FBRyxLQUFLLElBQUksRUFBRSxDQUFDLFNBQVMsQ0FBQztRQUNuQyxDQUFDO0lBQ0gsQ0FBQztJQUVELDJFQUEyRTtJQUMzRSxrREFBa0Q7SUFDbEQsTUFBTSxRQUFRLEdBQUcsUUFBUSxJQUFJLENBQUMsS0FBSyxJQUFJLEVBQUUsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNyRCxTQUFTLEdBQUcsUUFBUSxFQUFFO1NBQ25CLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFO1FBQ2IsMEVBQTBFO1FBQzFFLDBFQUEwRTtRQUMxRSx1REFBdUQ7UUFDdkQsSUFBSSxPQUFPLElBQUksS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUM3QixXQUFXLEdBQUcsSUFBSSxDQUFDO1FBQ3JCLENBQUM7UUFDRCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUMsQ0FBQztTQUNELE9BQU8sQ0FBQyxHQUFHLEVBQUU7UUFDWixTQUFTLEdBQUcsU0FBUyxDQUFDO0lBQ3hCLENBQUMsQ0FBQyxDQUFDO0lBQ0wsT0FBTyxTQUFTLENBQUM7QUFDbkIsQ0FBQztBQUVEOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSx3QkFBd0I7SUFDdEMsUUFBUSxHQUFHLFNBQVMsQ0FBQztJQUNyQixXQUFXLEdBQUcsU0FBUyxDQUFDO0lBQ3hCLFNBQVMsR0FBRyxTQUFTLENBQUM7QUFDeEIsQ0FBQztBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLHlCQUF5QixDQUN2QyxFQUFxQztJQUVyQyxRQUFRLEdBQUcsRUFBRSxDQUFDO0lBQ2QsV0FBVyxHQUFHLFNBQVMsQ0FBQztJQUN4QixTQUFTLEdBQUcsU0FBUyxDQUFDO0FBQ3hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIExhenkgbG9hZGVyIGZvciBnZXRQb3J0IHRoYXQgcHJldmVudHMgYnVuZGxlcnMgKFR1cmJvcGFjaywgZXNidWlsZClcbiAqIGZyb20gc3RhdGljYWxseSB0cmFjaW5nIEB3b3JrZmxvdy91dGlscy9nZXQtcG9ydCBhbmQgaXRzIGZpbGVzeXN0ZW1cbiAqIG9wZXJhdGlvbnMgKHJlYWRkaXIsIHJlYWRGaWxlLCByZWFkbGluaykgaW50byB0aGUgZmxvdyByb3V0ZSBidW5kbGUuXG4gKlxuICogVXNlcyBjcmVhdGVSZXF1aXJlIHdpdGggYSBkeW5hbWljYWxseSBjb25zdHJ1Y3RlZCBzcGVjaWZpZXIgc28gdGhlXG4gKiBkZXBlbmRlbmN5IGlzIGludmlzaWJsZSB0byBidW5kbGVyIHN0YXRpYyBhbmFseXNpcy5cbiAqL1xuXG5pbXBvcnQgeyBjcmVhdGVSZXF1aXJlIH0gZnJvbSAnbm9kZTptb2R1bGUnO1xuaW1wb3J0IHsgcGF0aFRvRmlsZVVSTCB9IGZyb20gJ25vZGU6dXJsJztcblxubGV0IF9nZXRQb3J0OiAoKCkgPT4gUHJvbWlzZTxudW1iZXIgfCB1bmRlZmluZWQ+KSB8IHVuZGVmaW5lZDtcblxuLy8gUGVyLXByb2Nlc3MgY2FjaGUgb2YgdGhlIHJlc29sdmVkIHBvcnQuIFRoZSB3b3JrZmxvdyBkZXYgc2VydmVyIGxpc3RlbnMgb24gYVxuLy8gc3RhYmxlIHBvcnQgZm9yIHRoZSBsaWZldGltZSBvZiB0aGUgcHJvY2VzcywgYnV0IGBnZXRQb3J0KClgIHJlZGlzY292ZXJzIGl0XG4vLyBvbiBldmVyeSBjYWxsIGJ5IHF1ZXJ5aW5nIHRoZSBPUyBmb3IgdGhlIHByb2Nlc3MncyBsaXN0ZW5pbmcgc29ja2V0cyDigJQgb25cbi8vIG1hY09TIHRoYXQgc2hlbGxzIG91dCB0byBgbHNvZmAgKH42MG1zKSwgd2hpY2ggdGhlIHJ1bnRpbWUgcGF5cyBvbiBFVkVSWVxuLy8gd29ya2Zsb3cgcmVwbGF5ICh0aGUgbm9uLVZlcmNlbCBicmFuY2ggb2YgYHJ1bldvcmtmbG93YCkuIFNpbmNlIHRoZSBwb3J0IGRvZXNcbi8vIG5vdCBjaGFuZ2Ugd2l0aGluIGEgcHJvY2VzcywgcmVzb2x2ZSBpdCBvbmNlIGFuZCByZXVzZSBpdC4gYF9pbkZsaWdodGBcbi8vIGRlZHVwZXMgY29uY3VycmVudCBmaXJzdCBjYWxscyBzbyBkaXNjb3ZlcnkgbmV2ZXIgcnVucyBtb3JlIHRoYW4gb25jZS5cbi8vXG4vLyBUaGUgZmlyc3QgY29uY3JldGUgcG9ydCBpcyBwaW5uZWQgZm9yIHRoZSBsaWZldGltZSBvZiB0aGUgcHJvY2VzcyDigJQgdGhlcmUgaXNcbi8vIG5vIHBlci1jYWxsIHJlLXJlc29sdXRpb24uIFRoaXMgaXMgc2FmZSBiZWNhdXNlIHRoZSBydW50aW1lIG9ubHkgcnVucyBpbnNpZGVcbi8vIHRoZSBhbHJlYWR5LWxpc3RlbmluZyBkZXYtc2VydmVyIHByb2Nlc3MsIGFuZCBgZ2V0UG9ydCgpYCAtPiBgZ2V0QWxsUG9ydHMoKWBcbi8vIHJldHVybnMgYSBkZXRlcm1pbmlzdGljIG9yZGVyLCBzbyByZXBlYXRlZCBjYWxscyB3b3VsZCByZXNvbHZlIHRoZSBzYW1lIHBvcnRcbi8vIGFueXdheS5cbmxldCBfY2FjaGVkUG9ydDogbnVtYmVyIHwgdW5kZWZpbmVkO1xubGV0IF9pbkZsaWdodDogUHJvbWlzZTxudW1iZXIgfCB1bmRlZmluZWQ+IHwgdW5kZWZpbmVkO1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gZ2V0UG9ydExhenkoKTogUHJvbWlzZTxudW1iZXIgfCB1bmRlZmluZWQ+IHtcbiAgLy8gRmFzdCBwYXRoOiBhbHJlYWR5IHJlc29sdmVkIGEgY29uY3JldGUgcG9ydCBmb3IgdGhpcyBwcm9jZXNzLlxuICBpZiAoX2NhY2hlZFBvcnQgIT09IHVuZGVmaW5lZCkge1xuICAgIHJldHVybiBfY2FjaGVkUG9ydDtcbiAgfVxuICAvLyBBIGRpc2NvdmVyeSBpcyBhbHJlYWR5IHJ1bm5pbmcg4oCUIHNoYXJlIGl0IHJhdGhlciB0aGFuIHN0YXJ0aW5nIGEgc2Vjb25kLlxuICBpZiAoX2luRmxpZ2h0KSB7XG4gICAgcmV0dXJuIF9pbkZsaWdodDtcbiAgfVxuXG4gIGlmICghX2dldFBvcnQpIHtcbiAgICB0cnkge1xuICAgICAgLy8gQ29uc3RydWN0IHNwZWNpZmllciBhdCBydW50aW1lIHRvIGRlZmVhdCBidW5kbGVyIHN0YXRpYyBhbmFseXNpcy5cbiAgICAgIGNvbnN0IHNwZWMgPSBbJ0B3b3JrZmxvdy91dGlscycsICdnZXQtcG9ydCddLmpvaW4oJy8nKTtcbiAgICAgIC8vIFVzZSBwcm9jZXNzLmN3ZCgpLWJhc2VkIGNyZWF0ZVJlcXVpcmUgZm9yIENKUy9FU00gY29tcGF0aWJpbGl0eS5cbiAgICAgIC8vIGltcG9ydC5tZXRhLnVybCBpcyB1bmF2YWlsYWJsZSBpbiBDSlMgcmUtYnVuZGxlZCBvdXRwdXRzLlxuICAgICAgY29uc3QgX3JlcXVpcmUgPSBjcmVhdGVSZXF1aXJlKFxuICAgICAgICBwYXRoVG9GaWxlVVJMKHByb2Nlc3MuY3dkKCkgKyAnL3BhY2thZ2UuanNvbicpLmhyZWZcbiAgICAgICk7XG4gICAgICBjb25zdCBtb2QgPSBfcmVxdWlyZShzcGVjKTtcbiAgICAgIF9nZXRQb3J0ID0gbW9kLmdldFBvcnQ7XG4gICAgfSBjYXRjaCB7XG4gICAgICAvLyBNb2R1bGUgbm90IGF2YWlsYWJsZSAoZS5nLiwgaW4gYSBicm93c2VyIG9yIG1pbmltYWwgYnVuZGxlKVxuICAgICAgX2dldFBvcnQgPSBhc3luYyAoKSA9PiB1bmRlZmluZWQ7XG4gICAgfVxuICB9XG5cbiAgLy8gYF9nZXRQb3J0YCBpcyBhbHdheXMgYXNzaWduZWQgYnkgdGhlIGJsb2NrIGFib3ZlOyB0aGUgZmFsbGJhY2sga2VlcHMgdGhlXG4gIC8vIHR5cGUgbm9uLW51bGxhYmxlIHdpdGhvdXQgYSBub24tbnVsbCBhc3NlcnRpb24uXG4gIGNvbnN0IHJlc29sdmVyID0gX2dldFBvcnQgPz8gKGFzeW5jICgpID0+IHVuZGVmaW5lZCk7XG4gIF9pbkZsaWdodCA9IHJlc29sdmVyKClcbiAgICAudGhlbigocG9ydCkgPT4ge1xuICAgICAgLy8gT25seSBjYWNoZSBhIGNvbmNyZXRlIHBvcnQuIEEgdHJhbnNpZW50IGB1bmRlZmluZWRgIChlLmcuIHRoZSBzZXJ2ZXIgaXNcbiAgICAgIC8vIG5vdCBsaXN0ZW5pbmcgeWV0IG9uIHRoZSB2ZXJ5IGZpcnN0IHJlcGxheSkgbXVzdCBub3QgcG9pc29uIHRoZSBjYWNoZSDigJRcbiAgICAgIC8vIGxlYXZpbmcgaXQgdW5zZXQgbGV0cyB0aGUgbmV4dCBjYWxsIHJldHJ5IGRpc2NvdmVyeS5cbiAgICAgIGlmICh0eXBlb2YgcG9ydCA9PT0gJ251bWJlcicpIHtcbiAgICAgICAgX2NhY2hlZFBvcnQgPSBwb3J0O1xuICAgICAgfVxuICAgICAgcmV0dXJuIHBvcnQ7XG4gICAgfSlcbiAgICAuZmluYWxseSgoKSA9PiB7XG4gICAgICBfaW5GbGlnaHQgPSB1bmRlZmluZWQ7XG4gICAgfSk7XG4gIHJldHVybiBfaW5GbGlnaHQ7XG59XG5cbi8qKlxuICogUmVzZXRzIHRoZSBwZXItcHJvY2VzcyBwb3J0IGNhY2hlLiBJbnRlbmRlZCBmb3IgdGVzdHM7IG5vdCB1c2VkIG9uIHRoZSBob3RcbiAqIHBhdGguIENhbGxlcnMgbXVzdCBsZXQgYW55IGluLWZsaWdodCBsb29rdXAgc2V0dGxlIChhd2FpdCB0aGUgcGVuZGluZ1xuICogYGdldFBvcnRMYXp5KClgIGNhbGwpIGJlZm9yZSByZXNldHRpbmc6IGNsZWFyaW5nIGBfaW5GbGlnaHRgIGhlcmUgZG9lcyBub3RcbiAqIGNhbmNlbCBhbiBhbHJlYWR5LXNjaGVkdWxlZCByZXNvbHV0aW9uLCBzbyBhIGxhdGUgYC50aGVuYCBjb3VsZCBvdGhlcndpc2VcbiAqIHJlcG9wdWxhdGUgYF9jYWNoZWRQb3J0YCBhZnRlciB0aGUgcmVzZXQgYW5kIGJsZWVkIGludG8gdGhlIG5leHQgdGVzdC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc2V0UG9ydENhY2hlRm9yVGVzdGluZygpOiB2b2lkIHtcbiAgX2dldFBvcnQgPSB1bmRlZmluZWQ7XG4gIF9jYWNoZWRQb3J0ID0gdW5kZWZpbmVkO1xuICBfaW5GbGlnaHQgPSB1bmRlZmluZWQ7XG59XG5cbi8qKlxuICogSW5zdGFsbHMgYSBmYWtlIHBvcnQgcmVzb2x2ZXIgYW5kIGNsZWFycyB0aGUgY2FjaGUuIFRlc3Qtb25seSBzZWFtOiB0aGUgcmVhbFxuICogcmVzb2x2ZXIgaXMgbG9hZGVkIHZpYSBgY3JlYXRlUmVxdWlyZWAgd2l0aCBhIHJ1bnRpbWUtYnVpbHQgc3BlY2lmaWVyICh0b1xuICogaGlkZSBpdCBmcm9tIGJ1bmRsZXJzKSwgd2hpY2ggYWxzbyBkZWZlYXRzIG1vZHVsZSBtb2NraW5nLCBzbyBpbmplY3Rpb24gaXNcbiAqIHRoZSBvbmx5IGRldGVybWluaXN0aWMgd2F5IHRvIGV4ZXJjaXNlIHRoZSBjYWNoaW5nIGNvbnRyYWN0LlxuICovXG5leHBvcnQgZnVuY3Rpb24gc2V0UG9ydFJlc29sdmVyRm9yVGVzdGluZyhcbiAgZm46ICgpID0+IFByb21pc2U8bnVtYmVyIHwgdW5kZWZpbmVkPlxuKTogdm9pZCB7XG4gIF9nZXRQb3J0ID0gZm47XG4gIF9jYWNoZWRQb3J0ID0gdW5kZWZpbmVkO1xuICBfaW5GbGlnaHQgPSB1bmRlZmluZWQ7XG59XG4iXX0=

package/dist/runtime/run-id-time.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Extracts the run's creation timestamp (epoch milliseconds) from a `wrun_`
+ * run ID by decoding the embedded ULID time component.
+ *
+ * Returns `undefined` when `runId` is not a decodable `wrun_<ulid>` (e.g. a
+ * legacy/non-ULID id, or a test fixture like `wrun_test`); callers fall back to
+ * an authoritative timestamp from the run snapshot (`createdAt`) in that case.
+ */
+export declare function runIdCreatedAt(runId: string): number | undefined;
+//# sourceMappingURL=run-id-time.d.ts.map

package/dist/runtime/run-id-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-id-time.d.ts","sourceRoot":"","sources":["../../src/runtime/run-id-time.ts"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAShE"}

package/dist/runtime/run-id-time.js

@@ -0,0 +1,31 @@
+import { decodeTime } from 'ulid';
+/**
+ * Run IDs are minted client-side in `start()` as `wrun_<ulid>` (see
+ * `runtime/start.ts`). A ULID encodes its creation time in its first 48 bits,
+ * so the run's creation timestamp is recoverable from the run ID alone —
+ * without any server round-trip or run-snapshot load. This is the earliest
+ * replay-stable timestamp a delivery has (the run ID arrives in the queue
+ * payload), which lets the workflow VM be seeded and clock-initialized before
+ * `run_started`.
+ */
+const RUN_ID_PREFIX = 'wrun_';
+/**
+ * Extracts the run's creation timestamp (epoch milliseconds) from a `wrun_`
+ * run ID by decoding the embedded ULID time component.
+ *
+ * Returns `undefined` when `runId` is not a decodable `wrun_<ulid>` (e.g. a
+ * legacy/non-ULID id, or a test fixture like `wrun_test`); callers fall back to
+ * an authoritative timestamp from the run snapshot (`createdAt`) in that case.
+ */
+export function runIdCreatedAt(runId) {
+    const ulidPart = runId.startsWith(RUN_ID_PREFIX)
+        ? runId.slice(RUN_ID_PREFIX.length)
+        : runId;
+    try {
+        return decodeTime(ulidPart);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,4 +1,4 @@
-import type { World } from '@workflow/world';
+import type { Event, SerializedData, World } from '@workflow/world';
 import type { CryptoKey } from '../encryption.js';
 export interface StepExecutorParams {
     world: World;
@@ -16,14 +16,57 @@ export interface StepExecutorParams {
      * as possibly containing compressed payloads (specVersion >= 5).
      */
     runSpecVersion?: number;
+    /**
+     * Lazy step start: the already-dehydrated step input. When provided, the
+     * `step_started` event carries this input so the world creates the step on
+     * the fly (no separate `step_created` round-trip). Set by the owned-inline
+     * path for the step whose `step_created` the suspension handler deferred.
+     * The world's atomic create-claim is the exactly-one-owner gate: losing it
+     * surfaces as `EntityConflictError` → `{ type: 'skipped' }`, so a handler
+     * that did not win the create never runs the body. Omitted on every other
+     * path, where the step already has a `step_created` and `step_started`
+     * carries no payload (the legacy contract).
+     */
+    lazyStepInput?: SerializedData;
+    /**
+     * Inline-delta optimization (opt-in). When provided, the cursor of the
+     * event log as observed by the caller *before* this step's events were
+     * written. It is threaded into the step-terminal `events.create` so a
+     * supporting World can return the delta of events written since (see
+     * {@link import('@workflow/world').CreateEventParams.sinceCursor}).
+     * Only set this when `correlationId`-based ownership guarantees this
+     * handler is the sole inline writer for the run on this iteration.
+     */
+    inlineDeltaSinceCursor?: string;
+}
+/**
+ * Inline-delta returned by a step-terminal write when the caller passed
+ * {@link StepExecutorParams.inlineDeltaSinceCursor} and the World supports
+ * the optimization. `events` are the events written strictly after that
+ * cursor (this step's events plus anything interleaved in-band), `cursor`
+ * is the position past the last one, and `hasMore` signals a further page
+ * (the caller then falls back to a full incremental fetch). Absent when
+ * the World did not return a delta.
+ */
+export interface InlineEventDelta {
+    events: Event[];
+    cursor: string | null;
+    hasMore: boolean;
 }
 /**
  * Result of a step execution attempt. The caller decides what to do
  * based on the result type (e.g., queue workflow continuation, replay inline, etc.).
+ *
+ * `inlineDelta` is attached to a `completed` result when the caller
+ * requested it via {@link StepExecutorParams.inlineDeltaSinceCursor} and
+ * the World returned one. Step failures are rare and not the inline
+ * optimization's target, so the `failed` path leaves it to the normal
+ * incremental fetch.
  */
 export type StepExecutionResult = {
     type: 'completed';
     hasPendingOps?: boolean;
+    inlineDelta?: InlineEventDelta;
 } | {
     type: 'failed';
 } | {

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

@@ -1 +1 @@
-{"version":3,"file":"step-executor.d.ts","sourceRoot":"","sources":["../../src/runtime/step-executor.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAK7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAyBlD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,KAAK,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,mBAAmB,CAAC,CA+mB9B"}
+{"version":3,"file":"step-executor.d.ts","sourceRoot":"","sources":["../../src/runtime/step-executor.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,KAAK,EAAE,cAAc,EAAQ,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAK1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AA+ClD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,KAAK,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE,cAAc,CAAC;IAC/B;;;;;;;;OAQG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,gBAAgB,CAAC;CAChC,GACD;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,mBAAmB,CAAC,CA+vB9B"}