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

package/dist/replay-payload-cache.d.ts

@@ -0,0 +1,64 @@
+import type { Event, WorkflowRun } from '@workflow/world';
+import type { PayloadKey } from './serialization/encryption.js';
+import { type PreparedReplayPayload, type ReplayPayloadPreparer } from './serialization.js';
+type ReplayPayloadField = 'result' | 'error' | 'payload';
+/**
+ * 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 and memoized primitive step results remain
+ * resident for the invocation lifetime. Their memory never crosses workflow
+ * runs or queue deliveries.
+ */
+export declare class ReplayPayloadCache {
+    private readonly preparer;
+    private readonly preparedPayloads;
+    private readonly primitiveStepResults;
+    private readonly encryptionKey;
+    private nextUnscannedEventIndex;
+    constructor(encryptionKey: PayloadKey | undefined | Promise<PayloadKey | undefined>, preparer?: ReplayPayloadPreparer);
+    /** Start preparing an event payload as soon as its frame is decoded. */
+    prepareEvent(event: Event): void;
+    /**
+     * 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.
+     */
+    prewarm(workflowRun: WorkflowRun, events: Event[]): Promise<void>;
+    /** Rescan the next event log after an authoritative replacement. */
+    resetScan(): void;
+    /** Return the workflow input after shared host-side preparation. */
+    prepareWorkflowInput(workflowRun: WorkflowRun): Promise<PreparedReplayPayload>;
+    /**
+     * 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: string, field: ReplayPayloadField, value: unknown): Promise<PreparedReplayPayload>;
+    /**
+     * Reuse final step values only when sharing them across VMs is unobservable.
+     * Objects always run `hydrate` again to produce a fresh VM-specific value;
+     * every primitive is safe to reuse directly.
+     */
+    getStepResult(eventId: string, hydrate: () => Promise<unknown>): Promise<unknown>;
+    /**
+     * Consumer-facing lookup. Binary payloads share preparation; legacy values
+     * bypass the cache because their flattened representation may be mutated.
+     */
+    private consumePreparation;
+    /** Start preparation once and share the exact in-flight promise. */
+    private ensurePreparation;
+    /** Normalize synchronous and asynchronous preparers to one promise contract. */
+    private runPreparation;
+    /** Start one event's binary payload unless another path already did. */
+    private prepareEventIfMissing;
+    private startPreparation;
+    private workflowInputKey;
+    private eventPayloadKey;
+}
+export {};
+//# sourceMappingURL=replay-payload-cache.d.ts.map

package/dist/replay-payload-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-payload-cache.d.ts","sourceRoot":"","sources":["../src/replay-payload-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EACL,KAAK,qBAAqB,EAE1B,KAAK,qBAAqB,EAC3B,MAAM,oBAAoB,CAAC;AAE5B,KAAK,kBAAkB,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;AASzD;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAkB;IAW3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAV3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAG7B;IACJ,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA8B;IACnE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkC;IAChE,OAAO,CAAC,uBAAuB,CAAK;gBAGlC,aAAa,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,EACtD,QAAQ,GAAE,qBAA4C;IAKzE,wEAAwE;IACxE,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAOhC;;;;OAIG;IACG,OAAO,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBvE,oEAAoE;IACpE,SAAS,IAAI,IAAI;IAIjB,oEAAoE;IACpE,oBAAoB,CAClB,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,qBAAqB,CAAC;IAOjC;;;;OAIG;IACH,mBAAmB,CACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,kBAAkB,EACzB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,qBAAqB,CAAC;IAIjC;;;;OAIG;IACG,aAAa,CACjB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAC9B,OAAO,CAAC,OAAO,CAAC;IAYnB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAe1B,oEAAoE;IACpE,OAAO,CAAC,iBAAiB;IAYzB,gFAAgF;YAClE,cAAc;IAI5B,wEAAwE;IACxE,OAAO,CAAC,qBAAqB;IAqC7B,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,eAAe;CAGxB"}

package/dist/replay-payload-cache.js

@@ -0,0 +1,158 @@
+import { prepareReplayPayload, } from './serialization.js';
+function isMemoizablePrimitive(value) {
+    if (value === null)
+        return true;
+    const type = typeof value;
+    if (type === 'object' || type === 'function')
+        return false;
+    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 and memoized primitive step results remain
+ * resident for the invocation lifetime. Their memory never crosses workflow
+ * runs or queue deliveries.
+ */
+export class ReplayPayloadCache {
+    preparer;
+    preparedPayloads = new Map();
+    primitiveStepResults = new Map();
+    encryptionKey;
+    nextUnscannedEventIndex = 0;
+    constructor(encryptionKey, preparer = prepareReplayPayload) {
+        this.preparer = preparer;
+        this.encryptionKey = Promise.resolve(encryptionKey);
+    }
+    /** Start preparing an event payload as soon as its frame is decoded. */
+    prepareEvent(event) {
+        const preparation = this.prepareEventIfMissing(event);
+        // Streaming preparation is speculative. Its ordered consumer observes the
+        // original rejection and makes that cache entry retryable.
+        void preparation?.catch(() => { });
+    }
+    /**
+     * 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 workflowInput = this.startPreparation(this.workflowInputKey(workflowRun.runId), workflowRun.input);
+        if (workflowInput)
+            preparations.push(workflowInput);
+        for (let index = this.nextUnscannedEventIndex; index < events.length; index++) {
+            const event = events[index];
+            const preparation = this.prepareEventIfMissing(event);
+            if (preparation)
+                preparations.push(preparation);
+        }
+        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);
+    }
+    /** Rescan the next event log after an authoritative replacement. */
+    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 always run `hydrate` again to produce a fresh VM-specific value;
+     * every primitive is safe to reuse directly.
+     */
+    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, await this.encryptionKey);
+    }
+    /** Start one event's binary payload unless another path already did. */
+    prepareEventIfMissing(event) {
+        let field;
+        let value;
+        switch (event.eventType) {
+            case 'run_created':
+                return this.startPreparation(this.workflowInputKey(event.runId), event.eventData.input);
+            case 'run_started':
+                return this.startPreparation(this.workflowInputKey(event.runId), event.eventData?.input);
+            case 'step_completed':
+                field = 'result';
+                value = event.eventData?.result;
+                break;
+            case 'step_failed':
+                field = 'error';
+                value = event.eventData?.error;
+                break;
+            case 'hook_received':
+                field = 'payload';
+                value = event.eventData?.payload;
+                break;
+            default:
+                return undefined;
+        }
+        return this.startPreparation(this.eventPayloadKey(event.eventId, field), value);
+    }
+    startPreparation(cacheKey, value) {
+        if (!(value instanceof Uint8Array) || this.preparedPayloads.has(cacheKey)) {
+            return undefined;
+        }
+        return this.ensurePreparation(cacheKey, value);
+    }
+    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\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  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 and memoized primitive step results remain\n * resident for the invocation lifetime. Their memory never crosses workflow\n * 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 readonly encryptionKey: Promise<PayloadKey | undefined>;\n  private nextUnscannedEventIndex = 0;\n\n  constructor(\n    encryptionKey: PayloadKey | undefined | Promise<PayloadKey | undefined>,\n    private readonly preparer: ReplayPayloadPreparer = prepareReplayPayload\n  ) {\n    this.encryptionKey = Promise.resolve(encryptionKey);\n  }\n\n  /** Start preparing an event payload as soon as its frame is decoded. */\n  prepareEvent(event: Event): void {\n    const preparation = this.prepareEventIfMissing(event);\n    // Streaming preparation is speculative. Its ordered consumer observes the\n    // original rejection and makes that cache entry retryable.\n    void preparation?.catch(() => {});\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 workflowInput = this.startPreparation(\n      this.workflowInputKey(workflowRun.runId),\n      workflowRun.input\n    );\n    if (workflowInput) preparations.push(workflowInput);\n    for (\n      let index = this.nextUnscannedEventIndex;\n      index < events.length;\n      index++\n    ) {\n      const event = events[index];\n      const preparation = this.prepareEventIfMissing(event);\n      if (preparation) preparations.push(preparation);\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  /** Rescan the next event log after an authoritative replacement. */\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 always run `hydrate` again to produce a fresh VM-specific value;\n   * every primitive is safe to reuse directly.\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, await this.encryptionKey);\n  }\n\n  /** Start one event's binary payload unless another path already did. */\n  private prepareEventIfMissing(\n    event: Event\n  ): Promise<PreparedReplayPayload> | undefined {\n    let field: ReplayPayloadField;\n    let value: unknown;\n    switch (event.eventType) {\n      case 'run_created':\n        return this.startPreparation(\n          this.workflowInputKey(event.runId),\n          event.eventData.input\n        );\n      case 'run_started':\n        return this.startPreparation(\n          this.workflowInputKey(event.runId),\n          event.eventData?.input\n        );\n      case 'step_completed':\n        field = 'result';\n        value = event.eventData?.result;\n        break;\n      case 'step_failed':\n        field = 'error';\n        value = event.eventData?.error;\n        break;\n      case 'hook_received':\n        field = 'payload';\n        value = event.eventData?.payload;\n        break;\n      default:\n        return undefined;\n    }\n    return this.startPreparation(\n      this.eventPayloadKey(event.eventId, field),\n      value\n    );\n  }\n\n  private startPreparation(\n    cacheKey: string,\n    value: unknown\n  ): Promise<PreparedReplayPayload> | undefined {\n    if (!(value instanceof Uint8Array) || this.preparedPayloads.has(cacheKey)) {\n      return undefined;\n    }\n    return this.ensurePreparation(cacheKey, value);\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,13 @@
+/**
+ * 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 OpenTelemetry `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;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,QAAoB,CAAC"}

package/dist/runtime/compute-instance.js

@@ -0,0 +1,14 @@
+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 OpenTelemetry `faas.instance`
+ * attribute.
+ */
+export const COMPUTE_INSTANCE_ID = `cinst_${ulid()}`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcHV0ZS1pbnN0YW5jZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydW50aW1lL2NvbXB1dGUtaW5zdGFuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUU1Qjs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsU0FBUyxJQUFJLEVBQUUsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdWxpZCB9IGZyb20gJ3VsaWQnO1xuXG4vKipcbiAqIElkZW50aWZpZXIgZm9yIHRoZSBjb21wdXRlIGluc3RhbmNlIChtaWNyb1ZNKSB0aGlzIG1vZHVsZSB3YXMgbG9hZGVkIGludG8uXG4gKlxuICogVmVyY2VsIGV4cG9zZXMgbm8gbmF0aXZlIHBlci1pbnN0YW5jZSBJRCB1bmRlciBGbHVpZCBjb21wdXRlIChgQVdTX0xBTUJEQV8qYFxuICogaXMgYmxvY2tlZCksIHNvIHdlIHN5bnRoZXNpemUgb25lIGF0IG1vZHVsZSBsb2FkOiBhIHByZWZpeGVkIFVMSURcbiAqIChgY2luc3RfPHVsaWQ+YCwgcGVyIHRoZSBgd3J1bl9gL2BzdGVwX2AgY29udmVudGlvbikgd2hvc2UgdGltZXN0YW1wIGlzIHRoZVxuICogaW5zdGFuY2UncyBiaXJ0aCB0aW1lLiBTdGFibGUgZm9yIHRoZSBpbnN0YW5jZSdzIGxpZmUgYW5kIHNoYXJlZCBieSBldmVyeVxuICogaW52b2NhdGlvbiBpdCBoYW5kbGVzLCBpbmNsdWRpbmcgdGhlIGNvbmN1cnJlbnQgb25lcyBGbHVpZCBwYWNrcyBvbnRvIGl0O1xuICogY29sZCBzdGFydHMgbWludCBmcmVzaCBJRHMuIEVtaXR0ZWQgYXMgdGhlIE9wZW5UZWxlbWV0cnkgYGZhYXMuaW5zdGFuY2VgXG4gKiBhdHRyaWJ1dGUuXG4gKi9cbmV4cG9ydCBjb25zdCBDT01QVVRFX0lOU1RBTkNFX0lEID0gYGNpbnN0XyR7dWxpZCgpfWA7XG4iXX0=

package/dist/runtime/constants.d.ts

@@ -1,4 +1,319 @@
 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;
+/**
+ * Upper bound on the serialized step input that resilient step dispatch will
+ * inline into the queue message's `stepInput`.
+ *
+ * Vercel Queues has no hard message-size cap (bodies above its ~256 KB
+ * inline threshold transparently spill to S3-backed storage), so this bound
+ * is a cost/latency choice, not a rejection guard: the message also carries
+ * the runId, stepId, stepName, and trace carrier alongside CBOR framing
+ * overhead, and staying under the queue's inline threshold keeps step
+ * messages on its fast inline path instead of paying an S3 store+fetch
+ * double-hop for bytes that already live in the event log. Above this size
+ * the dispatch falls back to the sequential path (`step_created` write, then
+ * a payload-less queue message).
+ */
+export declare const MAX_RESILIENT_STEP_INPUT_BYTES: number;
+/**
+ * Whether resilient step dispatch is enabled: the suspension handler
+ * parallelizes each newly created step's `step_created` event write with its
+ * step-execution queue publish, carrying the serialized step input in the
+ * queue message (`stepInput`) so the consumer can idempotently re-ensure the
+ * event if the direct write failed transiently. Mirrors the resilient start
+ * (`runInput`) pattern (and the legacy lazy hook resume's `hookInput`, which
+ * current producers no longer send).
+ *
+ * **Off by default.** Enable via `WORKFLOW_RESILIENT_STEP_DISPATCH=1`.
+ *
+ * The queue publish races the create's verdict, and a create can come back
+ * refused: as a duplicate this replay should stop pursuing, or as a stale
+ * write on a World that refuses rather than reports. Either way the message
+ * carrying the payload is already out, so the consumer can materialize a step
+ * whose create was refused, and nothing orders the verdict before the
+ * consumer's redelivery re-ensure. Enabling this trades that window for the
+ * latency the parallel publish saves.
+ */
+export declare function isResilientStepDispatchEnabled(): boolean;
+/**
+ * Whether batched event transitions are enabled: the suspension handler folds
+ * a clean fan-out's `step_created` + `wait_created` writes into one
+ * `world.events.createBatch` call (one durable write, per-event outcomes)
+ * instead of one write per event. Only engages when the World implements the
+ * optional `events.createBatch` AND the run is on slot identity
+ * (specVersion >= 6) AND the suspension carries no attribute/hook writes and
+ * no resilient step dispatch. Everything else keeps the single-event path
+ * byte-for-byte.
+ *
+ * Reads `process.env.WORKFLOW_BATCH_TRANSITIONS` lazily. Default **ON**;
+ * disabled only by an explicit `'0'` / `'false'` (case-insensitive), the
+ * operator escape hatch that restores the exact prior one-write-per-event
+ * path, mirroring `WORKFLOW_TURBO`'s kill-switch shape.
+ */
+export declare function isBatchTransitionsEnabled(): boolean;
+/**
+ * Ceiling on events per `createBatch` call from the batched fan-out fold.
+ * Mirrors the server's transaction budgets with a comfortable margin: each
+ * fan-out event costs 2 transaction items server-side (entity + event row)
+ * against the 100-item DynamoDB cap, and inline payloads count against a
+ * 768 KB byte budget, so 32 events stays well under both, and a fan-out larger
+ * than this commits in successive batches (split batches lose
+ * cross-batch atomicity, which is exactly today's per-event-write crash
+ * surface, and every batch still converges on retry via per-event 409s).
+ */
+export declare const MAX_BATCH_FANOUT_EVENTS = 32;
+/**
+ * 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 Node.js inline loop retains a suspended workflow VM within one
+ * invocation (default ON). When on, a step- or attribute-driven suspension can
+ * keep the live VM, event consumer, and hydrated state even with open hooks or
+ * waits. The next loop iteration appends newly durable events instead of
+ * rebuilding the `vm.Context` and replaying the whole event log. Hook- or
+ * wait-only suspensions park the invocation, while replay divergence falls back
+ * to the ordinary durable replay path. QuickJS manages its own retained loop.
+ *
+ * `WORKFLOW_RETAINED_VM=0` (or `false`) is the kill switch: every iteration
+ * replays the Node.js engine 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, and 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":"AAsBA,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;AAwB7C;;;;;;;;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;AAEvC;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CA2B1C;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,8BAA8B,QAAa,CAAC;AAEzD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,8BAA8B,IAAI,OAAO,CAExD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAInD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C;;;;;;;;;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;;;;;;;;;;;;GAYG;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"}