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

package/dist/replay-divergence.d.ts

@@ -0,0 +1,25 @@
+import type { Event } from '@workflow/world';
+import type { EventsConsumer } from './events-consumer.js';
+import type { QueueItem } from './global.js';
+/**
+ * Step, wait, hook and attribute correlation ids share one ULID draw per
+ * entity, prefixed by kind (`step_<ulid>`, `wait_<ulid>`, `hook_<ulid>`,
+ * `attr_<ulid>`). A replay that drew the same ordinal for a different kind of
+ * entity than the one the log recorded there produces an event nobody can
+ * consume, and the decisive fact for diagnosing that is which pending
+ * invocation currently holds the ordinal. This looks it up by the shared ULID
+ * body, so a `wait_created` the log holds at a position where the replay is
+ * waiting on `step_<same ulid>` names that step.
+ */
+export declare function findPendingItemAtOrdinal(invocationsQueue: Map<string, QueueItem>, correlationId: string): QueueItem | undefined;
+/**
+ * The detail appended to a `ReplayDivergenceError` raised because the replay
+ * could not place an event. Callers keep their own leading sentence (tests and
+ * users match on it) and append this after it.
+ *
+ * Example:
+ * `pending at this id: step drainStep (step_01K…). consumer: index=41,
+ * length=44, parked=0, lastConsumed=evnt_01K…`
+ */
+export declare function describeDivergenceContext(event: Event, invocationsQueue: Map<string, QueueItem>, eventsConsumer: EventsConsumer): string;
+//# sourceMappingURL=replay-divergence.d.ts.map

package/dist/replay-divergence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-divergence.d.ts","sourceRoot":"","sources":["../src/replay-divergence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EACxC,aAAa,EAAE,MAAM,GACpB,SAAS,GAAG,SAAS,CASvB;AAsBD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,KAAK,EACZ,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EACxC,cAAc,EAAE,cAAc,GAC7B,MAAM,CASR"}

package/dist/replay-divergence.js

@@ -0,0 +1,61 @@
+/**
+ * Step, wait, hook and attribute correlation ids share one ULID draw per
+ * entity, prefixed by kind (`step_<ulid>`, `wait_<ulid>`, `hook_<ulid>`,
+ * `attr_<ulid>`). A replay that drew the same ordinal for a different kind of
+ * entity than the one the log recorded there produces an event nobody can
+ * consume, and the decisive fact for diagnosing that is which pending
+ * invocation currently holds the ordinal. This looks it up by the shared ULID
+ * body, so a `wait_created` the log holds at a position where the replay is
+ * waiting on `step_<same ulid>` names that step.
+ */
+export function findPendingItemAtOrdinal(invocationsQueue, correlationId) {
+    const exact = invocationsQueue.get(correlationId);
+    if (exact)
+        return exact;
+    const body = ordinalBody(correlationId);
+    if (!body)
+        return undefined;
+    for (const [id, item] of invocationsQueue) {
+        if (ordinalBody(id) === body)
+            return item;
+    }
+    return undefined;
+}
+function ordinalBody(correlationId) {
+    const at = correlationId.indexOf('_');
+    return at === -1 ? undefined : correlationId.slice(at + 1);
+}
+function describeQueueItem(item) {
+    switch (item.type) {
+        case 'step':
+            return `step ${item.stepName} (${item.correlationId})`;
+        case 'hook':
+            return `hook (${item.correlationId})`;
+        case 'wait':
+            return `wait (${item.correlationId})`;
+        case 'attribute':
+            return `attribute (${item.correlationId})`;
+    }
+    item;
+    return 'unknown';
+}
+/**
+ * The detail appended to a `ReplayDivergenceError` raised because the replay
+ * could not place an event. Callers keep their own leading sentence (tests and
+ * users match on it) and append this after it.
+ *
+ * Example:
+ * `pending at this id: step drainStep (step_01K…). consumer: index=41,
+ * length=44, parked=0, lastConsumed=evnt_01K…`
+ */
+export function describeDivergenceContext(event, invocationsQueue, eventsConsumer) {
+    const pending = event.correlationId
+        ? findPendingItemAtOrdinal(invocationsQueue, event.correlationId)
+        : undefined;
+    const snapshot = eventsConsumer.describe();
+    return [
+        `pending at this id: ${pending ? describeQueueItem(pending) : 'none'}.`,
+        `consumer: index=${snapshot.index}, length=${snapshot.length}, parked=${snapshot.parked}, lastConsumed=${snapshot.lastConsumedEventId ?? 'none'}`,
+    ].join(' ');
+}
+//# sourceMappingURL=data:application/json;base64,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

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=