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

package/dist/replay-payload-cache.js

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

package/dist/runtime/compute-instance.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Identifier for the compute instance (microVM) this module was loaded into.
+ *
+ * Vercel exposes no native per-instance id under Fluid compute (`AWS_LAMBDA_*`
+ * is blocked), so we synthesize one at module load: a prefixed ULID
+ * (`cinst_<ulid>`, per the `wrun_`/`step_` convention) whose timestamp is the
+ * instance's birth time. Stable for the instance's life and shared by every
+ * invocation it handles — including the concurrent ones Fluid packs onto it;
+ * cold starts mint fresh ids. Emitted as the OTEL `faas.instance` attribute.
+ */
+export declare const COMPUTE_INSTANCE_ID: string;
+//# sourceMappingURL=compute-instance.d.ts.map

package/dist/runtime/compute-instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-instance.d.ts","sourceRoot":"","sources":["../../src/runtime/compute-instance.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,QAAoB,CAAC"}

package/dist/runtime/compute-instance.js

@@ -0,0 +1,13 @@
+import { ulid } from 'ulid';
+/**
+ * Identifier for the compute instance (microVM) this module was loaded into.
+ *
+ * Vercel exposes no native per-instance id under Fluid compute (`AWS_LAMBDA_*`
+ * is blocked), so we synthesize one at module load: a prefixed ULID
+ * (`cinst_<ulid>`, per the `wrun_`/`step_` convention) whose timestamp is the
+ * instance's birth time. Stable for the instance's life and shared by every
+ * invocation it handles — including the concurrent ones Fluid packs onto it;
+ * cold starts mint fresh ids. Emitted as the OTEL `faas.instance` attribute.
+ */
+export const COMPUTE_INSTANCE_ID = `cinst_${ulid()}`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcHV0ZS1pbnN0YW5jZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydW50aW1lL2NvbXB1dGUtaW5zdGFuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUU1Qjs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxTQUFTLElBQUksRUFBRSxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB1bGlkIH0gZnJvbSAndWxpZCc7XG5cbi8qKlxuICogSWRlbnRpZmllciBmb3IgdGhlIGNvbXB1dGUgaW5zdGFuY2UgKG1pY3JvVk0pIHRoaXMgbW9kdWxlIHdhcyBsb2FkZWQgaW50by5cbiAqXG4gKiBWZXJjZWwgZXhwb3NlcyBubyBuYXRpdmUgcGVyLWluc3RhbmNlIGlkIHVuZGVyIEZsdWlkIGNvbXB1dGUgKGBBV1NfTEFNQkRBXypgXG4gKiBpcyBibG9ja2VkKSwgc28gd2Ugc3ludGhlc2l6ZSBvbmUgYXQgbW9kdWxlIGxvYWQ6IGEgcHJlZml4ZWQgVUxJRFxuICogKGBjaW5zdF88dWxpZD5gLCBwZXIgdGhlIGB3cnVuX2AvYHN0ZXBfYCBjb252ZW50aW9uKSB3aG9zZSB0aW1lc3RhbXAgaXMgdGhlXG4gKiBpbnN0YW5jZSdzIGJpcnRoIHRpbWUuIFN0YWJsZSBmb3IgdGhlIGluc3RhbmNlJ3MgbGlmZSBhbmQgc2hhcmVkIGJ5IGV2ZXJ5XG4gKiBpbnZvY2F0aW9uIGl0IGhhbmRsZXMg4oCUIGluY2x1ZGluZyB0aGUgY29uY3VycmVudCBvbmVzIEZsdWlkIHBhY2tzIG9udG8gaXQ7XG4gKiBjb2xkIHN0YXJ0cyBtaW50IGZyZXNoIGlkcy4gRW1pdHRlZCBhcyB0aGUgT1RFTCBgZmFhcy5pbnN0YW5jZWAgYXR0cmlidXRlLlxuICovXG5leHBvcnQgY29uc3QgQ09NUFVURV9JTlNUQU5DRV9JRCA9IGBjaW5zdF8ke3VsaWQoKX1gO1xuIl19

package/dist/runtime/constants.d.ts

@@ -1,4 +1,255 @@
 export declare const MAX_QUEUE_DELIVERIES = 48;
+/**
+ * Effective max queue deliveries. Override via `WORKFLOW_MAX_QUEUE_DELIVERIES`.
+ */
+export declare function getMaxQueueDeliveries(): number;
+/**
+ * Default maximum time allowed for the *replay* portion of a single workflow
+ * handler invocation (in ms). This budget only covers deterministic-replay
+ * and workflow-VM execution between step boundaries — inline step bodies
+ * (`"use step"` functions invoked via `executeStep`) do NOT count against
+ * it. Step bodies are bounded separately by the platform's function
+ * `maxDuration` (e.g. 800s on Vercel Pro Fluid) and `NO_INLINE_REPLAY_AFTER_MS`.
+ *
+ * If the non-step ("replay") time within a single invocation exceeds this
+ * budget, the handler rejects so the queue can retry. After
+ * `REPLAY_TIMEOUT_MAX_RETRIES` exhausted attempts the run is failed with
+ * `RUN_ERROR_CODES.REPLAY_TIMEOUT`.
+ *
+ * Note that on Vercel Hobby (standard functions), the platform `maxDuration`
+ * is 60s — well below this budget, so the platform SIGTERM will fire first
+ * and the queue will re-deliver until the visibility window expires. With
+ * Fluid Compute on Hobby the per-function ceiling rises to 300s, still
+ * under the default budget.
+ *
+ * Override via the `WORKFLOW_REPLAY_TIMEOUT_MS` env var (clamped to
+ * `MIN_REPLAY_TIMEOUT_MS`..`MAX_REPLAY_TIMEOUT_MS`).
+ */
 export declare const REPLAY_TIMEOUT_MS = 240000;
+/** Lower bound for the replay-timeout env var override. */
+export declare const MIN_REPLAY_TIMEOUT_MS = 30000;
+/**
+ * Upper bound for the replay-timeout env var override. 780s leaves ≥20s of
+ * headroom under Vercel Pro Fluid's 800s function ceiling so the handler
+ * can write `run_failed` before SIGTERM.
+ */
+export declare const MAX_REPLAY_TIMEOUT_MS = 780000;
+/**
+ * Resolve the effective replay-timeout budget for the current process.
+ *
+ * Reads `process.env.WORKFLOW_REPLAY_TIMEOUT_MS` 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,
+ * not a hard requirement) and emit a one-time warning so misconfiguration
+ * is observable.
+ */
+export declare function getReplayTimeoutMs(): number;
+/**
+ * Reset the warn-once cache. Test-only — exported so unit tests can
+ * exercise the warn path repeatedly without sharing state.
+ *
+ * @internal
+ */
+export declare function _resetReplayTimeoutWarnCacheForTests(): void;
 export declare const REPLAY_TIMEOUT_MAX_RETRIES = 3;
+/**
+ * Effective replay-timeout retry budget. Override via
+ * `WORKFLOW_REPLAY_TIMEOUT_MAX_RETRIES`.
+ */
+export declare function getReplayTimeoutMaxRetries(): number;
+/**
+ * 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 declare const MAX_INLINE_STEPS = 3;
+/** Lower bound for the inline-steps env override (1 = single inline step). */
+export declare 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 declare const MAX_MAX_INLINE_STEPS = 16;
+/**
+ * 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 declare function getMaxInlineSteps(): number;
+/**
+ * Optional client-side override for the server-supplied per-run event ceiling.
+ * When set to a positive integer, the runtime clamps the server's limit *down*
+ * to this value (never raises it) so enforcement can be exercised without a
+ * server-side change. `undefined` (unset) ⇒ use the server value as-is.
+ *
+ * Reads `process.env.WORKFLOW_MAX_EVENTS_OVERRIDE` lazily so tests and
+ * deployments can override per invocation. Invalid values fall back to unset
+ * (no throw — the env var is an escape hatch) and emit a one-time warning.
+ */
+export declare function getMaxEventsOverride(): number | undefined;
+/**
+ * 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 declare function isOptimisticInlineStartEnabled(): boolean;
+/**
+ * Whether an operator has **explicitly disabled** optimistic inline start via
+ * `WORKFLOW_OPTIMISTIC_INLINE_START=0` / `=false`. Distinct from "unset": unset
+ * leaves the optimization off by default but lets turbo force it on; an explicit
+ * `0`/`false` is an operator opt-out that turbo must honor (turbo's forced
+ * optimistic start still runs a step body before `step_started`/`run_started` is
+ * confirmed, the property such an operator is opting out of), so
+ * `forceOptimisticStart` defers to this. Reads the env var lazily.
+ */
+export declare function isOptimisticInlineStartExplicitlyDisabled(): boolean;
+/**
+ * Whether "turbo mode" is enabled. Turbo mode fast-paths the *first delivery of
+ * the first invocation* of a run (detected by the entrypoint via `runInput`
+ * presence + `metadata.attempt === 1`): it backgrounds the `run_started` event
+ * creation, skips the initial event-log load (nothing has been written yet),
+ * and forces optimistic inline step start for that invocation — independent of
+ * `WORKFLOW_OPTIMISTIC_INLINE_START`.
+ *
+ * Forcing optimistic start is safe here because the first delivery has no
+ * concurrent peer handler to race the step create-claim, so a step body runs
+ * exactly once. That single-handler guarantee ends as soon as the run creates a
+ * hook or wait (which introduce resume/parallel invocations), so the runtime
+ * exits turbo at that point.
+ *
+ * Reads `process.env.WORKFLOW_TURBO` lazily. Default **ON**; disabled only by an
+ * explicit `'0'` / `'false'` (case-insensitive).
+ */
+export declare function isTurboEnabled(): boolean;
+/**
+ * Whether the QuickJS engine's baseline-snapshot startup optimization is
+ * enabled (default ON). When on, the engine hydrates a VM with the
+ * workflow bundle once per function instance, snapshots it, and starts
+ * every invocation by restoring the snapshot instead of re-evaluating
+ * the bundle — skipping the dominant share of VM startup (measured
+ * ~77ms → ~3ms to first suspension for a 1.3MB bundle). Bundles whose
+ * module scope consumes randomness, reads the clock, or replaces a
+ * serialization intrinsic are detected at hydrate time and
+ * automatically fall back to per-invocation fresh evaluation (see
+ * prepareBaselineSnapshot). Set WORKFLOW_QUICKJS_BASELINE_SNAPSHOT=0 to
+ * disable.
+ */
+export declare function isQuickJSBaselineSnapshotEnabled(): boolean;
+/**
+ * Whether the inline loop retains a suspended workflow VM across inline steps
+ * within one invocation (default ON). When on, a step-only suspension keeps
+ * the live VM, event consumer, and hydrated state alive, and the next loop
+ * iteration appends only the newly durable events instead of rebuilding the
+ * `vm.Context` and replaying the whole event log. Non-step suspensions and
+ * replay divergence always fall back to the ordinary durable replay path.
+ *
+ * `WORKFLOW_RETAINED_VM=0` (or `false`) is the kill switch: every iteration
+ * replays from scratch in a fresh VM, matching the pre-retention behavior.
+ */
+export declare function isVmRetentionEnabled(): boolean;
+/**
+ * Whether inline step ownership is enabled (default ON). When on, the lazy
+ * `step_started` that creates an inline step records the owning queue
+ * message ID, and wake replays that observe an actively-owned step enqueue a
+ * *delayed backstop* message instead of immediately requeueing it — fixing
+ * duplicate inline step execution when a hook/wait wakes a run mid-step
+ * (vercel/workflow#2780).
+ *
+ * `WORKFLOW_INLINE_OWNERSHIP=0` (or `false`) is the kill switch: dispatch
+ * reverts to the unconditional immediate requeue. Stamping is unaffected —
+ * the recorded ownerMessageId is inert data when the switch is off.
+ */
+export declare function isInlineOwnershipEnabled(): boolean;
+/**
+ * Default inline-ownership lease, in seconds: how long after a step's latest
+ * (stamped) `step_started` a non-owner invocation assumes the owning
+ * invocation may still be alive. Within the lease, wake replays enqueue the
+ * step's backstop message with `delaySeconds = lease remaining` instead of
+ * immediately; past it, they enqueue immediately (today's behavior).
+ *
+ * Why a fixed 860 and not a value derived from the function's `maxDuration`:
+ * neither runtime nor build time can see the resolved value — builders emit
+ * `maxDuration: 'max'`, which the platform resolves per-plan at deploy, and
+ * no env var or request-context deadline API exposes the result. The bound
+ * comes from a platform rule instead: durations above 800s require explicit
+ * per-function numeric config, so a builder-emitted `'max'` resolves to at
+ * most 800s — 860s therefore dominates any workflow route's invocation
+ * lifetime plus scheduling slack. Revisit when that ceiling moves (the
+ * 30-minute duration beta becoming reachable via `'max'` would invalidate
+ * the bound). Worlds without an invocation kill bound (world-local,
+ * self-hosted) get no death proof from any constant — there the in-process
+ * single-flight layer (step-single-flight.ts) is what makes a backstop
+ * firing mid-step harmless.
+ *
+ * 860 also stays under the queue's 900s maximum delay (SQS cap), so a
+ * backstop's full lease remainder always fits in a single delayed message.
+ *
+ * Override via `WORKFLOW_INLINE_OWNERSHIP_LEASE_SECONDS` (clamped to
+ * 1..`MAX_INLINE_OWNERSHIP_LEASE_SECONDS`).
+ */
+export declare const INLINE_OWNERSHIP_LEASE_SECONDS = 860;
+/**
+ * Upper bound for the lease env override. 900s is the queue's maximum
+ * per-message delay (SQS cap) — a longer lease would need delay chaining
+ * like long waits use; clamp instead so one delayed message always suffices.
+ */
+export declare const MAX_INLINE_OWNERSHIP_LEASE_SECONDS = 900;
+/**
+ * Effective inline-ownership lease. Override via
+ * `WORKFLOW_INLINE_OWNERSHIP_LEASE_SECONDS` — e.g. raise it on self-hosted
+ * multi-instance worlds with long-running steps to widen the window in which
+ * a live owner is protected from a concurrent backstop execution.
+ */
+export declare function getInlineOwnershipLeaseSeconds(): number;
+export declare const REPLAY_DIVERGENCE_MAX_RETRIES = 3;
+/**
+ * Effective replay-divergence recovery budget. Override via
+ * `WORKFLOW_REPLAY_DIVERGENCE_MAX_RETRIES`.
+ */
+export declare function getReplayDivergenceMaxRetries(): number;
+export declare const PRECONDITION_MAX_INPROCESS_RESTARTS = 3;
+/**
+ * Effective in-process replay-restart budget for stale-snapshot rejections.
+ * Override via `WORKFLOW_PRECONDITION_MAX_INPROCESS_RESTARTS`.
+ */
+export declare function getPreconditionMaxInProcessRestarts(): number;
+export declare const PRECONDITION_MAX_REINVOCATIONS = 5;
+/**
+ * Effective per-run budget for re-invocations caused by stale-snapshot
+ * rejections. Override via `WORKFLOW_PRECONDITION_MAX_REINVOCATIONS`.
+ */
+export declare function getPreconditionMaxReinvocations(): number;
+export declare const PRECONDITION_REINVOKE_DELAY_SECONDS = 2;
+/**
+ * Effective delay before a precondition re-invocation. Override via
+ * `WORKFLOW_PRECONDITION_REINVOKE_DELAY_SECONDS`.
+ */
+export declare function getPreconditionReinvokeDelaySeconds(): number;
+export declare const DEPLOYMENT_MISMATCH_MAX_RETRIES = 3;
+/**
+ * Effective deployment-mismatch re-route budget. Override via
+ * `WORKFLOW_DEPLOYMENT_MISMATCH_MAX_RETRIES`; `0` fails the run on the first
+ * misrouted delivery instead of attempting recovery.
+ */
+export declare function getDeploymentMismatchMaxRetries(): number;
 //# sourceMappingURL=constants.d.ts.map

package/dist/runtime/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AASvC,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAMzC,eAAO,MAAM,0BAA0B,IAAI,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAW9C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAEzC,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,SAAU,CAAC;AAgB7C;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CA6B3C;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,IAAI,IAAI,CAE3D;AAMD,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAMnD;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAKvC;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CA2B1C;AAID;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,SAAS,CAezD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,IAAI,OAAO,CAIxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,yCAAyC,IAAI,OAAO,CAInE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAIxC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gCAAgC,IAAI,OAAO,CAI1D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAI9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CAIlD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,kCAAkC,MAAM,CAAC;AAEtD;;;;;GAKG;AACH,wBAAgB,8BAA8B,IAAI,MAAM,CAMvD;AAKD,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAE/C;;;GAGG;AACH,wBAAgB,6BAA6B,IAAI,MAAM,CAMtD;AAQD,eAAO,MAAM,mCAAmC,IAAI,CAAC;AAErD;;;GAGG;AACH,wBAAgB,mCAAmC,IAAI,MAAM,CAM5D;AASD,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD;;;GAGG;AACH,wBAAgB,+BAA+B,IAAI,MAAM,CAMxD;AAMD,eAAO,MAAM,mCAAmC,IAAI,CAAC;AAErD;;;GAGG;AACH,wBAAgB,mCAAmC,IAAI,MAAM,CAM5D;AAKD,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAEjD;;;;GAIG;AACH,wBAAgB,+BAA+B,IAAI,MAAM,CAMxD"}