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

package/dist/workflow/index.d.ts

@@ -5,6 +5,7 @@ export { sleep } from '../sleep.js';
 export { createHook, createWebhook } from './create-hook.js';
 export { defineHook } from './define-hook.js';
 export { getWorkflowMetadata } from './get-workflow-metadata.js';
+export { type SetAttributesOptions, setAttributes, } from './set-attributes.js';
 export { getWritable } from './writable-stream.js';
 export declare function getStepMetadata(): StepMetadata;
 export declare function resumeHook(): void;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAInD,wBAAgB,eAAe,IAAI,YAAY,CAI9C;AACD,wBAAgB,UAAU,SAIzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EACL,KAAK,oBAAoB,EACzB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAInD,wBAAgB,eAAe,IAAI,YAAY,CAM9C;AACD,wBAAgB,UAAU,SAMzB"}

package/dist/workflow/index.js

@@ -1,15 +1,17 @@
+import { throwNotInStepContext, throwUnavailableInWorkflowContext, } from '../context-errors.js';
 export { FatalError, RetryableError, } from '@workflow/errors';
 export { sleep } from '../sleep.js';
 export { createHook, createWebhook } from './create-hook.js';
 export { defineHook } from './define-hook.js';
 export { getWorkflowMetadata } from './get-workflow-metadata.js';
+export { setAttributes, } from './set-attributes.js';
 export { getWritable } from './writable-stream.js';
 // workflows can't use these functions, but we still need to provide
 // the export so bundling doesn't fail when step and workflow are in same file
 export function getStepMetadata() {
-    throw new Error('`getStepMetadata()` can only be called inside a step function');
+    throwNotInStepContext('getStepMetadata()', 'https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata', getStepMetadata);
 }
 export function resumeHook() {
-    throw new Error('`resumeHook()` can only be called from outside a workflow function');
+    throwUnavailableInWorkflowContext('resumeHook()', 'https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook', resumeHook);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd29ya2Zsb3cvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUNMLFVBQVUsRUFDVixjQUFjLEdBRWYsTUFBTSxrQkFBa0IsQ0FBQztBQUUxQixPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxVQUFVLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDN0QsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVuRCxvRUFBb0U7QUFDcEUsOEVBQThFO0FBQzlFLE1BQU0sVUFBVSxlQUFlO0lBQzdCLE1BQU0sSUFBSSxLQUFLLENBQ2IsK0RBQStELENBQ2hFLENBQUM7QUFDSixDQUFDO0FBQ0QsTUFBTSxVQUFVLFVBQVU7SUFDeEIsTUFBTSxJQUFJLEtBQUssQ0FDYixvRUFBb0UsQ0FDckUsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFN0ZXBNZXRhZGF0YSB9IGZyb20gJy4uL3N0ZXAvZ2V0LXN0ZXAtbWV0YWRhdGEuanMnO1xuXG5leHBvcnQge1xuICBGYXRhbEVycm9yLFxuICBSZXRyeWFibGVFcnJvcixcbiAgdHlwZSBSZXRyeWFibGVFcnJvck9wdGlvbnMsXG59IGZyb20gJ0B3b3JrZmxvdy9lcnJvcnMnO1xuZXhwb3J0IHR5cGUgeyBIb29rLCBIb29rT3B0aW9ucyB9IGZyb20gJy4uL2NyZWF0ZS1ob29rLmpzJztcbmV4cG9ydCB7IHNsZWVwIH0gZnJvbSAnLi4vc2xlZXAuanMnO1xuZXhwb3J0IHsgY3JlYXRlSG9vaywgY3JlYXRlV2ViaG9vayB9IGZyb20gJy4vY3JlYXRlLWhvb2suanMnO1xuZXhwb3J0IHsgZGVmaW5lSG9vayB9IGZyb20gJy4vZGVmaW5lLWhvb2suanMnO1xuZXhwb3J0IHsgZ2V0V29ya2Zsb3dNZXRhZGF0YSB9IGZyb20gJy4vZ2V0LXdvcmtmbG93LW1ldGFkYXRhLmpzJztcbmV4cG9ydCB7IGdldFdyaXRhYmxlIH0gZnJvbSAnLi93cml0YWJsZS1zdHJlYW0uanMnO1xuXG4vLyB3b3JrZmxvd3MgY2FuJ3QgdXNlIHRoZXNlIGZ1bmN0aW9ucywgYnV0IHdlIHN0aWxsIG5lZWQgdG8gcHJvdmlkZVxuLy8gdGhlIGV4cG9ydCBzbyBidW5kbGluZyBkb2Vzbid0IGZhaWwgd2hlbiBzdGVwIGFuZCB3b3JrZmxvdyBhcmUgaW4gc2FtZSBmaWxlXG5leHBvcnQgZnVuY3Rpb24gZ2V0U3RlcE1ldGFkYXRhKCk6IFN0ZXBNZXRhZGF0YSB7XG4gIHRocm93IG5ldyBFcnJvcihcbiAgICAnYGdldFN0ZXBNZXRhZGF0YSgpYCBjYW4gb25seSBiZSBjYWxsZWQgaW5zaWRlIGEgc3RlcCBmdW5jdGlvbidcbiAgKTtcbn1cbmV4cG9ydCBmdW5jdGlvbiByZXN1bWVIb29rKCkge1xuICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgJ2ByZXN1bWVIb29rKClgIGNhbiBvbmx5IGJlIGNhbGxlZCBmcm9tIG91dHNpZGUgYSB3b3JrZmxvdyBmdW5jdGlvbidcbiAgKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/workflow/set-attributes.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Options accepted by `setAttributes`.
+ */
+export interface SetAttributesOptions {
+    /**
+     * Permit attribute keys that start with the reserved `$` prefix.
+     * **Default: `false`.**
+     *
+     * The `$` namespace is reserved for framework and library code that
+     * is built on top of the workflow SDK (telemetry, agent metadata,
+     * platform-emitted tags, etc.). User code MUST NOT write keys in
+     * this namespace; validation rejects them so accidental collisions
+     * with tooling-owned keys can't slip through.
+     *
+     * Only flip this to `true` if your caller is itself a framework or
+     * library that owns a `$`-prefixed sub-namespace and knows the
+     * conventions of any other tools writing into it. Misuse can
+     * conflict with observability surfaces, agent dashboards, or future
+     * platform features that rely on the reserved namespace.
+     */
+    allowReservedAttributes?: boolean;
+}
+/**
+ * Attach plaintext string key/value metadata to the current workflow run.
+ *
+ * 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
+ * `SetAttributesOptions` for the trade-offs.
+ *
+ * **WARNING**: Calling e.g.
+ * `Promise.all([setAttributes({ a: '1' }), setAttributes({ a: '2' })])`
+ * is not guaranteed to be ordered consistently, but the equivalent
+ * sequential `.then()` chain is.
+ *
+ * @example
+ * ```ts
+ * import { setAttributes } from 'workflow';
+ *
+ * export async function myWorkflow() {
+ *   'use workflow';
+ *   await setAttributes({ phase: 'init' });
+ *   // ... work ...
+ *   await setAttributes({ phase: 'done', orderId: 'ord_123' });
+ *   await setAttributes({ orderId: undefined }); // remove
+ * }
+ * ```
+ *
+ * @example Framework / library code writing into the reserved namespace.
+ * ```ts
+ * await setAttributes(
+ *   { '$agent.kind': 'durable-agent' },
+ *   { allowReservedAttributes: true }
+ * );
+ * ```
+ */
+export declare function setAttributes(attrs: Record<string, string | undefined>, options?: SetAttributesOptions): Promise<void>;
+//# sourceMappingURL=set-attributes.d.ts.map

package/dist/workflow/set-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-attributes.d.ts","sourceRoot":"","sources":["../../src/workflow/set-attributes.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACzC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CAsBf"}

package/dist/workflow/set-attributes.js

@@ -0,0 +1,60 @@
+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.
+ *
+ * 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
+ * `SetAttributesOptions` for the trade-offs.
+ *
+ * **WARNING**: Calling e.g.
+ * `Promise.all([setAttributes({ a: '1' }), setAttributes({ a: '2' })])`
+ * is not guaranteed to be ordered consistently, but the equivalent
+ * sequential `.then()` chain is.
+ *
+ * @example
+ * ```ts
+ * import { setAttributes } from 'workflow';
+ *
+ * export async function myWorkflow() {
+ *   'use workflow';
+ *   await setAttributes({ phase: 'init' });
+ *   // ... work ...
+ *   await setAttributes({ phase: 'done', orderId: 'ord_123' });
+ *   await setAttributes({ orderId: undefined }); // remove
+ * }
+ * ```
+ *
+ * @example Framework / library code writing into the reserved namespace.
+ * ```ts
+ * await setAttributes(
+ *   { '$agent.kind': 'durable-agent' },
+ *   { allowReservedAttributes: true }
+ * );
+ * ```
+ */
+export async function setAttributes(attrs, options = {}) {
+    const changes = normalizeAttributeChanges(attrs, options);
+    if (changes.length === 0)
+        return;
+    const allowReservedAttributes = options.allowReservedAttributes === true;
+    const dispatchSetAttributes = globalThis[WORKFLOW_SET_ATTRIBUTES];
+    if (!dispatchSetAttributes) {
+        throw new FatalError('setAttributes() called outside a workflow runtime context. ' +
+            'It must be called from within a workflow body (`use workflow`).');
+    }
+    await dispatchSetAttributes(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,CAoIjB"}

package/dist/workflow/sleep.js

@@ -1,12 +1,12 @@
-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();
-        const correlationId = `wait_${ctx.generateUlid()}`;
+        const correlationId = `wait_${ctx.generateCorrelationId('wait')}`;
         // Calculate the resume time
         const resumeAt = parseDurationToDate(param);
         // Add wait to invocations queue (using Map for O(1) operations)
@@ -42,22 +42,71 @@ 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, or await on a branch
+                // parallel to one awaiting a step. 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 or step result is delivered only after this wait.
+                //  - Before resolving, defer behind every EARLIER-in-log HOOK and STEP
+                //    delivery so this wait does not preempt one the committed log
+                //    ordered first. Then mark this wait delivered to release the later
+                //    deliveries gated on it.
+                const eventIndex = ctx.eventsConsumer.eventIndex;
+                const barrier = registerDeliveryBarrier(ctx, eventIndex, 'wait');
+                // The deferral is captured HERE, while consuming the event, and not
+                // after the queue tail below — same reasoning as step.ts. An earlier
+                // step or hook whose hydration slot sits in that tail has usually
+                // delivered, and so deregistered its barrier, by the time the tail
+                // resolves. Read then, it would be invisible and this wait would skip
+                // both the gate AND `awaitEarlierDeliveries`' macrotask yield, letting
+                // it overtake the branch that earlier delivery just woke. Every event
+                // in one drain window is consumed before any slot runs, so capturing
+                // at consumption time sees all of them.
+                const earlierDelivered = awaitEarlierDeliveries(ctx, eventIndex, 'wait');
+                // Defer + resolve in a DETACHED promise (not chained onto the serial
+                // `promiseQueue`). `awaitEarlierDeliveries` may wait on an earlier
+                // hook or step 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(() => earlierDelivered)
+                    .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":"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","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.generateCorrelationId('wait')}`;\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, or await on a branch\n        // parallel to one awaiting a step. Order it deterministically by\n        // event-log position (see `pendingDeliveryBarriers`):\n        //  - Register a 'wait' barrier at this event's index so a LATER-in-log\n        //    hook payload or step result is delivered only after this wait.\n        //  - Before resolving, defer behind every EARLIER-in-log HOOK and STEP\n        //    delivery so this wait does not preempt one the committed log\n        //    ordered first. Then mark this wait delivered to release the later\n        //    deliveries gated on it.\n        const eventIndex = ctx.eventsConsumer.eventIndex;\n        const barrier = registerDeliveryBarrier(ctx, eventIndex, 'wait');\n        // The deferral is captured HERE, while consuming the event, and not\n        // after the queue tail below — same reasoning as step.ts. An earlier\n        // step or hook whose hydration slot sits in that tail has usually\n        // delivered, and so deregistered its barrier, by the time the tail\n        // resolves. Read then, it would be invisible and this wait would skip\n        // both the gate AND `awaitEarlierDeliveries`' macrotask yield, letting\n        // it overtake the branch that earlier delivery just woke. Every event\n        // in one drain window is consumed before any slot runs, so capturing\n        // at consumption time sees all of them.\n        const earlierDelivered = awaitEarlierDeliveries(\n          ctx,\n          eventIndex,\n          'wait'\n        );\n        // Defer + resolve in a DETACHED promise (not chained onto the serial\n        // `promiseQueue`). `awaitEarlierDeliveries` may wait on an earlier\n        // hook or step 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(() => earlierDelivered)\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 the configured server-only world package 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 the configured server-only world package 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGQtaW5pdC1zdHViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3dvcmtmbG93L3dvcmxkLWluaXQtc3R1Yi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7O0dBWUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFZNL3N0ZXAtYnVuZGxlIHN0dWIgZm9yIGBAd29ya2Zsb3cvY29yZS9ydW50aW1lL3dvcmxkLWluaXRgLlxuICpcbiAqIFJlc29sdmVkIHZpYSB0aGUgYHdvcmtmbG93YCBleHBvcnQgY29uZGl0aW9uLiBFbXB0eSBieSBkZXNpZ24g4oCUIHRoZSBob3N0XG4gKiBpcyByZXNwb25zaWJsZSBmb3IgbG9hZGluZyBgd29ybGQudHNgIGFuZCBwb3B1bGF0aW5nIHRoZSBnbG9iYWxUaGlzXG4gKiB3b3JsZCBjYWNoZSBiZWZvcmUgYW55IFZNIG9yIHN0ZXAgY29kZSBleGVjdXRlcy4gSW5jbHVkaW5nIHRoaXMgbW9kdWxlXG4gKiAocmF0aGVyIHRoYW4gbGV0dGluZyB0aGUgcmVzb2x2ZXIgZmFsbCB0aHJvdWdoIHRvIHRoZSBob3N0IGZpbGUpIGtlZXBzXG4gKiBgd29ybGQudHNgIGFuZCB0aGUgY29uZmlndXJlZCBzZXJ2ZXItb25seSB3b3JsZCBwYWNrYWdlIG91dCBvZiB0aGVcbiAqIHdvcmtmbG93IHNhbmRib3guXG4gKlxuICogU2VlIGAuLi9ydW50aW1lL3dvcmxkLWluaXQudHNgIGZvciB0aGUgaG9zdC1zaWRlIGltcGxlbWVudGF0aW9uIGFuZCB0aGVcbiAqIGZ1bGwgcmF0aW9uYWxlLlxuICovXG5cbmV4cG9ydCB7fTtcbiJdfQ==

package/dist/workflow.d.ts

@@ -1,4 +1,70 @@
-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 { Event, WorkflowRun, WorldCapabilities } from '@workflow/world';
+import { WorkflowSuspension } from './global.js';
+import { ReplayPayloadCache } from './replay-payload-cache.js';
+import type { PayloadKey } from './serialization/encryption.js';
+/** Everything needed to cold-start a workflow VM over an event log. */
+interface WorkflowSessionOptions {
+    readonly workflowCode: string;
+    readonly workflowRun: WorkflowRun;
+    readonly events: Event[];
+    readonly encryptionKey: PayloadKey | undefined;
+    readonly replayPayloadCache: ReplayPayloadCache;
+    readonly runReadyBarrier?: Promise<unknown>;
+    readonly worldCapabilities?: WorldCapabilities;
+}
+/**
+ * A live workflow VM, parked at a suspension boundary. `resume` advances it
+ * by appending events instead of replaying from scratch.
+ */
+export interface WorkflowSession {
+    readonly workflowRun: WorkflowRun;
+    readonly argumentCount: number;
+    resume(events: Event[]): Promise<WorkflowResumeResult>;
+}
+/** A finished execution attempt: the workflow's output or a live boundary. */
+export type WorkflowResult = {
+    readonly type: 'completed';
+    readonly output: unknown;
+    /** `typeof` the raw return value, for telemetry. */
+    readonly resultType: string;
+} | {
+    readonly type: 'suspended';
+    readonly suspension: WorkflowSuspension;
+    readonly session: WorkflowSession;
+};
+/**
+ * `resume` can additionally decline — `{ type: 'replay' }` means "this
+ * session is unusable, cold-replay instead". A fresh replay never declines.
+ */
+export type WorkflowResumeResult = WorkflowResult | {
+    readonly type: 'replay';
+};
+/** Cold-start: build a fresh VM session and replay it over `events`. */
+export declare function replayWorkflow(options: WorkflowSessionOptions): Promise<WorkflowResult>;
+/** Warm-start: advance a retained session by appending events. */
+export declare function resumeWorkflow(session: WorkflowSession, events: Event[]): Promise<WorkflowResumeResult>;
+/**
+ * Single-shot replay: execute the workflow over `events` and either return
+ * its output or throw its suspension. Kept for the extensive existing test
+ * suites — production code goes through `replayWorkflow`/`resumeWorkflow`.
+ */
+export declare function runWorkflow(workflowCode: string, workflowRun: WorkflowRun, events: Event[], encryptionKey: PayloadKey | undefined, 
+/**
+ * Optional per-run cache for replay payload preparation and immutable final
+ * values. Owned by the inline execution loop for this invocation.
+ */
+replayPayloadCache?: ReplayPayloadCache, 
+/**
+ * Turbo mode only: resolves once the backgrounded `run_started` has landed.
+ * Threaded into the end-of-run drain so fire-and-forget `*_created` writes
+ * committed at workflow completion order after the run's creation. Undefined
+ * outside turbo, where `run_started` is awaited up front.
+ */
+runReadyBarrier?: Promise<unknown>, 
+/**
+ * Features supported by the World executing this workflow. Missing
+ * capabilities are treated as unsupported.
+ */
+worldCapabilities?: WorldCapabilities): Promise<Uint8Array | unknown>;
+export {};
 //# 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":"AAaA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAU7E,OAAO,EAAW,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAG1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAK/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AA4FhE,uEAAuE;AACvE,UAAU,sBAAsB;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,UAAU,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAChD,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CAChD;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACxD;AAED,8EAA8E;AAC9E,MAAM,MAAM,cAAc,GACtB;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,oDAAoD;IACpD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;CACnC,CAAC;AAEN;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,cAAc,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAYhF,wEAAwE;AACxE,wBAAgB,cAAc,CAC5B,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,cAAc,CAAC,CAazB;AAED,kEAAkE;AAClE,wBAAgB,cAAc,CAC5B,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,KAAK,EAAE,GACd,OAAO,CAAC,oBAAoB,CAAC,CAa/B;AAkCD;;;;GAIG;AACH,wBAAsB,WAAW,CAC/B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,KAAK,EAAE,EACf,aAAa,EAAE,UAAU,GAAG,SAAS;AACrC;;;GAGG;AACH,kBAAkB,GAAE,kBAEnB;AACD;;;;;GAKG;AACH,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;AAClC;;;GAGG;AACH,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAY/B"}