@workflow/core 5.0.0-beta.2 → 5.0.0-beta.21

package/dist/workflow/set-attributes.js

@@ -0,0 +1,65 @@
+import { FatalError } from '@workflow/errors';
+import { normalizeAttributeChanges } from '../attribute-changes.js';
+import { WORKFLOW_SET_ATTRIBUTES } from '../symbols.js';
+/**
+ * Attach plaintext string key/value metadata to the current workflow run.
+ *
+ * **EXPERIMENTAL.** The `experimental_` prefix is deliberate — the
+ * shape, semantics, and dispatch path are likely to change before this
+ * is renamed to a stable export. Use only when you can absorb a
+ * breaking rename later.
+ *
+ * Callable only from a workflow body (`'use workflow'`). The call is
+ * dispatched as a native `attr_set` event and materialized on the run.
+ *
+ * Validation runs in the VM (cheap, deterministic) before event
+ * dispatch - violations throw `FatalError` without writing an event. An
+ * empty record is a no-op. `value: undefined` removes the key from the
+ * run's attribute map.
+ *
+ * **Reserved namespace.** Keys starting with `$` are reserved for
+ * framework/library code (telemetry, agent metadata, etc.). User code
+ * trying to write a `$`-prefixed key throws `FatalError`. If you are a
+ * framework author and need to set a reserved key, pass
+ * `{ allowReservedAttributes: true }` as the second argument — see
+ * `ExperimentalSetAttributesOptions` for the trade-offs.
+ *
+ * **WARNING**: While this feature is experimental, calling e.g.
+ * `Promise.all([experimental_setAttributes({ a: '1' }), experimental_setAttributes({ a: '2' })])`
+ * is not guaranteed to be ordered consistently, but the equivalent
+ * sequential `.then()` chain is.
+ *
+ * @example
+ * ```ts
+ * import { experimental_setAttributes } from 'workflow';
+ *
+ * export async function myWorkflow() {
+ *   'use workflow';
+ *   await experimental_setAttributes({ phase: 'init' });
+ *   // ... work ...
+ *   await experimental_setAttributes({ phase: 'done', orderId: 'ord_123' });
+ *   await experimental_setAttributes({ orderId: undefined }); // remove
+ * }
+ * ```
+ *
+ * @example Framework / library code writing into the reserved namespace.
+ * ```ts
+ * await experimental_setAttributes(
+ *   { '$agent.kind': 'durable-agent' },
+ *   { allowReservedAttributes: true }
+ * );
+ * ```
+ */
+export async function experimental_setAttributes(attrs, options = {}) {
+    const changes = normalizeAttributeChanges(attrs, options);
+    if (changes.length === 0)
+        return;
+    const allowReservedAttributes = options.allowReservedAttributes === true;
+    const setAttributes = globalThis[WORKFLOW_SET_ATTRIBUTES];
+    if (!setAttributes) {
+        throw new FatalError('experimental_setAttributes() called outside a workflow runtime context. ' +
+            'It must be called from within a workflow body (`use workflow`).');
+    }
+    await setAttributes(changes, allowReservedAttributes ? { allowReservedAttributes: true } : {});
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/workflow/sleep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../src/workflow/sleep.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC;AAGtC,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,eAAe,CAAC;AAEvB,wBAAgB,WAAW,CAAC,GAAG,EAAE,2BAA2B,IAExD,OAAO,WAAW,GAAG,IAAI,GAAG,MAAM,KACjC,OAAO,CAAC,IAAI,CAAC,CAsEjB"}
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../src/workflow/sleep.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC;AAGtC,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,eAAe,CAAC;AAEvB,wBAAgB,WAAW,CAAC,GAAG,EAAE,2BAA2B,IAExD,OAAO,WAAW,GAAG,IAAI,GAAG,MAAM,KACjC,OAAO,CAAC,IAAI,CAAC,CAoHjB"}

package/dist/workflow/sleep.js

@@ -1,8 +1,8 @@
-import { WorkflowRuntimeError } from '@workflow/errors';
+import { ReplayDivergenceError } from '@workflow/errors';
 import { parseDurationToDate, withResolvers } from '@workflow/utils';
 import { EventConsumerResult } from '../events-consumer.js';
 import { WorkflowSuspension } from '../global.js';
-import { scheduleWhenIdle, } from '../private.js';
+import { awaitEarlierDeliveries, registerDeliveryBarrier, scheduleWhenIdle, } from '../private.js';
 export function createSleep(ctx) {
     return async function sleepImpl(param) {
         const { promise, resolve } = withResolvers();
@@ -42,22 +42,59 @@ export function createSleep(ctx) {
             }
             // Check for wait_completed event
             if (event.eventType === 'wait_completed') {
+                const eventResumeAt = event.eventData?.resumeAt;
+                if (eventResumeAt !== undefined) {
+                    const queueItem = ctx.invocationsQueue.get(correlationId);
+                    const expectedResumeAt = queueItem && queueItem.type === 'wait'
+                        ? queueItem.resumeAt
+                        : resumeAt;
+                    const eventResumeAtDate = new Date(eventResumeAt);
+                    const eventResumeAtMs = eventResumeAtDate.getTime();
+                    const expectedResumeAtMs = expectedResumeAt.getTime();
+                    const eventResumeAtForMessage = Number.isFinite(eventResumeAtMs)
+                        ? eventResumeAtDate.toISOString()
+                        : String(eventResumeAt);
+                    if (eventResumeAtMs !== expectedResumeAtMs) {
+                        ctx.promiseQueue = ctx.promiseQueue.then(() => {
+                            ctx.onWorkflowError(new ReplayDivergenceError(`Replay divergence: wait_completed event for ${correlationId} has resumeAt "${eventResumeAtForMessage}", but the current wait consumer expects "${expectedResumeAt.toISOString()}"`, { eventId: event.eventId }));
+                        });
+                        return EventConsumerResult.Finished;
+                    }
+                }
                 // Remove this wait from the invocations queue (O(1) delete using Map)
                 ctx.invocationsQueue.delete(correlationId);
-                // Wait has elapsed - chain through promiseQueue to ensure
-                // deterministic ordering of all promise resolutions.
-                ctx.promiseQueue = ctx.promiseQueue.then(() => {
+                // This `wait_completed` is a branch-deciding resolution the workflow
+                // may `Promise.race` against a hook payload. Order it deterministically
+                // by event-log position (see `pendingDeliveryBarriers`):
+                //  - Register a 'wait' barrier at this event's index so a LATER-in-log
+                //    hook payload is delivered only after this wait.
+                //  - Before resolving, defer behind every EARLIER-in-log HOOK delivery
+                //    so this wait does not preempt a hook the committed log ordered
+                //    first. Then mark this wait delivered to release later hooks.
+                const eventIndex = ctx.eventsConsumer.eventIndex;
+                const barrier = registerDeliveryBarrier(ctx, eventIndex, 'wait');
+                // Defer + resolve in a DETACHED promise (not chained onto the serial
+                // `promiseQueue`). `awaitEarlierDeliveries` may wait on an earlier
+                // hook delivery whose own resolution is itself driven by the
+                // promiseQueue; blocking a queue slot on it would deadlock the serial
+                // queue. We still anchor to the queue tail first so prior queued
+                // hydration/ordering work runs in event-log order.
+                const queueAtCompletion = ctx.promiseQueue;
+                void queueAtCompletion
+                    .then(() => awaitEarlierDeliveries(ctx, eventIndex, ['hook']))
+                    .then(() => {
+                    barrier.markDelivered();
                     resolve();
                 });
                 return EventConsumerResult.Finished;
             }
-            // An unexpected event type has been received, this event log looks corrupted. Let's fail immediately.
+            // This replay installed a different consumer than the stored event needs.
             ctx.promiseQueue = ctx.promiseQueue.then(() => {
-                ctx.onWorkflowError(new WorkflowRuntimeError(`Unexpected event type for wait ${correlationId} "${event.eventType}"`));
+                ctx.onWorkflowError(new ReplayDivergenceError(`Replay divergence: Unexpected event type for wait ${correlationId} "${event.eventType}"`, { eventId: event.eventId }));
             });
             return EventConsumerResult.Finished;
         });
         return promise;
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sleep.js","sourceRoot":"","sources":["../../src/workflow/sleep.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAgC,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,gBAAgB,GAEjB,MAAM,eAAe,CAAC;AAEvB,MAAM,UAAU,WAAW,CAAC,GAAgC;IAC1D,OAAO,KAAK,UAAU,SAAS,CAC7B,KAAkC;QAElC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,aAAa,EAAQ,CAAC;QACnD,MAAM,aAAa,GAAG,QAAQ,GAAG,CAAC,YAAY,EAAE,EAAE,CAAC;QAEnD,4BAA4B;QAC5B,MAAM,QAAQ,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAE5C,gEAAgE;QAChE,MAAM,QAAQ,GAA4B;YACxC,IAAI,EAAE,MAAM;YACZ,aAAa;YACb,QAAQ;SACT,CAAC;QACF,GAAG,CAAC,gBAAgB,CAAC,GAAG,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;QAElD,GAAG,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACrC,+DAA+D;YAC/D,4CAA4C;YAC5C,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE;oBACzB,GAAG,CAAC,eAAe,CACjB,IAAI,kBAAkB,CAAC,GAAG,CAAC,gBAAgB,EAAE,GAAG,CAAC,UAAU,CAAC,CAC7D,CAAC;gBACJ,CAAC,CAAC,CAAC;gBACH,OAAO,mBAAmB,CAAC,WAAW,CAAC;YACzC,CAAC;YAED,IAAI,KAAK,CAAC,aAAa,KAAK,aAAa,EAAE,CAAC;gBAC1C,uFAAuF;gBACvF,OAAO,mBAAmB,CAAC,WAAW,CAAC;YACzC,CAAC;YAED,6EAA6E;YAC7E,IAAI,KAAK,CAAC,SAAS,KAAK,cAAc,EAAE,CAAC;gBACvC,uEAAuE;gBACvE,wBAAwB;gBACxB,MAAM,SAAS,GAAG,GAAG,CAAC,gBAAgB,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;gBAC1D,IAAI,SAAS,IAAI,SAAS,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;oBAC3C,SAAS,CAAC,eAAe,GAAG,IAAI,CAAC;oBACjC,SAAS,CAAC,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC;gBAChD,CAAC;gBACD,OAAO,mBAAmB,CAAC,QAAQ,CAAC;YACtC,CAAC;YAED,iCAAiC;YACjC,IAAI,KAAK,CAAC,SAAS,KAAK,gBAAgB,EAAE,CAAC;gBACzC,MAAM,aAAa,GAAG,KAAK,CAAC,SAAS,EAAE,QAAQ,CAAC;gBAChD,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;oBAChC,MAAM,SAAS,GAAG,GAAG,CAAC,gBAAgB,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;oBAC1D,MAAM,gBAAgB,GACpB,SAAS,IAAI,SAAS,CAAC,IAAI,KAAK,MAAM;wBACpC,CAAC,CAAC,SAAS,CAAC,QAAQ;wBACpB,CAAC,CAAC,QAAQ,CAAC;oBACf,MAAM,iBAAiB,GAAG,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC;oBAClD,MAAM,eAAe,GAAG,iBAAiB,CAAC,OAAO,EAAE,CAAC;oBACpD,MAAM,kBAAkB,GAAG,gBAAgB,CAAC,OAAO,EAAE,CAAC;oBACtD,MAAM,uBAAuB,GAAG,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC;wBAC9D,CAAC,CAAC,iBAAiB,CAAC,WAAW,EAAE;wBACjC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;oBAE1B,IAAI,eAAe,KAAK,kBAAkB,EAAE,CAAC;wBAC3C,GAAG,CAAC,YAAY,GAAG,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,EAAE;4BAC5C,GAAG,CAAC,eAAe,CACjB,IAAI,qBAAqB,CACvB,+CAA+C,aAAa,kBAAkB,uBAAuB,6CAA6C,gBAAgB,CAAC,WAAW,EAAE,GAAG,EACnL,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAC3B,CACF,CAAC;wBACJ,CAAC,CAAC,CAAC;wBACH,OAAO,mBAAmB,CAAC,QAAQ,CAAC;oBACtC,CAAC;gBACH,CAAC;gBAED,sEAAsE;gBACtE,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;gBAE3C,qEAAqE;gBACrE,wEAAwE;gBACxE,yDAAyD;gBACzD,uEAAuE;gBACvE,qDAAqD;gBACrD,uEAAuE;gBACvE,oEAAoE;gBACpE,kEAAkE;gBAClE,MAAM,UAAU,GAAG,GAAG,CAAC,cAAc,CAAC,UAAU,CAAC;gBACjD,MAAM,OAAO,GAAG,uBAAuB,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;gBACjE,qEAAqE;gBACrE,mEAAmE;gBACnE,6DAA6D;gBAC7D,sEAAsE;gBACtE,iEAAiE;gBACjE,mDAAmD;gBACnD,MAAM,iBAAiB,GAAG,GAAG,CAAC,YAAY,CAAC;gBAC3C,KAAK,iBAAiB;qBACnB,IAAI,CAAC,GAAG,EAAE,CAAC,sBAAsB,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;qBAC7D,IAAI,CAAC,GAAG,EAAE;oBACT,OAAO,CAAC,aAAa,EAAE,CAAC;oBACxB,OAAO,EAAE,CAAC;gBACZ,CAAC,CAAC,CAAC;gBACL,OAAO,mBAAmB,CAAC,QAAQ,CAAC;YACtC,CAAC;YAED,0EAA0E;YAC1E,GAAG,CAAC,YAAY,GAAG,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC5C,GAAG,CAAC,eAAe,CACjB,IAAI,qBAAqB,CACvB,qDAAqD,aAAa,KAAK,KAAK,CAAC,SAAS,GAAG,EACzF,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAC3B,CACF,CAAC;YACJ,CAAC,CAAC,CAAC;YACH,OAAO,mBAAmB,CAAC,QAAQ,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import { ReplayDivergenceError } from '@workflow/errors';\nimport { parseDurationToDate, withResolvers } from '@workflow/utils';\nimport type { StringValue } from 'ms';\nimport { EventConsumerResult } from '../events-consumer.js';\nimport { type WaitInvocationQueueItem, WorkflowSuspension } from '../global.js';\nimport {\n  awaitEarlierDeliveries,\n  registerDeliveryBarrier,\n  scheduleWhenIdle,\n  type WorkflowOrchestratorContext,\n} from '../private.js';\n\nexport function createSleep(ctx: WorkflowOrchestratorContext) {\n  return async function sleepImpl(\n    param: StringValue | Date | number\n  ): Promise<void> {\n    const { promise, resolve } = withResolvers<void>();\n    const correlationId = `wait_${ctx.generateUlid()}`;\n\n    // Calculate the resume time\n    const resumeAt = parseDurationToDate(param);\n\n    // Add wait to invocations queue (using Map for O(1) operations)\n    const waitItem: WaitInvocationQueueItem = {\n      type: 'wait',\n      correlationId,\n      resumeAt,\n    };\n    ctx.invocationsQueue.set(correlationId, waitItem);\n\n    ctx.eventsConsumer.subscribe((event) => {\n      // If there are no events and we're waiting for wait_completed,\n      // suspend the workflow until the wait fires\n      if (!event) {\n        scheduleWhenIdle(ctx, () => {\n          ctx.onWorkflowError(\n            new WorkflowSuspension(ctx.invocationsQueue, ctx.globalThis)\n          );\n        });\n        return EventConsumerResult.NotConsumed;\n      }\n\n      if (event.correlationId !== correlationId) {\n        // We're not interested in this event - the correlationId belongs to a different entity\n        return EventConsumerResult.NotConsumed;\n      }\n\n      // Check for wait_created event to mark this wait as having the event created\n      if (event.eventType === 'wait_created') {\n        // Mark this wait as having the created event, but keep it in the queue\n        // O(1) lookup using Map\n        const queueItem = ctx.invocationsQueue.get(correlationId);\n        if (queueItem && queueItem.type === 'wait') {\n          queueItem.hasCreatedEvent = true;\n          queueItem.resumeAt = event.eventData.resumeAt;\n        }\n        return EventConsumerResult.Consumed;\n      }\n\n      // Check for wait_completed event\n      if (event.eventType === 'wait_completed') {\n        const eventResumeAt = event.eventData?.resumeAt;\n        if (eventResumeAt !== undefined) {\n          const queueItem = ctx.invocationsQueue.get(correlationId);\n          const expectedResumeAt =\n            queueItem && queueItem.type === 'wait'\n              ? queueItem.resumeAt\n              : resumeAt;\n          const eventResumeAtDate = new Date(eventResumeAt);\n          const eventResumeAtMs = eventResumeAtDate.getTime();\n          const expectedResumeAtMs = expectedResumeAt.getTime();\n          const eventResumeAtForMessage = Number.isFinite(eventResumeAtMs)\n            ? eventResumeAtDate.toISOString()\n            : String(eventResumeAt);\n\n          if (eventResumeAtMs !== expectedResumeAtMs) {\n            ctx.promiseQueue = ctx.promiseQueue.then(() => {\n              ctx.onWorkflowError(\n                new ReplayDivergenceError(\n                  `Replay divergence: wait_completed event for ${correlationId} has resumeAt \"${eventResumeAtForMessage}\", but the current wait consumer expects \"${expectedResumeAt.toISOString()}\"`,\n                  { eventId: event.eventId }\n                )\n              );\n            });\n            return EventConsumerResult.Finished;\n          }\n        }\n\n        // Remove this wait from the invocations queue (O(1) delete using Map)\n        ctx.invocationsQueue.delete(correlationId);\n\n        // This `wait_completed` is a branch-deciding resolution the workflow\n        // may `Promise.race` against a hook payload. Order it deterministically\n        // by event-log position (see `pendingDeliveryBarriers`):\n        //  - Register a 'wait' barrier at this event's index so a LATER-in-log\n        //    hook payload is delivered only after this wait.\n        //  - Before resolving, defer behind every EARLIER-in-log HOOK delivery\n        //    so this wait does not preempt a hook the committed log ordered\n        //    first. Then mark this wait delivered to release later hooks.\n        const eventIndex = ctx.eventsConsumer.eventIndex;\n        const barrier = registerDeliveryBarrier(ctx, eventIndex, 'wait');\n        // Defer + resolve in a DETACHED promise (not chained onto the serial\n        // `promiseQueue`). `awaitEarlierDeliveries` may wait on an earlier\n        // hook delivery whose own resolution is itself driven by the\n        // promiseQueue; blocking a queue slot on it would deadlock the serial\n        // queue. We still anchor to the queue tail first so prior queued\n        // hydration/ordering work runs in event-log order.\n        const queueAtCompletion = ctx.promiseQueue;\n        void queueAtCompletion\n          .then(() => awaitEarlierDeliveries(ctx, eventIndex, ['hook']))\n          .then(() => {\n            barrier.markDelivered();\n            resolve();\n          });\n        return EventConsumerResult.Finished;\n      }\n\n      // This replay installed a different consumer than the stored event needs.\n      ctx.promiseQueue = ctx.promiseQueue.then(() => {\n        ctx.onWorkflowError(\n          new ReplayDivergenceError(\n            `Replay divergence: Unexpected event type for wait ${correlationId} \"${event.eventType}\"`,\n            { eventId: event.eventId }\n          )\n        );\n      });\n      return EventConsumerResult.Finished;\n    });\n\n    return promise;\n  };\n}\n"]}

package/dist/workflow/world-init-stub.d.ts

@@ -0,0 +1,15 @@
+/**
+ * VM/step-bundle stub for `@workflow/core/runtime/world-init`.
+ *
+ * Resolved via the `workflow` export condition. Empty by design — the host
+ * is responsible for loading `world.ts` and populating the globalThis
+ * world cache before any VM or step code executes. Including this module
+ * (rather than letting the resolver fall through to the host file) keeps
+ * `world.ts` and its server-only deps (`@workflow/world-vercel`,
+ * `@workflow/world-local`, `cbor-x`, …) out of the workflow sandbox.
+ *
+ * See `../runtime/world-init.ts` for the host-side implementation and the
+ * full rationale.
+ */
+export {};
+//# sourceMappingURL=world-init-stub.d.ts.map

package/dist/workflow/world-init-stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-init-stub.d.ts","sourceRoot":"","sources":["../../src/workflow/world-init-stub.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,CAAC"}

package/dist/workflow/world-init-stub.js

@@ -0,0 +1,15 @@
+/**
+ * VM/step-bundle stub for `@workflow/core/runtime/world-init`.
+ *
+ * Resolved via the `workflow` export condition. Empty by design — the host
+ * is responsible for loading `world.ts` and populating the globalThis
+ * world cache before any VM or step code executes. Including this module
+ * (rather than letting the resolver fall through to the host file) keeps
+ * `world.ts` and its server-only deps (`@workflow/world-vercel`,
+ * `@workflow/world-local`, `cbor-x`, …) out of the workflow sandbox.
+ *
+ * See `../runtime/world-init.ts` for the host-side implementation and the
+ * full rationale.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGQtaW5pdC1zdHViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3dvcmtmbG93L3dvcmxkLWluaXQtc3R1Yi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7O0dBWUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFZNL3N0ZXAtYnVuZGxlIHN0dWIgZm9yIGBAd29ya2Zsb3cvY29yZS9ydW50aW1lL3dvcmxkLWluaXRgLlxuICpcbiAqIFJlc29sdmVkIHZpYSB0aGUgYHdvcmtmbG93YCBleHBvcnQgY29uZGl0aW9uLiBFbXB0eSBieSBkZXNpZ24g4oCUIHRoZSBob3N0XG4gKiBpcyByZXNwb25zaWJsZSBmb3IgbG9hZGluZyBgd29ybGQudHNgIGFuZCBwb3B1bGF0aW5nIHRoZSBnbG9iYWxUaGlzXG4gKiB3b3JsZCBjYWNoZSBiZWZvcmUgYW55IFZNIG9yIHN0ZXAgY29kZSBleGVjdXRlcy4gSW5jbHVkaW5nIHRoaXMgbW9kdWxlXG4gKiAocmF0aGVyIHRoYW4gbGV0dGluZyB0aGUgcmVzb2x2ZXIgZmFsbCB0aHJvdWdoIHRvIHRoZSBob3N0IGZpbGUpIGtlZXBzXG4gKiBgd29ybGQudHNgIGFuZCBpdHMgc2VydmVyLW9ubHkgZGVwcyAoYEB3b3JrZmxvdy93b3JsZC12ZXJjZWxgLFxuICogYEB3b3JrZmxvdy93b3JsZC1sb2NhbGAsIGBjYm9yLXhgLCDigKYpIG91dCBvZiB0aGUgd29ya2Zsb3cgc2FuZGJveC5cbiAqXG4gKiBTZWUgYC4uL3J1bnRpbWUvd29ybGQtaW5pdC50c2AgZm9yIHRoZSBob3N0LXNpZGUgaW1wbGVtZW50YXRpb24gYW5kIHRoZVxuICogZnVsbCByYXRpb25hbGUuXG4gKi9cblxuZXhwb3J0IHt9O1xuIl19

package/dist/workflow.d.ts

@@ -1,4 +1,13 @@
 import type { Event, WorkflowRun } from '@workflow/world';
 import type { CryptoKey } from './encryption.js';
-export declare function runWorkflow(workflowCode: string, workflowRun: WorkflowRun, events: Event[], encryptionKey: CryptoKey | undefined): Promise<Uint8Array | unknown>;
+import type { StepHydrationCache } from './step-hydration-cache.js';
+export declare function runWorkflow(workflowCode: string, workflowRun: WorkflowRun, events: Event[], encryptionKey: CryptoKey | undefined, 
+/**
+ * Optional per-run cache for hydrated step return values, owned by the inline
+ * replay loop so it survives across the loop's iterations (each of which
+ * creates a fresh context). Memoizes the decrypt + devalue-parse of completed
+ * step results to turn O(N²) replay hydration into O(N). Omitted by callers
+ * that replay only once (then there is nothing to reuse).
+ */
+stepHydrationCache?: StepHydrationCache): Promise<Uint8Array | unknown>;
 //# sourceMappingURL=workflow.d.ts.map

package/dist/workflow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAkEjD,wBAAsB,WAAW,CAC/B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,KAAK,EAAE,EACf,aAAa,EAAE,SAAS,GAAG,SAAS,GACnC,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAorB/B"}
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAI1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAejD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAiGpE,wBAAsB,WAAW,CAC/B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,KAAK,EAAE,EACf,aAAa,EAAE,SAAS,GAAG,SAAS;AACpC;;;;;;GAMG;AACH,kBAAkB,CAAC,EAAE,kBAAkB,GACtC,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAowB/B"}