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

package/dist/define-hook.js

@@ -1,3 +1,4 @@
+import { throwNotInWorkflowContext } from './context-errors.js';
 import { resumeHook } from './runtime/resume-hook.js';
 /**
  * Defines a typed hook for type-safe hook creation and resumption.
@@ -31,10 +32,14 @@ import { resumeHook } from './runtime/resume-hook.js';
  * ```
  */
 export function defineHook({ schema, } = {}) {
+    function create(_options) {
+        // NOTE: `create` is referenced by name (not `this.create`) so the stack
+        // strip still works if the caller destructured the hook (`const { create }
+        // = defineHook(); create()`) — in that case `this` is undefined.
+        throwNotInWorkflowContext('defineHook().create()', 'https://workflow-sdk.dev/docs/api-reference/workflow/define-hook', create);
+    }
     return {
-        create(_options) {
-            throw new Error('`defineHook().create()` can only be called inside a workflow function.');
-        },
+        create,
         async resume(token, payload) {
             if (!schema?.['~standard']) {
                 return await resumeHook(token, payload);
@@ -45,10 +50,20 @@ export function defineHook({ schema, } = {}) {
             }
             // if the `issues` field exists, the validation failed
             if (result.issues) {
-                throw new Error(JSON.stringify(result.issues, null, 2));
+                const lines = result.issues.map((issue) => {
+                    const path = issue.path
+                        ?.map((segment) => typeof segment === 'object' && segment !== null
+                        ? String(segment.key)
+                        : String(segment))
+                        .join('.');
+                    return path
+                        ? `  at "${path}": ${issue.message}`
+                        : `  ${issue.message}`;
+                });
+                throw new Error(`Hook payload did not match the defined schema:\n${lines.join('\n')}`);
             }
             return await resumeHook(token, result.value);
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmaW5lLWhvb2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZGVmaW5lLWhvb2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFaEUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBbUN0RDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBOEJHO0FBQ0gsTUFBTSxVQUFVLFVBQVUsQ0FBMkIsRUFDbkQsTUFBTSxNQUdKLEVBQUU7SUFDSixTQUFTLE1BQU0sQ0FBQyxRQUFzQjtRQUNwQyx3RUFBd0U7UUFDeEUsMkVBQTJFO1FBQzNFLGlFQUFpRTtRQUNqRSx5QkFBeUIsQ0FDdkIsdUJBQXVCLEVBQ3ZCLGtFQUFrRSxFQUNsRSxNQUFNLENBQ1AsQ0FBQztJQUNKLENBQUM7SUFFRCxPQUFPO1FBQ0wsTUFBTTtRQUNOLEtBQUssQ0FBQyxNQUFNLENBQUMsS0FBYSxFQUFFLE9BQWU7WUFDekMsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDLFdBQVcsQ0FBQyxFQUFFLENBQUM7Z0JBQzNCLE9BQU8sTUFBTSxVQUFVLENBQUMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFDO1lBQzFDLENBQUM7WUFFRCxJQUFJLE1BQU0sR0FBRyxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1lBQ25ELElBQUksTUFBTSxZQUFZLE9BQU8sRUFBRSxDQUFDO2dCQUM5QixNQUFNLEdBQUcsTUFBTSxNQUFNLENBQUM7WUFDeEIsQ0FBQztZQUVELHNEQUFzRDtZQUN0RCxJQUFJLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQztnQkFDbEIsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRTtvQkFDeEMsTUFBTSxJQUFJLEdBQUcsS0FBSyxDQUFDLElBQUk7d0JBQ3JCLEVBQUUsR0FBRyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FDaEIsT0FBTyxPQUFPLEtBQUssUUFBUSxJQUFJLE9BQU8sS0FBSyxJQUFJO3dCQUM3QyxDQUFDLENBQUMsTUFBTSxDQUFFLE9BQWdDLENBQUMsR0FBRyxDQUFDO3dCQUMvQyxDQUFDLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUNwQjt5QkFDQSxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7b0JBQ2IsT0FBTyxJQUFJO3dCQUNULENBQUMsQ0FBQyxTQUFTLElBQUksTUFBTSxLQUFLLENBQUMsT0FBTyxFQUFFO3dCQUNwQyxDQUFDLENBQUMsS0FBSyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUM7Z0JBQzNCLENBQUMsQ0FBQyxDQUFDO2dCQUNILE1BQU0sSUFBSSxLQUFLLENBQ2IsbURBQW1ELEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FDdEUsQ0FBQztZQUNKLENBQUM7WUFFRCxPQUFPLE1BQU0sVUFBVSxDQUFVLEtBQUssRUFBRSxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDeEQsQ0FBQztLQUNGLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTdGFuZGFyZFNjaGVtYVYxIH0gZnJvbSAnQHN0YW5kYXJkLXNjaGVtYS9zcGVjJztcbmltcG9ydCB0eXBlIHsgSG9vayBhcyBIb29rRW50aXR5IH0gZnJvbSAnQHdvcmtmbG93L3dvcmxkJztcbmltcG9ydCB7IHRocm93Tm90SW5Xb3JrZmxvd0NvbnRleHQgfSBmcm9tICcuL2NvbnRleHQtZXJyb3JzLmpzJztcbmltcG9ydCB0eXBlIHsgSG9vaywgSG9va09wdGlvbnMgfSBmcm9tICcuL2NyZWF0ZS1ob29rLmpzJztcbmltcG9ydCB7IHJlc3VtZUhvb2sgfSBmcm9tICcuL3J1bnRpbWUvcmVzdW1lLWhvb2suanMnO1xuXG4vKipcbiAqIEEgdHlwZWQgaG9vayBpbnRlcmZhY2UgZm9yIHR5cGUtc2FmZSBob29rIGNyZWF0aW9uIGFuZCByZXN1bXB0aW9uLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFR5cGVkSG9vazxUSW5wdXQsIFRPdXRwdXQ+IHtcbiAgLyoqXG4gICAqIENyZWF0ZXMgYSBuZXcgaG9vayB3aXRoIHRoZSBkZWZpbmVkIG91dHB1dCB0eXBlLlxuICAgKlxuICAgKiBOb3RlOiBUaGlzIG1ldGhvZCBpcyBub3QgYXZhaWxhYmxlIGluIHJ1bnRpbWUgYnVuZGxlcy4gVXNlIGl0IGZyb20gd29ya2Zsb3cgY29udGV4dHMgb25seS5cbiAgICpcbiAgICogQHBhcmFtIG9wdGlvbnMgLSBPcHRpb25hbCBob29rIGNvbmZpZ3VyYXRpb25cbiAgICogQHJldHVybnMgQSBIb29rIHRoYXQgcmVzb2x2ZXMgdG8gdGhlIGRlZmluZWQgb3V0cHV0IHR5cGVcbiAgICovXG4gIGNyZWF0ZShvcHRpb25zPzogSG9va09wdGlvbnMpOiBIb29rPFRPdXRwdXQ+O1xuICAvKipcbiAgICogUmVzdW1lcyBhIGhvb2sgYnkgc2VuZGluZyBhIHBheWxvYWQgd2l0aCB0aGUgZGVmaW5lZCBpbnB1dCB0eXBlLlxuICAgKiBUaGlzIGlzIGEgdHlwZS1zYWZlIHdyYXBwZXIgYXJvdW5kIHRoZSBgcmVzdW1lSG9va2AgcnVudGltZSBmdW5jdGlvbi5cbiAgICpcbiAgICogQHBhcmFtIHRva2VuIC0gVGhlIHVuaXF1ZSB0b2tlbiBpZGVudGlmeWluZyB0aGUgaG9va1xuICAgKiBAcGFyYW0gcGF5bG9hZCAtIFRoZSBwYXlsb2FkIHRvIHNlbmQ7IGlmIGEgYHNjaGVtYWAgaXMgY29uZmlndXJlZCBpdCBpcyB2YWxpZGF0ZWQvdHJhbnNmb3JtZWQgYmVmb3JlIHJlc3VtaW5nXG4gICAqIEByZXR1cm5zIFByb21pc2UgcmVzb2x2aW5nIHRvIHRoZSBob29rIGVudGl0eVxuICAgKiBAdGhyb3dzIEVycm9yIGlmIHRoZSBob29rIGlzIG5vdCBmb3VuZCBvciBpZiB0aGVyZSdzIGFuIGVycm9yIGR1cmluZyB0aGUgcHJvY2Vzc1xuICAgKi9cbiAgcmVzdW1lKHRva2VuOiBzdHJpbmcsIHBheWxvYWQ6IFRJbnB1dCk6IFByb21pc2U8SG9va0VudGl0eT47XG59XG5cbmV4cG9ydCBuYW1lc3BhY2UgVHlwZWRIb29rIHtcbiAgLyoqXG4gICAqIEV4dHJhY3RzIHRoZSBpbnB1dCB0eXBlIGZyb20gYSB7QGxpbmsgVHlwZWRIb29rfVxuICAgKi9cbiAgZXhwb3J0IHR5cGUgSW5wdXQ8VCBleHRlbmRzIFR5cGVkSG9vazxhbnksIGFueT4+ID1cbiAgICBUIGV4dGVuZHMgVHlwZWRIb29rPGluZmVyIEksIGFueT4gPyBJIDogbmV2ZXI7XG59XG5cbi8qKlxuICogRGVmaW5lcyBhIHR5cGVkIGhvb2sgZm9yIHR5cGUtc2FmZSBob29rIGNyZWF0aW9uIGFuZCByZXN1bXB0aW9uLlxuICpcbiAqIFRoaXMgaGVscGVyIHByb3ZpZGVzIHR5cGUgc2FmZXR5IGJ5IGFsbG93aW5nIHlvdSB0byBkZWZpbmUgdGhlIGlucHV0IGFuZCBvdXRwdXQgdHlwZXNcbiAqIGZvciB0aGUgaG9vaydzIHBheWxvYWQsIHdpdGggb3B0aW9uYWwgdmFsaWRhdGlvbiBhbmQgdHJhbnNmb3JtYXRpb24gdmlhIGEgc2NoZW1hLlxuICpcbiAqIEBwYXJhbSBzY2hlbWEgLSBTY2hlbWEgdXNlZCB0byB2YWxpZGF0ZSBhbmQgdHJhbnNmb3JtIHRoZSBpbnB1dCBwYXlsb2FkIGJlZm9yZSByZXN1bWluZ1xuICogQHJldHVybnMgQW4gb2JqZWN0IHdpdGggYGNyZWF0ZWAgYW5kIGByZXN1bWVgIGZ1bmN0aW9ucyBwcmUtdHlwZWQgd2l0aCB0aGUgaW5wdXQgYW5kIG91dHB1dCB0eXBlc1xuICpcbiAqIEBleGFtcGxlXG4gKlxuICogYGBgdHNcbiAqIC8vIERlZmluZSBhIGhvb2sgd2l0aCBhIHNwZWNpZmljIHBheWxvYWQgdHlwZVxuICogY29uc3QgYXBwcm92YWxIb29rID0gZGVmaW5lSG9vazx7IGFwcHJvdmVkOiBib29sZWFuOyBjb21tZW50OiBzdHJpbmcgfT4oKTtcbiAqXG4gKiAvLyBJbiBhIHdvcmtmbG93XG4gKiBleHBvcnQgYXN5bmMgZnVuY3Rpb24gd29ya2Zsb3dXaXRoQXBwcm92YWwoKSB7XG4gKiAgIFwidXNlIHdvcmtmbG93XCI7XG4gKlxuICogICBjb25zdCBob29rID0gYXBwcm92YWxIb29rLmNyZWF0ZSgpO1xuICogICBjb25zdCByZXN1bHQgPSBhd2FpdCBob29rOyAvLyBGdWxseSB0eXBlZCBhcyB7IGFwcHJvdmVkOiBib29sZWFuOyBjb21tZW50OiBzdHJpbmc7IH1cbiAqIH1cbiAqXG4gKiAvLyBJbiBhbiBBUEkgcm91dGVcbiAqIGV4cG9ydCBhc3luYyBmdW5jdGlvbiBQT1NUKHJlcXVlc3Q6IFJlcXVlc3QpIHtcbiAqICAgY29uc3QgeyB0b2tlbiwgYXBwcm92ZWQsIGNvbW1lbnQgfSA9IGF3YWl0IHJlcXVlc3QuanNvbigpO1xuICogICBhd2FpdCBhcHByb3ZhbEhvb2sucmVzdW1lKHRva2VuLCB7IGFwcHJvdmVkLCBjb21tZW50IH0pOyAvLyBJbnB1dCB0eXBlXG4gKiAgIHJldHVybiBSZXNwb25zZS5qc29uKHsgc3VjY2VzczogdHJ1ZSB9KTtcbiAqIH1cbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gZGVmaW5lSG9vazxUSW5wdXQsIFRPdXRwdXQgPSBUSW5wdXQ+KHtcbiAgc2NoZW1hLFxufToge1xuICBzY2hlbWE/OiBTdGFuZGFyZFNjaGVtYVYxPFRJbnB1dCwgVE91dHB1dD47XG59ID0ge30pOiBUeXBlZEhvb2s8VElucHV0LCBUT3V0cHV0PiB7XG4gIGZ1bmN0aW9uIGNyZWF0ZShfb3B0aW9ucz86IEhvb2tPcHRpb25zKTogSG9vazxUT3V0cHV0PiB7XG4gICAgLy8gTk9URTogYGNyZWF0ZWAgaXMgcmVmZXJlbmNlZCBieSBuYW1lIChub3QgYHRoaXMuY3JlYXRlYCkgc28gdGhlIHN0YWNrXG4gICAgLy8gc3RyaXAgc3RpbGwgd29ya3MgaWYgdGhlIGNhbGxlciBkZXN0cnVjdHVyZWQgdGhlIGhvb2sgKGBjb25zdCB7IGNyZWF0ZSB9XG4gICAgLy8gPSBkZWZpbmVIb29rKCk7IGNyZWF0ZSgpYCkg4oCUIGluIHRoYXQgY2FzZSBgdGhpc2AgaXMgdW5kZWZpbmVkLlxuICAgIHRocm93Tm90SW5Xb3JrZmxvd0NvbnRleHQoXG4gICAgICAnZGVmaW5lSG9vaygpLmNyZWF0ZSgpJyxcbiAgICAgICdodHRwczovL3dvcmtmbG93LXNkay5kZXYvZG9jcy9hcGktcmVmZXJlbmNlL3dvcmtmbG93L2RlZmluZS1ob29rJyxcbiAgICAgIGNyZWF0ZVxuICAgICk7XG4gIH1cblxuICByZXR1cm4ge1xuICAgIGNyZWF0ZSxcbiAgICBhc3luYyByZXN1bWUodG9rZW46IHN0cmluZywgcGF5bG9hZDogVElucHV0KTogUHJvbWlzZTxIb29rRW50aXR5PiB7XG4gICAgICBpZiAoIXNjaGVtYT8uWyd+c3RhbmRhcmQnXSkge1xuICAgICAgICByZXR1cm4gYXdhaXQgcmVzdW1lSG9vayh0b2tlbiwgcGF5bG9hZCk7XG4gICAgICB9XG5cbiAgICAgIGxldCByZXN1bHQgPSBzY2hlbWFbJ35zdGFuZGFyZCddLnZhbGlkYXRlKHBheWxvYWQpO1xuICAgICAgaWYgKHJlc3VsdCBpbnN0YW5jZW9mIFByb21pc2UpIHtcbiAgICAgICAgcmVzdWx0ID0gYXdhaXQgcmVzdWx0O1xuICAgICAgfVxuXG4gICAgICAvLyBpZiB0aGUgYGlzc3Vlc2AgZmllbGQgZXhpc3RzLCB0aGUgdmFsaWRhdGlvbiBmYWlsZWRcbiAgICAgIGlmIChyZXN1bHQuaXNzdWVzKSB7XG4gICAgICAgIGNvbnN0IGxpbmVzID0gcmVzdWx0Lmlzc3Vlcy5tYXAoKGlzc3VlKSA9PiB7XG4gICAgICAgICAgY29uc3QgcGF0aCA9IGlzc3VlLnBhdGhcbiAgICAgICAgICAgID8ubWFwKChzZWdtZW50KSA9PlxuICAgICAgICAgICAgICB0eXBlb2Ygc2VnbWVudCA9PT0gJ29iamVjdCcgJiYgc2VnbWVudCAhPT0gbnVsbFxuICAgICAgICAgICAgICAgID8gU3RyaW5nKChzZWdtZW50IGFzIHsga2V5OiBQcm9wZXJ0eUtleSB9KS5rZXkpXG4gICAgICAgICAgICAgICAgOiBTdHJpbmcoc2VnbWVudClcbiAgICAgICAgICAgIClcbiAgICAgICAgICAgIC5qb2luKCcuJyk7XG4gICAgICAgICAgcmV0dXJuIHBhdGhcbiAgICAgICAgICAgID8gYCAgYXQgXCIke3BhdGh9XCI6ICR7aXNzdWUubWVzc2FnZX1gXG4gICAgICAgICAgICA6IGAgICR7aXNzdWUubWVzc2FnZX1gO1xuICAgICAgICB9KTtcbiAgICAgICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgICAgIGBIb29rIHBheWxvYWQgZGlkIG5vdCBtYXRjaCB0aGUgZGVmaW5lZCBzY2hlbWE6XFxuJHtsaW5lcy5qb2luKCdcXG4nKX1gXG4gICAgICAgICk7XG4gICAgICB9XG5cbiAgICAgIHJldHVybiBhd2FpdCByZXN1bWVIb29rPFRPdXRwdXQ+KHRva2VuLCByZXN1bHQudmFsdWUpO1xuICAgIH0sXG4gIH07XG59XG4iXX0=

package/dist/describe-error.d.ts

@@ -0,0 +1,70 @@
+import { type RunErrorCode } from '@workflow/errors';
+/**
+ * Attribution of a workflow/step failure for presentation.
+ *
+ * - `user`: the error came from customer code (a step or workflow function
+ *   threw, or a value they passed across a boundary wasn't serializable).
+ * - `sdk`: the SDK produced the error itself — an internal invariant broke,
+ *   or a runtime guard rejected the call. These should be rare; when they
+ *   happen we want to frame the terminal output as "this is us, not you."
+ */
+export type ErrorAttribution = 'user' | 'sdk';
+export interface ErrorDescription {
+    attribution: ErrorAttribution;
+    errorCode: RunErrorCode;
+    /**
+     * Short, class-aware hint to help a user understand what the error means.
+     * Only set for well-known SDK error classes (SerializationError,
+     * WorkflowRuntimeError, context-violation errors); `undefined` for plain
+     * user errors, where the stack is already the most useful thing to show.
+     */
+    hint?: string;
+}
+/**
+ * Error signal fields carried on persisted failure events (e.g.
+ * `run_failed` / `step_failed`). The shape is intentionally loose:
+ *
+ * - `errorCode` is typed as `string` rather than `RunErrorCode` because
+ *   the value comes from stored JSON/CBOR and may predate the current
+ *   enum — callers should not narrow on it blindly. Values that don't
+ *   match a known `RUN_ERROR_CODES` entry fall through to USER_ERROR.
+ * - `errorName` is the thrown `Error#name`. It is not universally
+ *   persisted today; callers that have access to it (either via an
+ *   in-memory throw or a richer payload) can pass it in to sharpen
+ *   the attribution and hint. When absent, `describeRunError` still
+ *   returns a sensible attribution from `errorCode` alone.
+ */
+export interface PersistedErrorSignal {
+    errorCode?: string;
+    errorName?: string;
+}
+/**
+ * Data-driven variant of {@link describeError} that works from persisted
+ * event fields instead of a live `Error` instance. Intended for CLI/web
+ * renderers that read failure events and no longer have the original
+ * thrown object.
+ */
+export declare function describeRunError(signal: PersistedErrorSignal): ErrorDescription;
+/**
+ * Describe an error for user-facing presentation. Purely informational —
+ * does not change any persisted event data or error classification used by
+ * the runtime.
+ *
+ * The attribution here is more nuanced than `classifyRunError`:
+ *
+ * - `SerializationError` is technically raised by the SDK, but it almost
+ *   always points at something the caller did (passed a non-serializable
+ *   value, didn't register a class). We attribute it to the user.
+ * - Context-violation errors (`NotInWorkflowContextError`, etc.) likewise
+ *   describe a user mistake.
+ * - `WorkflowRuntimeError` (and subclasses like `StepNotRegisteredError`)
+ *   indicates an internal SDK invariant broke — surface that as `sdk`.
+ *
+ * @param err The error value thrown by the workflow / step.
+ * @param errorCode Optional precomputed error code. Callers that already
+ *   know the code (e.g. `REPLAY_TIMEOUT` or `MAX_DELIVERIES_EXCEEDED`, which
+ *   `classifyRunError` can't derive from the error alone) should pass it so
+ *   the attribution and hint reflect the actual failure category.
+ */
+export declare function describeError(err: unknown, errorCode?: RunErrorCode): ErrorDescription;
+//# sourceMappingURL=describe-error.d.ts.map

package/dist/describe-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-error.d.ts","sourceRoot":"","sources":["../src/describe-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAC;AAS1B;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,KAAK,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,EAAE,YAAY,CAAC;IACxB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAuCD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,oBAAoB,GAC3B,gBAAgB,CAuBlB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,SAAS,CAAC,EAAE,YAAY,GACvB,gBAAgB,CA4ClB"}

package/dist/describe-error.js

@@ -0,0 +1,119 @@
+import { RUN_ERROR_CODES, SerializationError, WorkflowRuntimeError, } from '@workflow/errors';
+import { classifyRunError } from './classify-error.js';
+import { NotInStepContextError, NotInWorkflowContextError, NotInWorkflowOrStepContextError, UnavailableInWorkflowContextError, } from './context-errors.js';
+const CONTEXT_ERROR_NAMES = new Set([
+    'NotInWorkflowContextError',
+    'NotInStepContextError',
+    'NotInWorkflowOrStepContextError',
+    'UnavailableInWorkflowContextError',
+]);
+function isContextViolationError(err) {
+    return (err instanceof NotInWorkflowContextError ||
+        err instanceof NotInStepContextError ||
+        err instanceof NotInWorkflowOrStepContextError ||
+        err instanceof UnavailableInWorkflowContextError);
+}
+const SERIALIZATION_ERROR_HINT = 'A value passed across a workflow/step boundary could not be serialized. See the error message for the offending path and the Learn More link for details.';
+const CONTEXT_ERROR_HINT = 'A workflow-only or step-only API was called from the wrong context. The error message includes the exact API and how to move the call.';
+const RUNTIME_ERROR_HINT = 'This is an internal workflow SDK error, not a bug in your code. If it keeps happening, please report it with the stack trace and the runId.';
+const REPLAY_TIMEOUT_HINT = 'The workflow replay took too long. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work between step boundaries.';
+const MAX_DELIVERIES_HINT = 'The workflow queue exceeded its max-delivery budget. This usually indicates a persistent runtime failure — check the most recent stack traces for the underlying cause.';
+function normalizeErrorCode(code) {
+    // Values read back from persisted events are `string | undefined` — we
+    // only trust codes that match a known entry in `RUN_ERROR_CODES`.
+    const known = Object.values(RUN_ERROR_CODES);
+    if (code && known.includes(code)) {
+        return code;
+    }
+    return RUN_ERROR_CODES.USER_ERROR;
+}
+/**
+ * Data-driven variant of {@link describeError} that works from persisted
+ * event fields instead of a live `Error` instance. Intended for CLI/web
+ * renderers that read failure events and no longer have the original
+ * thrown object.
+ */
+export function describeRunError(signal) {
+    const errorCode = normalizeErrorCode(signal.errorCode);
+    const name = signal.errorName;
+    if (name === 'SerializationError') {
+        return { attribution: 'user', errorCode, hint: SERIALIZATION_ERROR_HINT };
+    }
+    if (name && CONTEXT_ERROR_NAMES.has(name)) {
+        return { attribution: 'user', errorCode, hint: CONTEXT_ERROR_HINT };
+    }
+    if (name === 'WorkflowRuntimeError' || name === 'StepNotRegisteredError') {
+        return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };
+    }
+    if (errorCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {
+        return { attribution: 'sdk', errorCode, hint: REPLAY_TIMEOUT_HINT };
+    }
+    if (errorCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {
+        return { attribution: 'sdk', errorCode, hint: MAX_DELIVERIES_HINT };
+    }
+    if (errorCode === RUN_ERROR_CODES.RUNTIME_ERROR) {
+        return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };
+    }
+    return { attribution: 'user', errorCode };
+}
+/**
+ * Describe an error for user-facing presentation. Purely informational —
+ * does not change any persisted event data or error classification used by
+ * the runtime.
+ *
+ * The attribution here is more nuanced than `classifyRunError`:
+ *
+ * - `SerializationError` is technically raised by the SDK, but it almost
+ *   always points at something the caller did (passed a non-serializable
+ *   value, didn't register a class). We attribute it to the user.
+ * - Context-violation errors (`NotInWorkflowContextError`, etc.) likewise
+ *   describe a user mistake.
+ * - `WorkflowRuntimeError` (and subclasses like `StepNotRegisteredError`)
+ *   indicates an internal SDK invariant broke — surface that as `sdk`.
+ *
+ * @param err The error value thrown by the workflow / step.
+ * @param errorCode Optional precomputed error code. Callers that already
+ *   know the code (e.g. `REPLAY_TIMEOUT` or `MAX_DELIVERIES_EXCEEDED`, which
+ *   `classifyRunError` can't derive from the error alone) should pass it so
+ *   the attribution and hint reflect the actual failure category.
+ */
+export function describeError(err, errorCode) {
+    const effectiveCode = errorCode ?? classifyRunError(err);
+    if (SerializationError.is(err)) {
+        return {
+            attribution: 'user',
+            errorCode: effectiveCode,
+            hint: SERIALIZATION_ERROR_HINT,
+        };
+    }
+    if (isContextViolationError(err)) {
+        return {
+            attribution: 'user',
+            errorCode: effectiveCode,
+            hint: CONTEXT_ERROR_HINT,
+        };
+    }
+    if (err instanceof WorkflowRuntimeError) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: RUNTIME_ERROR_HINT,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: REPLAY_TIMEOUT_HINT,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: MAX_DELIVERIES_HINT,
+        };
+    }
+    return { attribution: 'user', errorCode: effectiveCode };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"describe-error.js","sourceRoot":"","sources":["../src/describe-error.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  RUN_ERROR_CODES,\n  type RunErrorCode,\n  SerializationError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport { classifyRunError } from './classify-error.js';\nimport {\n  NotInStepContextError,\n  NotInWorkflowContextError,\n  NotInWorkflowOrStepContextError,\n  UnavailableInWorkflowContextError,\n} from './context-errors.js';\n\n/**\n * Attribution of a workflow/step failure for presentation.\n *\n * - `user`: the error came from customer code (a step or workflow function\n *   threw, or a value they passed across a boundary wasn't serializable).\n * - `sdk`: the SDK produced the error itself — an internal invariant broke,\n *   or a runtime guard rejected the call. These should be rare; when they\n *   happen we want to frame the terminal output as \"this is us, not you.\"\n */\nexport type ErrorAttribution = 'user' | 'sdk';\n\nexport interface ErrorDescription {\n  attribution: ErrorAttribution;\n  errorCode: RunErrorCode;\n  /**\n   * Short, class-aware hint to help a user understand what the error means.\n   * Only set for well-known SDK error classes (SerializationError,\n   * WorkflowRuntimeError, context-violation errors); `undefined` for plain\n   * user errors, where the stack is already the most useful thing to show.\n   */\n  hint?: string;\n}\n\n/**\n * Error signal fields carried on persisted failure events (e.g.\n * `run_failed` / `step_failed`). The shape is intentionally loose:\n *\n * - `errorCode` is typed as `string` rather than `RunErrorCode` because\n *   the value comes from stored JSON/CBOR and may predate the current\n *   enum — callers should not narrow on it blindly. Values that don't\n *   match a known `RUN_ERROR_CODES` entry fall through to USER_ERROR.\n * - `errorName` is the thrown `Error#name`. It is not universally\n *   persisted today; callers that have access to it (either via an\n *   in-memory throw or a richer payload) can pass it in to sharpen\n *   the attribution and hint. When absent, `describeRunError` still\n *   returns a sensible attribution from `errorCode` alone.\n */\nexport interface PersistedErrorSignal {\n  errorCode?: string;\n  errorName?: string;\n}\n\nconst CONTEXT_ERROR_NAMES = new Set([\n  'NotInWorkflowContextError',\n  'NotInStepContextError',\n  'NotInWorkflowOrStepContextError',\n  'UnavailableInWorkflowContextError',\n]);\n\nfunction isContextViolationError(err: unknown): boolean {\n  return (\n    err instanceof NotInWorkflowContextError ||\n    err instanceof NotInStepContextError ||\n    err instanceof NotInWorkflowOrStepContextError ||\n    err instanceof UnavailableInWorkflowContextError\n  );\n}\n\nconst SERIALIZATION_ERROR_HINT =\n  'A value passed across a workflow/step boundary could not be serialized. See the error message for the offending path and the Learn More link for details.';\nconst CONTEXT_ERROR_HINT =\n  'A workflow-only or step-only API was called from the wrong context. The error message includes the exact API and how to move the call.';\nconst RUNTIME_ERROR_HINT =\n  'This is an internal workflow SDK error, not a bug in your code. If it keeps happening, please report it with the stack trace and the runId.';\nconst REPLAY_TIMEOUT_HINT =\n  'The workflow replay took too long. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work between step boundaries.';\nconst MAX_DELIVERIES_HINT =\n  'The workflow queue exceeded its max-delivery budget. This usually indicates a persistent runtime failure — check the most recent stack traces for the underlying cause.';\n\nfunction normalizeErrorCode(code: string | undefined): RunErrorCode {\n  // Values read back from persisted events are `string | undefined` — we\n  // only trust codes that match a known entry in `RUN_ERROR_CODES`.\n  const known = Object.values(RUN_ERROR_CODES) as readonly string[];\n  if (code && known.includes(code)) {\n    return code as RunErrorCode;\n  }\n  return RUN_ERROR_CODES.USER_ERROR;\n}\n\n/**\n * Data-driven variant of {@link describeError} that works from persisted\n * event fields instead of a live `Error` instance. Intended for CLI/web\n * renderers that read failure events and no longer have the original\n * thrown object.\n */\nexport function describeRunError(\n  signal: PersistedErrorSignal\n): ErrorDescription {\n  const errorCode = normalizeErrorCode(signal.errorCode);\n  const name = signal.errorName;\n\n  if (name === 'SerializationError') {\n    return { attribution: 'user', errorCode, hint: SERIALIZATION_ERROR_HINT };\n  }\n  if (name && CONTEXT_ERROR_NAMES.has(name)) {\n    return { attribution: 'user', errorCode, hint: CONTEXT_ERROR_HINT };\n  }\n  if (name === 'WorkflowRuntimeError' || name === 'StepNotRegisteredError') {\n    return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {\n    return { attribution: 'sdk', errorCode, hint: REPLAY_TIMEOUT_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {\n    return { attribution: 'sdk', errorCode, hint: MAX_DELIVERIES_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.RUNTIME_ERROR) {\n    return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };\n  }\n  return { attribution: 'user', errorCode };\n}\n\n/**\n * Describe an error for user-facing presentation. Purely informational —\n * does not change any persisted event data or error classification used by\n * the runtime.\n *\n * The attribution here is more nuanced than `classifyRunError`:\n *\n * - `SerializationError` is technically raised by the SDK, but it almost\n *   always points at something the caller did (passed a non-serializable\n *   value, didn't register a class). We attribute it to the user.\n * - Context-violation errors (`NotInWorkflowContextError`, etc.) likewise\n *   describe a user mistake.\n * - `WorkflowRuntimeError` (and subclasses like `StepNotRegisteredError`)\n *   indicates an internal SDK invariant broke — surface that as `sdk`.\n *\n * @param err The error value thrown by the workflow / step.\n * @param errorCode Optional precomputed error code. Callers that already\n *   know the code (e.g. `REPLAY_TIMEOUT` or `MAX_DELIVERIES_EXCEEDED`, which\n *   `classifyRunError` can't derive from the error alone) should pass it so\n *   the attribution and hint reflect the actual failure category.\n */\nexport function describeError(\n  err: unknown,\n  errorCode?: RunErrorCode\n): ErrorDescription {\n  const effectiveCode = errorCode ?? classifyRunError(err);\n\n  if (SerializationError.is(err)) {\n    return {\n      attribution: 'user',\n      errorCode: effectiveCode,\n      hint: SERIALIZATION_ERROR_HINT,\n    };\n  }\n\n  if (isContextViolationError(err)) {\n    return {\n      attribution: 'user',\n      errorCode: effectiveCode,\n      hint: CONTEXT_ERROR_HINT,\n    };\n  }\n\n  if (err instanceof WorkflowRuntimeError) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: RUNTIME_ERROR_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: REPLAY_TIMEOUT_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: MAX_DELIVERIES_HINT,\n    };\n  }\n\n  return { attribution: 'user', errorCode: effectiveCode };\n}\n"]}

package/dist/encryption.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,MAAM,SAAS,GAAG,OAAO,aAAa,EAAE,SAAS,CAAC,SAAS,CAAC;AAMlE;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,UAAU,iDAU9C;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAWrB;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAerB"}
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,MAAM,SAAS,GAAG,OAAO,aAAa,EAAE,SAAS,CAAC,SAAS,CAAC;AAMlE;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,UAAU,iDAU9C;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAWrB;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAerB"}

package/dist/encryption.js

@@ -1,20 +1,4 @@
-/**
- * Browser-compatible AES-256-GCM encryption module.
- *
- * Uses the Web Crypto API (`globalThis.crypto.subtle`) which works in
- * both modern browsers and Node.js 20+. This module is intentionally
- * free of Node.js-specific imports so it can be bundled for the browser.
- *
- * The World interface (`getEncryptionKeyForRun`) returns a raw 32-byte
- * AES-256 key. Callers should use `importKey()` once to convert it to a
- * `CryptoKey`, then pass that to `encrypt()`/`decrypt()` for all
- * operations within the same run. This avoids repeated `importKey()`
- * calls on every encrypt/decrypt invocation.
- *
- * Wire format: `[nonce (12 bytes)][ciphertext + auth tag]`
- * The `encr` format prefix is NOT part of this module — it's added/stripped
- * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.
- */
+import { WorkflowRuntimeError } from '@workflow/errors';
 const NONCE_LENGTH = 12;
 const TAG_LENGTH = 128; // bits
 const KEY_LENGTH = 32; // bytes (AES-256)
@@ -29,7 +13,7 @@ const KEY_LENGTH = 32; // bytes (AES-256)
  */
 export async function importKey(raw) {
     if (raw.byteLength !== KEY_LENGTH) {
-        throw new Error(`Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`);
+        throw new WorkflowRuntimeError(`Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`);
     }
     return globalThis.crypto.subtle.importKey('raw', raw, 'AES-GCM', false, [
         'encrypt',
@@ -61,11 +45,11 @@ export async function encrypt(key, data) {
 export async function decrypt(key, data) {
     const minLength = NONCE_LENGTH + TAG_LENGTH / 8; // nonce + auth tag
     if (data.byteLength < minLength) {
-        throw new Error(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`);
+        throw new WorkflowRuntimeError(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`);
     }
     const nonce = data.subarray(0, NONCE_LENGTH);
     const ciphertext = data.subarray(NONCE_LENGTH);
     const plaintext = await globalThis.crypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH }, key, ciphertext);
     return new Uint8Array(plaintext);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/events-consumer.d.ts

@@ -1,4 +1,11 @@
 import type { Event } from '@workflow/world';
+/**
+ * Delay before firing the deferred unconsumed-event check after the promise
+ * queue has drained. Must be long enough for cross-VM microtask chains to
+ * propagate (resolve in host → workflow code in VM → subscribe call back
+ * in host). Any subscribe() arriving during this window cancels the check.
+ */
+export declare const DEFERRED_CHECK_DELAY_MS = 100;
 export declare enum EventConsumerResult {
     /**
      * Callback consumed the event, but should not be removed from the callbacks list

package/dist/events-consumer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events-consumer.d.ts","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAG7C,oBAAY,mBAAmB;IAC7B;;OAEG;IACH,QAAQ,IAAA;IACR;;OAEG;IACH,WAAW,IAAA;IACX;;OAEG;IACH,QAAQ,IAAA;CACT;AAED,KAAK,qBAAqB,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,mBAAmB,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,qBAAa,cAAc;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAM;IAC9B,QAAQ,CAAC,SAAS,EAAE,qBAAqB,EAAE,CAAM;IACjD,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,wBAAwB,CAA8C;IAC9E,OAAO,CAAC,sBAAsB,CAAK;gBAEvB,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,qBAAqB;IAO3D;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,EAAE,qBAAqB;IAgBnC,OAAO,CAAC,OAAO,CA+Db;CACH"}
+{"version":3,"file":"events-consumer.d.ts","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAG7C;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C,oBAAY,mBAAmB;IAC7B;;OAEG;IACH,QAAQ,IAAA;IACR;;OAEG;IACH,WAAW,IAAA;IACX;;OAEG;IACH,QAAQ,IAAA;CACT;AAED,KAAK,qBAAqB,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,mBAAmB,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,qBAAa,cAAc;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAM;IAC9B,QAAQ,CAAC,SAAS,EAAE,qBAAqB,EAAE,CAAM;IACjD,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,wBAAwB,CAA8C;IAC9E,OAAO,CAAC,sBAAsB,CAAK;gBAEvB,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,qBAAqB;IAO3D;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,EAAE,qBAAqB;IAgBnC,OAAO,CAAC,OAAO,CA+Db;CACH"}

package/dist/events-consumer.js

@@ -1,4 +1,11 @@
 import { eventsLogger } from './logger.js';
+/**
+ * Delay before firing the deferred unconsumed-event check after the promise
+ * queue has drained. Must be long enough for cross-VM microtask chains to
+ * propagate (resolve in host → workflow code in VM → subscribe call back
+ * in host). Any subscribe() arriving during this window cancels the check.
+ */
+export const DEFERRED_CHECK_DELAY_MS = 100;
 export var EventConsumerResult;
 (function (EventConsumerResult) {
     /**
@@ -108,9 +115,9 @@ export class EventsConsumer {
                         this.pendingUnconsumedCheck = null;
                         this.onUnconsumedEvent(currentEvent);
                     }
-                }, 100);
+                }, DEFERRED_CHECK_DELAY_MS);
             });
         }
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events-consumer.js","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Event } from '@workflow/world';\nimport { eventsLogger } from './logger.js';\n\nexport enum EventConsumerResult {\n  /**\n   * Callback consumed the event, but should not be removed from the callbacks list\n   */\n  Consumed,\n  /**\n   * Callback did not consume the event, so it should be passed to the next callback\n   */\n  NotConsumed,\n  /**\n   * Callback consumed the event, and should be removed from the callbacks list\n   */\n  Finished,\n}\n\ntype EventConsumerCallback = (event: Event | null) => EventConsumerResult;\n\nexport interface EventsConsumerOptions {\n  /**\n   * Callback invoked when a non-null event cannot be consumed by any registered\n   * callback, indicating an orphaned or invalid event in the event log. The\n   * check is deferred until after the promise queue has drained, ensuring that\n   * any pending async work (e.g., deserialization/decryption) completes and\n   * downstream subscribe() calls have a chance to cancel the check first.\n   */\n  onUnconsumedEvent: (event: Event) => void;\n  /**\n   * Returns the current promise queue. The unconsumed event check is chained\n   * onto this queue so it only fires after all pending async work (e.g.,\n   * deserialization) has completed. This prevents false positives when async\n   * deserialization delays the resolve() that triggers the next subscribe().\n   */\n  getPromiseQueue: () => Promise<void>;\n}\n\nexport class EventsConsumer {\n  eventIndex: number;\n  readonly events: Event[] = [];\n  readonly callbacks: EventConsumerCallback[] = [];\n  private onUnconsumedEvent: (event: Event) => void;\n  private getPromiseQueue: () => Promise<void>;\n  private pendingUnconsumedCheck: Promise<void> | null = null;\n  private pendingUnconsumedTimeout: ReturnType<typeof setTimeout> | null = null;\n  private unconsumedCheckVersion = 0;\n\n  constructor(events: Event[], options: EventsConsumerOptions) {\n    this.events = events;\n    this.eventIndex = 0;\n    this.onUnconsumedEvent = options.onUnconsumedEvent;\n    this.getPromiseQueue = options.getPromiseQueue;\n  }\n\n  /**\n   * Registers a callback function to be called after an event has been consumed\n   * by a different callback. The callback can return:\n   *  - `EventConsumerResult.Consumed` the event is considered consumed and will not be passed to any other callback, but the callback will remain in the callbacks list\n   *  - `EventConsumerResult.NotConsumed` the event is passed to the next callback\n   *  - `EventConsumerResult.Finished` the event is considered consumed and the callback is removed from the callbacks list\n   *\n   * @param fn - The callback function to register.\n   */\n  subscribe(fn: EventConsumerCallback) {\n    this.callbacks.push(fn);\n    // Cancel any pending unconsumed check since a new callback may consume the event.\n    // Incrementing the version causes any in-flight promise chain check to no-op.\n    // Also clear the pending setTimeout if it hasn't fired yet.\n    if (this.pendingUnconsumedCheck !== null) {\n      this.unconsumedCheckVersion++;\n      this.pendingUnconsumedCheck = null;\n      if (this.pendingUnconsumedTimeout !== null) {\n        clearTimeout(this.pendingUnconsumedTimeout);\n        this.pendingUnconsumedTimeout = null;\n      }\n    }\n    process.nextTick(this.consume);\n  }\n\n  private consume = () => {\n    const currentEvent = this.events[this.eventIndex] ?? null;\n    for (let i = 0; i < this.callbacks.length; i++) {\n      const callback = this.callbacks[i];\n      let handled = EventConsumerResult.NotConsumed;\n      try {\n        handled = callback(currentEvent);\n      } catch (error) {\n        eventsLogger.error('EventConsumer callback threw an error', { error });\n      }\n      if (\n        handled === EventConsumerResult.Consumed ||\n        handled === EventConsumerResult.Finished\n      ) {\n        // consumer handled this event, so increase the event index\n        this.eventIndex++;\n\n        // remove the callback if it has finished\n        if (handled === EventConsumerResult.Finished) {\n          this.callbacks.splice(i, 1);\n        }\n\n        // continue to the next event\n        process.nextTick(this.consume);\n        return;\n      }\n    }\n\n    // If we reach here, all callbacks returned NotConsumed.\n    // If the current event is non-null (a real event, not end-of-events),\n    // schedule a deferred check. We chain onto the promiseQueue so that any\n    // pending async work (e.g., deserialization/decryption that triggers\n    // resolve() → user code → subscribe()) completes first. If the event\n    // is still unconsumed after the queue drains, it's truly orphaned.\n    if (currentEvent !== null) {\n      const checkVersion = ++this.unconsumedCheckVersion;\n      this.pendingUnconsumedCheck = this.getPromiseQueue()\n        .then(\n          // Yield once after the first queue drain so promise chains resumed by\n          // that drain can run across the VM boundary and append any follow-up\n          // async work (for example: step_completed resolves -> for-await loop\n          // resumes -> the next hook payload starts hydrating).\n          () => new Promise<void>((resolve) => setTimeout(resolve, 0))\n        )\n        .then(() => this.getPromiseQueue())\n        .then(() => {\n          // Use a delayed setTimeout after the queue drains. The delay must be\n          // long enough for promise chains to propagate across the VM boundary\n          // (from resolve() in the host context through to the workflow code\n          // calling subscribe() in the VM context). Node.js does not guarantee\n          // that setTimeout(0) fires after all cross-context microtasks settle,\n          // so we use a small but non-zero delay. Any subscribe() call that\n          // arrives during this window will cancel the check via version\n          // invalidation + clearTimeout.\n          this.pendingUnconsumedTimeout = setTimeout(() => {\n            this.pendingUnconsumedTimeout = null;\n            if (this.unconsumedCheckVersion === checkVersion) {\n              this.pendingUnconsumedCheck = null;\n              this.onUnconsumedEvent(currentEvent);\n            }\n          }, 100);\n        });\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events-consumer.js","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Event } from '@workflow/world';\nimport { eventsLogger } from './logger.js';\n\n/**\n * Delay before firing the deferred unconsumed-event check after the promise\n * queue has drained. Must be long enough for cross-VM microtask chains to\n * propagate (resolve in host → workflow code in VM → subscribe call back\n * in host). Any subscribe() arriving during this window cancels the check.\n */\nexport const DEFERRED_CHECK_DELAY_MS = 100;\n\nexport enum EventConsumerResult {\n  /**\n   * Callback consumed the event, but should not be removed from the callbacks list\n   */\n  Consumed,\n  /**\n   * Callback did not consume the event, so it should be passed to the next callback\n   */\n  NotConsumed,\n  /**\n   * Callback consumed the event, and should be removed from the callbacks list\n   */\n  Finished,\n}\n\ntype EventConsumerCallback = (event: Event | null) => EventConsumerResult;\n\nexport interface EventsConsumerOptions {\n  /**\n   * Callback invoked when a non-null event cannot be consumed by any registered\n   * callback, indicating an orphaned or invalid event in the event log. The\n   * check is deferred until after the promise queue has drained, ensuring that\n   * any pending async work (e.g., deserialization/decryption) completes and\n   * downstream subscribe() calls have a chance to cancel the check first.\n   */\n  onUnconsumedEvent: (event: Event) => void;\n  /**\n   * Returns the current promise queue. The unconsumed event check is chained\n   * onto this queue so it only fires after all pending async work (e.g.,\n   * deserialization) has completed. This prevents false positives when async\n   * deserialization delays the resolve() that triggers the next subscribe().\n   */\n  getPromiseQueue: () => Promise<void>;\n}\n\nexport class EventsConsumer {\n  eventIndex: number;\n  readonly events: Event[] = [];\n  readonly callbacks: EventConsumerCallback[] = [];\n  private onUnconsumedEvent: (event: Event) => void;\n  private getPromiseQueue: () => Promise<void>;\n  private pendingUnconsumedCheck: Promise<void> | null = null;\n  private pendingUnconsumedTimeout: ReturnType<typeof setTimeout> | null = null;\n  private unconsumedCheckVersion = 0;\n\n  constructor(events: Event[], options: EventsConsumerOptions) {\n    this.events = events;\n    this.eventIndex = 0;\n    this.onUnconsumedEvent = options.onUnconsumedEvent;\n    this.getPromiseQueue = options.getPromiseQueue;\n  }\n\n  /**\n   * Registers a callback function to be called after an event has been consumed\n   * by a different callback. The callback can return:\n   *  - `EventConsumerResult.Consumed` the event is considered consumed and will not be passed to any other callback, but the callback will remain in the callbacks list\n   *  - `EventConsumerResult.NotConsumed` the event is passed to the next callback\n   *  - `EventConsumerResult.Finished` the event is considered consumed and the callback is removed from the callbacks list\n   *\n   * @param fn - The callback function to register.\n   */\n  subscribe(fn: EventConsumerCallback) {\n    this.callbacks.push(fn);\n    // Cancel any pending unconsumed check since a new callback may consume the event.\n    // Incrementing the version causes any in-flight promise chain check to no-op.\n    // Also clear the pending setTimeout if it hasn't fired yet.\n    if (this.pendingUnconsumedCheck !== null) {\n      this.unconsumedCheckVersion++;\n      this.pendingUnconsumedCheck = null;\n      if (this.pendingUnconsumedTimeout !== null) {\n        clearTimeout(this.pendingUnconsumedTimeout);\n        this.pendingUnconsumedTimeout = null;\n      }\n    }\n    process.nextTick(this.consume);\n  }\n\n  private consume = () => {\n    const currentEvent = this.events[this.eventIndex] ?? null;\n    for (let i = 0; i < this.callbacks.length; i++) {\n      const callback = this.callbacks[i];\n      let handled = EventConsumerResult.NotConsumed;\n      try {\n        handled = callback(currentEvent);\n      } catch (error) {\n        eventsLogger.error('EventConsumer callback threw an error', { error });\n      }\n      if (\n        handled === EventConsumerResult.Consumed ||\n        handled === EventConsumerResult.Finished\n      ) {\n        // consumer handled this event, so increase the event index\n        this.eventIndex++;\n\n        // remove the callback if it has finished\n        if (handled === EventConsumerResult.Finished) {\n          this.callbacks.splice(i, 1);\n        }\n\n        // continue to the next event\n        process.nextTick(this.consume);\n        return;\n      }\n    }\n\n    // If we reach here, all callbacks returned NotConsumed.\n    // If the current event is non-null (a real event, not end-of-events),\n    // schedule a deferred check. We chain onto the promiseQueue so that any\n    // pending async work (e.g., deserialization/decryption that triggers\n    // resolve() → user code → subscribe()) completes first. If the event\n    // is still unconsumed after the queue drains, it's truly orphaned.\n    if (currentEvent !== null) {\n      const checkVersion = ++this.unconsumedCheckVersion;\n      this.pendingUnconsumedCheck = this.getPromiseQueue()\n        .then(\n          // Yield once after the first queue drain so promise chains resumed by\n          // that drain can run across the VM boundary and append any follow-up\n          // async work (for example: step_completed resolves -> for-await loop\n          // resumes -> the next hook payload starts hydrating).\n          () => new Promise<void>((resolve) => setTimeout(resolve, 0))\n        )\n        .then(() => this.getPromiseQueue())\n        .then(() => {\n          // Use a delayed setTimeout after the queue drains. The delay must be\n          // long enough for promise chains to propagate across the VM boundary\n          // (from resolve() in the host context through to the workflow code\n          // calling subscribe() in the VM context). Node.js does not guarantee\n          // that setTimeout(0) fires after all cross-context microtasks settle,\n          // so we use a small but non-zero delay. Any subscribe() call that\n          // arrives during this window will cancel the check via version\n          // invalidation + clearTimeout.\n          this.pendingUnconsumedTimeout = setTimeout(() => {\n            this.pendingUnconsumedTimeout = null;\n            if (this.unconsumedCheckVersion === checkVersion) {\n              this.pendingUnconsumedCheck = null;\n              this.onUnconsumedEvent(currentEvent);\n            }\n          }, DEFERRED_CHECK_DELAY_MS);\n        });\n    }\n  };\n}\n"]}

package/dist/flushable-stream.d.ts

@@ -7,17 +7,17 @@ import { type PromiseWithResolvers } from '@workflow/utils';
  * to acquire a reader/writer. For that reason we use polling instead of a
  * fully event-driven approach here.
  *
- * 100ms is a compromise between:
- * - Latency: how quickly we notice that the user has released their lock, and
- * - Cost/CPU usage: how often timers fire, especially with many concurrent
- *   streams or in serverless environments where billed time matters.
- *
- * This value should only be changed with care, as decreasing it will
- * increase polling frequency (and thus potential cost), while increasing it
- * will add worst-case delay before the `done` promise resolves after a lock
- * is released.
+ * 10ms is chosen so the polling tick almost never sits on the critical path:
+ * the V2 step-executor's `opsSettled` race waits for this state to resolve
+ * after each step body returns, so a coarser interval (the previous 100ms)
+ * adds visible per-step latency to streaming workflows. With a uniformly
+ * distributed offset between step return and the next tick, the expected
+ * wait is half the interval — so 10ms means ~5ms average wait per step
+ * instead of ~50ms. The per-tick work is `writable.locked` plus a
+ * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more
+ * ticks during a stream's lifetime is not measurable in practice.
  */
-export declare const LOCK_POLL_INTERVAL_MS = 100;
+export declare const LOCK_POLL_INTERVAL_MS = 10;
 /**
  * State tracker for flushable stream operations.
  * Resolves when either:

package/dist/flushable-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flushable-stream.d.ts","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,iBAAiB,CAAC;AAE3E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB,CAAC,IAAI,CAAC;IACtE,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;CAC1D;AAED,wBAAgB,oBAAoB,IAAI,oBAAoB,CAO3D;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAoEf"}
+{"version":3,"file":"flushable-stream.d.ts","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,iBAAiB,CAAC;AAE3E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB,CAAC,IAAI,CAAC;IACtE,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;CAC1D;AAED,wBAAgB,oBAAoB,IAAI,oBAAoB,CAO3D;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAoEf"}