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

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,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

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,EAGL,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;AA+CD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,oBAAoB,GAC3B,gBAAgB,CAqDlB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,SAAS,CAAC,EAAE,YAAY,GACvB,gBAAgB,CAsFlB"}

package/dist/describe-error.js

@@ -0,0 +1,189 @@
+import { CorruptedEventLogError, 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 CORRUPTED_EVENT_LOG_HINT = 'The workflow event log contains orphaned or mismatched events and cannot be replayed. This is an internal workflow SDK error; please report it with the runId.';
+const REPLAY_TIMEOUT_HINT = 'The workflow replay between step boundaries took too long. This bounds workflow-VM and event-log replay time only — step bodies (`"use step"` functions) are excluded. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work in workflow code outside of step bodies. Override the default budget via the WORKFLOW_REPLAY_TIMEOUT_MS env var if needed.';
+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.';
+const MAX_EVENTS_HINT = 'The workflow exceeded the maximum number of events per run. This usually means unbounded work in the workflow function — e.g. a loop that keeps creating steps without terminating. Break long-running workflows into child workflows to stay under the limit.';
+const WORLD_CONTRACT_HINT = 'The workflow backend returned data that violated the SDK contract. This is not retryable; please report it with the stack trace and runId.';
+const DEPLOYMENT_MISMATCH_HINT = "The run was delivered to a deployment other than the deployment it is pinned to, and was stopped to protect against code-skew errors after the runtime failed to re-route it there. Verify that the run's deployment is still available and that queue callbacks route to it.";
+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 name = signal.errorName;
+    const errorCode = name === 'CorruptedEventLogError'
+        ? RUN_ERROR_CODES.CORRUPTED_EVENT_LOG
+        : normalizeErrorCode(signal.errorCode);
+    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 === 'CorruptedEventLogError') {
+        return {
+            attribution: 'sdk',
+            errorCode,
+            hint: CORRUPTED_EVENT_LOG_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.MAX_EVENTS_EXCEEDED) {
+        return { attribution: 'user', errorCode, hint: MAX_EVENTS_HINT };
+    }
+    if (errorCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {
+        return {
+            attribution: 'sdk',
+            errorCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
+    }
+    if (errorCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {
+        return {
+            attribution: 'sdk',
+            errorCode,
+            hint: WORLD_CONTRACT_HINT,
+        };
+    }
+    if (errorCode === RUN_ERROR_CODES.DEPLOYMENT_MISMATCH) {
+        return { attribution: 'sdk', errorCode, hint: DEPLOYMENT_MISMATCH_HINT };
+    }
+    if (name === 'WorkflowRuntimeError' || name === 'StepNotRegisteredError') {
+        return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_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 (CorruptedEventLogError.is(err)) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
+    }
+    // Check DEPLOYMENT_MISMATCH before the generic WorkflowRuntimeError branch —
+    // WorkflowDeploymentMismatchError subclasses it, but has its own code + hint.
+    if (effectiveCode === RUN_ERROR_CODES.DEPLOYMENT_MISMATCH) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: DEPLOYMENT_MISMATCH_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,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.MAX_EVENTS_EXCEEDED) {
+        return {
+            attribution: 'user',
+            errorCode: effectiveCode,
+            hint: MAX_EVENTS_HINT,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: WORLD_CONTRACT_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":"AAAA,OAAO,EACL,sBAAsB,EACtB,eAAe,EAEf,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,+BAA+B,EAC/B,iCAAiC,GAClC,MAAM,qBAAqB,CAAC;AA4C7B,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC;IAClC,2BAA2B;IAC3B,uBAAuB;IACvB,iCAAiC;IACjC,mCAAmC;CACpC,CAAC,CAAC;AAEH,SAAS,uBAAuB,CAAC,GAAY;IAC3C,OAAO,CACL,GAAG,YAAY,yBAAyB;QACxC,GAAG,YAAY,qBAAqB;QACpC,GAAG,YAAY,+BAA+B;QAC9C,GAAG,YAAY,iCAAiC,CACjD,CAAC;AACJ,CAAC;AAED,MAAM,wBAAwB,GAC5B,2JAA2J,CAAC;AAC9J,MAAM,kBAAkB,GACtB,wIAAwI,CAAC;AAC3I,MAAM,kBAAkB,GACtB,6IAA6I,CAAC;AAChJ,MAAM,wBAAwB,GAC5B,gKAAgK,CAAC;AACnK,MAAM,mBAAmB,GACvB,gZAAgZ,CAAC;AACnZ,MAAM,mBAAmB,GACvB,yKAAyK,CAAC;AAC5K,MAAM,eAAe,GACnB,gQAAgQ,CAAC;AACnQ,MAAM,mBAAmB,GACvB,4IAA4I,CAAC;AAC/I,MAAM,wBAAwB,GAC5B,+QAA+Q,CAAC;AAElR,SAAS,kBAAkB,CAAC,IAAwB;IAClD,uEAAuE;IACvE,kEAAkE;IAClE,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,CAAsB,CAAC;IAClE,IAAI,IAAI,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,OAAO,IAAoB,CAAC;IAC9B,CAAC;IACD,OAAO,eAAe,CAAC,UAAU,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAA4B;IAE5B,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC;IAC9B,MAAM,SAAS,GACb,IAAI,KAAK,wBAAwB;QAC/B,CAAC,CAAC,eAAe,CAAC,mBAAmB;QACrC,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAE3C,IAAI,IAAI,KAAK,oBAAoB,EAAE,CAAC;QAClC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,wBAAwB,EAAE,CAAC;IAC5E,CAAC;IACD,IAAI,IAAI,IAAI,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;IACtE,CAAC;IACD,IAAI,IAAI,KAAK,wBAAwB,EAAE,CAAC;QACtC,OAAO;YACL,WAAW,EAAE,KAAK;YAClB,SAAS;YACT,IAAI,EAAE,wBAAwB;SAC/B,CAAC;IACJ,CAAC;IACD,IAAI,SAAS,KAAK,eAAe,CAAC,cAAc,EAAE,CAAC;QACjD,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;IACtE,CAAC;IACD,IAAI,SAAS,KAAK,eAAe,CAAC,uBAAuB,EAAE,CAAC;QAC1D,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;IACtE,CAAC;IACD,IAAI,SAAS,KAAK,eAAe,CAAC,mBAAmB,EAAE,CAAC;QACtD,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;IACnE,CAAC;IACD,IAAI,SAAS,KAAK,eAAe,CAAC,mBAAmB,EAAE,CAAC;QACtD,OAAO;YACL,WAAW,EAAE,KAAK;YAClB,SAAS;YACT,IAAI,EAAE,wBAAwB;SAC/B,CAAC;IACJ,CAAC;IACD,IAAI,SAAS,KAAK,eAAe,CAAC,oBAAoB,EAAE,CAAC;QACvD,OAAO;YACL,WAAW,EAAE,KAAK;YAClB,SAAS;YACT,IAAI,EAAE,mBAAmB;SAC1B,CAAC;IACJ,CAAC;IACD,IAAI,SAAS,KAAK,eAAe,CAAC,mBAAmB,EAAE,CAAC;QACtD,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,wBAAwB,EAAE,CAAC;IAC3E,CAAC;IACD,IAAI,IAAI,KAAK,sBAAsB,IAAI,IAAI,KAAK,wBAAwB,EAAE,CAAC;QACzE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;IACrE,CAAC;IACD,IAAI,SAAS,KAAK,eAAe,CAAC,aAAa,EAAE,CAAC;QAChD,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;IACrE,CAAC;IACD,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,aAAa,CAC3B,GAAY,EACZ,SAAwB;IAExB,MAAM,aAAa,GAAG,SAAS,IAAI,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAEzD,IAAI,kBAAkB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/B,OAAO;YACL,WAAW,EAAE,MAAM;YACnB,SAAS,EAAE,aAAa;YACxB,IAAI,EAAE,wBAAwB;SAC/B,CAAC;IACJ,CAAC;IAED,IAAI,uBAAuB,CAAC,GAAG,CAAC,EAAE,CAAC;QACjC,OAAO;YACL,WAAW,EAAE,MAAM;YACnB,SAAS,EAAE,aAAa;YACxB,IAAI,EAAE,kBAAkB;SACzB,CAAC;IACJ,CAAC;IAED,IAAI,sBAAsB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,OAAO;YACL,WAAW,EAAE,KAAK;YAClB,SAAS,EAAE,aAAa;YACxB,IAAI,EAAE,wBAAwB;SAC/B,CAAC;IACJ,CAAC;IAED,6EAA6E;IAC7E,8EAA8E;IAC9E,IAAI,aAAa,KAAK,eAAe,CAAC,mBAAmB,EAAE,CAAC;QAC1D,OAAO;YACL,WAAW,EAAE,KAAK;YAClB,SAAS,EAAE,aAAa;YACxB,IAAI,EAAE,wBAAwB;SAC/B,CAAC;IACJ,CAAC;IAED,IAAI,GAAG,YAAY,oBAAoB,EAAE,CAAC;QACxC,OAAO;YACL,WAAW,EAAE,KAAK;YAClB,SAAS,EAAE,aAAa;YACxB,IAAI,EAAE,kBAAkB;SACzB,CAAC;IACJ,CAAC;IAED,IAAI,aAAa,KAAK,eAAe,CAAC,cAAc,EAAE,CAAC;QACrD,OAAO;YACL,WAAW,EAAE,KAAK;YAClB,SAAS,EAAE,aAAa;YACxB,IAAI,EAAE,mBAAmB;SAC1B,CAAC;IACJ,CAAC;IAED,IAAI,aAAa,KAAK,eAAe,CAAC,uBAAuB,EAAE,CAAC;QAC9D,OAAO;YACL,WAAW,EAAE,KAAK;YAClB,SAAS,EAAE,aAAa;YACxB,IAAI,EAAE,mBAAmB;SAC1B,CAAC;IACJ,CAAC;IAED,IAAI,aAAa,KAAK,eAAe,CAAC,mBAAmB,EAAE,CAAC;QAC1D,OAAO;YACL,WAAW,EAAE,MAAM;YACnB,SAAS,EAAE,aAAa;YACxB,IAAI,EAAE,eAAe;SACtB,CAAC;IACJ,CAAC;IAED,IAAI,aAAa,KAAK,eAAe,CAAC,mBAAmB,EAAE,CAAC;QAC1D,OAAO;YACL,WAAW,EAAE,KAAK;YAClB,SAAS,EAAE,aAAa;YACxB,IAAI,EAAE,wBAAwB;SAC/B,CAAC;IACJ,CAAC;IAED,IAAI,aAAa,KAAK,eAAe,CAAC,oBAAoB,EAAE,CAAC;QAC3D,OAAO;YACL,WAAW,EAAE,KAAK;YAClB,SAAS,EAAE,aAAa;YACxB,IAAI,EAAE,mBAAmB;SAC1B,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC;AAC3D,CAAC","sourcesContent":["import {\n  CorruptedEventLogError,\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 CORRUPTED_EVENT_LOG_HINT =\n  'The workflow event log contains orphaned or mismatched events and cannot be replayed. This is an internal workflow SDK error; please report it with the runId.';\nconst REPLAY_TIMEOUT_HINT =\n  'The workflow replay between step boundaries took too long. This bounds workflow-VM and event-log replay time only — step bodies (`\"use step\"` functions) are excluded. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work in workflow code outside of step bodies. Override the default budget via the WORKFLOW_REPLAY_TIMEOUT_MS env var if needed.';\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.';\nconst MAX_EVENTS_HINT =\n  'The workflow exceeded the maximum number of events per run. This usually means unbounded work in the workflow function — e.g. a loop that keeps creating steps without terminating. Break long-running workflows into child workflows to stay under the limit.';\nconst WORLD_CONTRACT_HINT =\n  'The workflow backend returned data that violated the SDK contract. This is not retryable; please report it with the stack trace and runId.';\nconst DEPLOYMENT_MISMATCH_HINT =\n  \"The run was delivered to a deployment other than the deployment it is pinned to, and was stopped to protect against code-skew errors after the runtime failed to re-route it there. Verify that the run's deployment is still available and that queue callbacks route to it.\";\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 name = signal.errorName;\n  const errorCode =\n    name === 'CorruptedEventLogError'\n      ? RUN_ERROR_CODES.CORRUPTED_EVENT_LOG\n      : normalizeErrorCode(signal.errorCode);\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 === 'CorruptedEventLogError') {\n    return {\n      attribution: 'sdk',\n      errorCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\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.MAX_EVENTS_EXCEEDED) {\n    return { attribution: 'user', errorCode, hint: MAX_EVENTS_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {\n    return {\n      attribution: 'sdk',\n      errorCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n  if (errorCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {\n    return {\n      attribution: 'sdk',\n      errorCode,\n      hint: WORLD_CONTRACT_HINT,\n    };\n  }\n  if (errorCode === RUN_ERROR_CODES.DEPLOYMENT_MISMATCH) {\n    return { attribution: 'sdk', errorCode, hint: DEPLOYMENT_MISMATCH_HINT };\n  }\n  if (name === 'WorkflowRuntimeError' || name === 'StepNotRegisteredError') {\n    return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_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 (CorruptedEventLogError.is(err)) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n\n  // Check DEPLOYMENT_MISMATCH before the generic WorkflowRuntimeError branch —\n  // WorkflowDeploymentMismatchError subclasses it, but has its own code + hint.\n  if (effectiveCode === RUN_ERROR_CODES.DEPLOYMENT_MISMATCH) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: DEPLOYMENT_MISMATCH_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  if (effectiveCode === RUN_ERROR_CODES.MAX_EVENTS_EXCEEDED) {\n    return {\n      attribution: 'user',\n      errorCode: effectiveCode,\n      hint: MAX_EVENTS_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: WORLD_CONTRACT_HINT,\n    };\n  }\n\n  return { attribution: 'user', errorCode: effectiveCode };\n}\n"]}

package/dist/encryption.d.ts

@@ -16,30 +16,64 @@
  * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.
  */
 export type CryptoKey = import('node:crypto').webcrypto.CryptoKey;
+/** AES-GCM nonce length in bytes. */
+export declare const NONCE_LENGTH = 12;
+/** AES-GCM authentication tag length in bits. */
+export declare const TAG_LENGTH = 128;
+/** AES-GCM authentication tag length in bytes. */
+export declare const TAG_BYTES: number;
 /**
  * Import a raw AES-256 key as a `CryptoKey` for use with `encrypt()`/`decrypt()`.
  *
  * Callers should call this once per run (after `getEncryptionKeyForRun()`)
  * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.
  *
+ * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios
+ * where the caller should not be able to perform the inverse operation
+ * with the key — for example a child workflow writing into a parent
+ * run's forwarded WritableStream only needs to encrypt, never decrypt.
+ *
  * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)
+ * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.
  * @returns CryptoKey ready for AES-GCM operations
  */
-export declare function importKey(raw: Uint8Array): Promise<import("crypto").webcrypto.CryptoKey>;
+export declare function importKey(raw: Uint8Array, usages?: ReadonlyArray<'encrypt' | 'decrypt'>): Promise<import("crypto").webcrypto.CryptoKey>;
 /**
  * Encrypt data using AES-256-GCM.
  *
  * @param key - CryptoKey from `importKey()`
  * @param data - Plaintext to encrypt
+ * @param aad - Optional additional authenticated data. Not encrypted, but
+ *   covered by the GCM auth tag: decryption fails unless the exact same
+ *   bytes are supplied. Used by the sealed-box layer to bind ciphertext to
+ *   a `projectId|runId` context. Omit for no AAD (the legacy behavior).
  * @returns `[nonce (12 bytes)][ciphertext + GCM auth tag]`
  */
-export declare function encrypt(key: CryptoKey, data: Uint8Array): Promise<Uint8Array>;
+export declare function encrypt(key: CryptoKey, data: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
 /**
  * Decrypt data using AES-256-GCM.
  *
+ * Any failure inside the Web Crypto layer — most commonly an
+ * `OperationError: The operation failed for an operation-specific reason`
+ * raised by `AESCipherJob.onDone` when the GCM authentication tag does
+ * not verify — is rewrapped as {@link RuntimeDecryptionError}. The
+ * wrapped error carries the original DOMException as `cause`, plus a
+ * small diagnostic context (`operation`, input `byteLength`) to help
+ * disambiguate ciphertext corruption from key mismatch from truncated
+ * transport reads.
+ *
+ * Note: `data` is the raw AES payload (`[nonce][ciphertext + tag]`), not a
+ * format-prefixed envelope — callers strip the `encr` marker via
+ * `decodeFormatPrefix()` before reaching this function. The outer
+ * envelope's format prefix is therefore attached by the serialization
+ * layer (`serialization/encryption.ts`), which is the layer that has it.
+ *
  * @param key - CryptoKey from `importKey()`
  * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`
+ * @param aad - Optional additional authenticated data. Must match the bytes
+ *   passed to {@link encrypt} exactly, otherwise the GCM tag fails to verify
+ *   and a {@link RuntimeDecryptionError} is thrown.
  * @returns Decrypted plaintext
  */
-export declare function decrypt(key: CryptoKey, data: Uint8Array): Promise<Uint8Array>;
+export declare function decrypt(key: CryptoKey, data: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
 //# sourceMappingURL=encryption.d.ts.map

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;AAElE,qCAAqC;AACrC,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,iDAAiD;AACjD,eAAO,MAAM,UAAU,MAAM,CAAC;AAC9B,kDAAkD;AAClD,eAAO,MAAM,SAAS,QAAiB,CAAC;AAGxC;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,UAAU,EACf,MAAM,GAAE,aAAa,CAAC,SAAS,GAAG,SAAS,CAA0B,iDAiBtE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,EAChB,GAAG,CAAC,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAiCrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,EAChB,GAAG,CAAC,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CA+CrB"}