@workflow/core 5.0.0-beta.0 → 5.0.0-beta.10

package/dist/context-violation-error.js

@@ -0,0 +1,147 @@
+import * as Ansi from '@workflow/errors/ansi';
+const INSPECT_CUSTOM = Symbol.for('nodejs.util.inspect.custom');
+function renderSegmentPlain(s) {
+    if ('code' in s)
+        return `\`${s.code}\``;
+    if ('dim' in s)
+        return s.dim;
+    return s.text;
+}
+function renderSegmentPretty(s) {
+    if ('code' in s)
+        return Ansi.code(s.code);
+    if ('dim' in s)
+        return Ansi.dim(s.dim);
+    return s.text;
+}
+function renderDetailPlain(d) {
+    if (d.type === 'docs')
+        return `docs: ${d.url}`;
+    return d.segments.map(renderSegmentPlain).join('');
+}
+function renderDetailPretty(d) {
+    if (d.type === 'docs')
+        return Ansi.docs(d.url);
+    return d.segments.map(renderSegmentPretty).join('');
+}
+export function renderPlain(c) {
+    // Mimic `Ansi.frame` structure so `.message` is still readable in logs
+    // even without the color.
+    const title = c.title.map(renderSegmentPlain).join('');
+    const lines = [title];
+    c.details.forEach((detail, index) => {
+        const isLast = index === c.details.length - 1;
+        const first = isLast ? '╰▶ ' : '├▶ ';
+        const cont = isLast ? '   ' : '│  ';
+        const raw = renderDetailPlain(detail).split('\n');
+        raw.forEach((line, i) => lines.push(`${i === 0 ? first : cont}${line}`));
+    });
+    return lines.join('\n');
+}
+export function renderPretty(c) {
+    const title = c.title.map(renderSegmentPretty).join('');
+    return Ansi.frame(title, c.details.map(renderDetailPretty));
+}
+/**
+ * Base class for structured context-violation errors.
+ *
+ * Design notes:
+ *
+ * - `.message` is **plain text** (no ANSI escape bytes). Structured logs,
+ *   log drains, CBOR-serialized event data, and anything else that reads
+ *   `err.message` / `err.stack` as a string gets clean output — no mojibake
+ *   in JSON, no `\x1B[...m` noise in Vercel logs.
+ *
+ * - The ANSI-framed version is rendered **lazily** via `toString()` and
+ *   `[util.inspect.custom]`. When the error is thrown and Node prints it
+ *   via `util.inspect`, the user sees the colored, framed box. When it's
+ *   attached to a structured log field, the consumer sees plain text.
+ *
+ * - `fatal = true` marks these as non-retryable. Calling `createHook()`
+ *   from a step function will never succeed no matter how many retries —
+ *   burning attempts just produces duplicated log output. The runtime's
+ *   `FatalError.is(err)` gate recognizes any error with `fatal: true`.
+ */
+export class ContextViolationError extends Error {
+    /** Non-retryable — see class doc. */
+    fatal = true;
+    #content;
+    constructor(content) {
+        super(renderPlain(content));
+        this.#content = content;
+    }
+    /**
+     * `console.log(err)` and most Node internals route through `util.inspect`,
+     * which respects this symbol. Returning a custom string here means the
+     * thrown error prints as a pretty frame in the terminal while `.message`
+     * and `.stack` stay plain.
+     */
+    [INSPECT_CUSTOM]() {
+        const pretty = renderPretty(this.#content);
+        // `stack` starts with `${name}: ${message}\n    at ...`. Our message is
+        // multi-line (`title\n╰▶ docs: …`), so slicing only the first line glues
+        // the framed-detail tail of the message onto the prepended pretty form
+        // and renders every detail line twice. Slice past *all* message lines.
+        const messageLineCount = this.message.split('\n').length;
+        const tail = (this.stack ?? '')
+            .split('\n')
+            .slice(messageLineCount)
+            .join('\n');
+        return tail
+            ? `${this.name}: ${pretty}\n${tail}`
+            : `${this.name}: ${pretty}`;
+    }
+    toString() {
+        return `${this.name}: ${renderPretty(this.#content)}`;
+    }
+}
+/**
+ * Thrown when an API that must run inside a workflow function is called
+ * from outside a workflow context (e.g. from a step function or from
+ * regular application code).
+ */
+export class NotInWorkflowContextError extends ContextViolationError {
+    name = 'NotInWorkflowContextError';
+    constructor(functionName, docsUrl) {
+        super({
+            title: [
+                { code: functionName },
+                { text: ' can only be called inside a workflow function' },
+            ],
+            details: [{ type: 'docs', url: docsUrl }],
+        });
+    }
+}
+/**
+ * Thrown when an API that must run inside a step function is called from
+ * outside a step context.
+ */
+export class NotInStepContextError extends ContextViolationError {
+    name = 'NotInStepContextError';
+    constructor(functionName, docsUrl) {
+        super({
+            title: [
+                { code: functionName },
+                { text: ' can only be called inside a step function' },
+            ],
+            details: [{ type: 'docs', url: docsUrl }],
+        });
+    }
+}
+/**
+ * Thrown when an API that must run inside either a workflow or step function
+ * is called from regular application code.
+ */
+export class NotInWorkflowOrStepContextError extends ContextViolationError {
+    name = 'NotInWorkflowOrStepContextError';
+    constructor(functionName, docsUrl) {
+        super({
+            title: [
+                { code: functionName },
+                { text: ' can only be called inside a workflow or step function' },
+            ],
+            details: [{ type: 'docs', url: docsUrl }],
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-violation-error.js","sourceRoot":"","sources":["../src/context-violation-error.ts"],"names":[],"mappings":"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","sourcesContent":["import * as Ansi from '@workflow/errors/ansi';\n\n/**\n * A `docs:` line URL. The leading protocol is part of the type so call sites\n * can't accidentally pass a protocol-relative or bare path.\n */\nexport type DocsUrl = `https://${string}`;\n\nconst INSPECT_CUSTOM = Symbol.for('nodejs.util.inspect.custom');\n\n/**\n * Structured data for a framed error. The base class takes this and renders\n * it to plain text (for `.message` / `.stack` / structured logs) or to an\n * ANSI-framed string (for terminal display via `util.inspect` / `toString`).\n *\n * Keeping the pieces structured means we never have to strip ANSI back out\n * once it's in the message — we just don't put it there in the first place.\n */\nexport interface FramedContent {\n  /** Headline. `{ code: 'foo()' }` segments render as backticked inline code. */\n  readonly title: readonly Segment[];\n  /** One framed branch per entry. The last uses `╰▶`, others use `├▶`. */\n  readonly details: readonly Detail[];\n}\n\nexport type Segment =\n  | { readonly text: string }\n  | { readonly code: string }\n  | { readonly dim: string };\n\nexport type Detail =\n  | { readonly type: 'plain'; readonly segments: readonly Segment[] }\n  | { readonly type: 'docs'; readonly url: DocsUrl };\n\nfunction renderSegmentPlain(s: Segment): string {\n  if ('code' in s) return `\\`${s.code}\\``;\n  if ('dim' in s) return s.dim;\n  return s.text;\n}\n\nfunction renderSegmentPretty(s: Segment): string {\n  if ('code' in s) return Ansi.code(s.code);\n  if ('dim' in s) return Ansi.dim(s.dim);\n  return s.text;\n}\n\nfunction renderDetailPlain(d: Detail): string {\n  if (d.type === 'docs') return `docs: ${d.url}`;\n  return d.segments.map(renderSegmentPlain).join('');\n}\n\nfunction renderDetailPretty(d: Detail): string {\n  if (d.type === 'docs') return Ansi.docs(d.url);\n  return d.segments.map(renderSegmentPretty).join('');\n}\n\nexport function renderPlain(c: FramedContent): string {\n  // Mimic `Ansi.frame` structure so `.message` is still readable in logs\n  // even without the color.\n  const title = c.title.map(renderSegmentPlain).join('');\n  const lines = [title];\n  c.details.forEach((detail, index) => {\n    const isLast = index === c.details.length - 1;\n    const first = isLast ? '╰▶ ' : '├▶ ';\n    const cont = isLast ? '   ' : '│  ';\n    const raw = renderDetailPlain(detail).split('\\n');\n    raw.forEach((line, i) => lines.push(`${i === 0 ? first : cont}${line}`));\n  });\n  return lines.join('\\n');\n}\n\nexport function renderPretty(c: FramedContent): string {\n  const title = c.title.map(renderSegmentPretty).join('');\n  return Ansi.frame(title, c.details.map(renderDetailPretty));\n}\n\n/**\n * Base class for structured context-violation errors.\n *\n * Design notes:\n *\n * - `.message` is **plain text** (no ANSI escape bytes). Structured logs,\n *   log drains, CBOR-serialized event data, and anything else that reads\n *   `err.message` / `err.stack` as a string gets clean output — no mojibake\n *   in JSON, no `\\x1B[...m` noise in Vercel logs.\n *\n * - The ANSI-framed version is rendered **lazily** via `toString()` and\n *   `[util.inspect.custom]`. When the error is thrown and Node prints it\n *   via `util.inspect`, the user sees the colored, framed box. When it's\n *   attached to a structured log field, the consumer sees plain text.\n *\n * - `fatal = true` marks these as non-retryable. Calling `createHook()`\n *   from a step function will never succeed no matter how many retries —\n *   burning attempts just produces duplicated log output. The runtime's\n *   `FatalError.is(err)` gate recognizes any error with `fatal: true`.\n */\nexport abstract class ContextViolationError extends Error {\n  /** Non-retryable — see class doc. */\n  readonly fatal = true;\n\n  readonly #content: FramedContent;\n\n  constructor(content: FramedContent) {\n    super(renderPlain(content));\n    this.#content = content;\n  }\n\n  /**\n   * `console.log(err)` and most Node internals route through `util.inspect`,\n   * which respects this symbol. Returning a custom string here means the\n   * thrown error prints as a pretty frame in the terminal while `.message`\n   * and `.stack` stay plain.\n   */\n  [INSPECT_CUSTOM](): string {\n    const pretty = renderPretty(this.#content);\n    // `stack` starts with `${name}: ${message}\\n    at ...`. Our message is\n    // multi-line (`title\\n╰▶ docs: …`), so slicing only the first line glues\n    // the framed-detail tail of the message onto the prepended pretty form\n    // and renders every detail line twice. Slice past *all* message lines.\n    const messageLineCount = this.message.split('\\n').length;\n    const tail = (this.stack ?? '')\n      .split('\\n')\n      .slice(messageLineCount)\n      .join('\\n');\n    return tail\n      ? `${this.name}: ${pretty}\\n${tail}`\n      : `${this.name}: ${pretty}`;\n  }\n\n  toString(): string {\n    return `${this.name}: ${renderPretty(this.#content)}`;\n  }\n}\n\n/**\n * Thrown when an API that must run inside a workflow function is called\n * from outside a workflow context (e.g. from a step function or from\n * regular application code).\n */\nexport class NotInWorkflowContextError extends ContextViolationError {\n  name = 'NotInWorkflowContextError';\n\n  constructor(functionName: string, docsUrl: DocsUrl) {\n    super({\n      title: [\n        { code: functionName },\n        { text: ' can only be called inside a workflow function' },\n      ],\n      details: [{ type: 'docs', url: docsUrl }],\n    });\n  }\n}\n\n/**\n * Thrown when an API that must run inside a step function is called from\n * outside a step context.\n */\nexport class NotInStepContextError extends ContextViolationError {\n  name = 'NotInStepContextError';\n\n  constructor(functionName: string, docsUrl: DocsUrl) {\n    super({\n      title: [\n        { code: functionName },\n        { text: ' can only be called inside a step function' },\n      ],\n      details: [{ type: 'docs', url: docsUrl }],\n    });\n  }\n}\n\n/**\n * Thrown when an API that must run inside either a workflow or step function\n * is called from regular application code.\n */\nexport class NotInWorkflowOrStepContextError extends ContextViolationError {\n  name = 'NotInWorkflowOrStepContextError';\n\n  constructor(functionName: string, docsUrl: DocsUrl) {\n    super({\n      title: [\n        { code: functionName },\n        { text: ' can only be called inside a workflow or step function' },\n      ],\n      details: [{ type: 'docs', url: docsUrl }],\n    });\n  }\n}\n"]}

package/dist/create-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-hook.d.ts","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;GAEG;AACH,UAAU,QAAQ,CAAC,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IAClD,WAAW,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;;;;;;;;;;;OAYG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,SAAS,OAAO,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;IACzD;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC;IAChD;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAIlE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,GAAG;IAAE,WAAW,EAAE,QAAQ,CAAA;CAAE,GAClD,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC"}
+{"version":3,"file":"create-hook.d.ts","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;GAEG;AACH,UAAU,QAAQ,CAAC,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IAClD,WAAW,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;;;;;;;;;;;OAYG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,SAAS,OAAO,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;IACzD;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC;IAChD;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAMlE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,GAAG;IAAE,WAAW,EAAE,QAAQ,CAAA;CAAE,GAClD,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC"}

package/dist/create-hook.js

@@ -1,3 +1,4 @@
+import { throwNotInWorkflowContext } from './context-errors.js';
 /**
  * Creates a {@link Hook} that can be used to suspend and resume the workflow run with a payload.
  *
@@ -22,11 +23,11 @@
  */
 // @ts-expect-error `options` is here for types/docs
 export function createHook(options) {
-    throw new Error('`createHook()` can only be called inside a workflow function');
+    throwNotInWorkflowContext('createHook()', 'https://workflow-sdk.dev/docs/api-reference/workflow/create-hook', createHook);
 }
 export function createWebhook(
 // @ts-expect-error `options` is here for types/docs
 options) {
-    throw new Error('`createWebhook()` can only be called inside a workflow function');
+    throwNotInWorkflowContext('createWebhook()', 'https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook', createWebhook);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWhvb2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY3JlYXRlLWhvb2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBMkpBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FxQkc7QUFDSCxvREFBb0Q7QUFDcEQsTUFBTSxVQUFVLFVBQVUsQ0FBVSxPQUFxQjtJQUN2RCxNQUFNLElBQUksS0FBSyxDQUNiLDhEQUE4RCxDQUMvRCxDQUFDO0FBQ0osQ0FBQztBQWFELE1BQU0sVUFBVSxhQUFhO0FBQzNCLG9EQUFvRDtBQUNwRCxPQUF3QjtJQUV4QixNQUFNLElBQUksS0FBSyxDQUNiLGlFQUFpRSxDQUNsRSxDQUFDO0FBQ0osQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-hook.js","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AA4JhE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oDAAoD;AACpD,MAAM,UAAU,UAAU,CAAU,OAAqB;IACvD,yBAAyB,CACvB,cAAc,EACd,kEAAkE,EAClE,UAAU,CACX,CAAC;AACJ,CAAC;AAaD,MAAM,UAAU,aAAa;AAC3B,oDAAoD;AACpD,OAAwB;IAExB,yBAAyB,CACvB,iBAAiB,EACjB,qEAAqE,EACrE,aAAa,CACd,CAAC;AACJ,CAAC","sourcesContent":["import { throwNotInWorkflowContext } from './context-errors.js';\nimport type { Serializable } from './schemas.js';\n\n/**\n * An object that can be awaited to receive a value.\n */\ninterface Thenable<T> {\n  then: Promise<T>['then'];\n}\n\n/**\n * A `Request` that can be responded to within a workflow\n * step function by calling the `respondWith()` method.\n */\nexport interface RequestWithResponse extends Request {\n  respondWith: (response: Response) => Promise<void>;\n}\n\n/**\n * A hook that can be awaited and/or iterated over to receive\n * a value within a workflow from an external system.\n *\n * Hooks implement the TC39 Explicit Resource Management proposal,\n * allowing them to be used with the `using` keyword for automatic disposal.\n */\nexport interface Hook<T = any> extends AsyncIterable<T>, Thenable<T> {\n  /**\n   * The token used to identify this hook.\n   */\n  token: string;\n\n  /**\n   * Disposes the hook, releasing its token for reuse by other workflows.\n   *\n   * After calling `dispose()`, the hook will no longer receive any events.\n   * This is useful when you want to explicitly release a hook token before\n   * the workflow completes, allowing another workflow to register a hook\n   * with the same token.\n   *\n   * @example\n   * ```ts\n   * const hook = createHook<{ message: string }>({ token: 'my-token' });\n   *\n   * for await (const payload of hook) {\n   *   if (payload.message === 'done') {\n   *     hook.dispose(); // Release the token early\n   *     break;\n   *   }\n   * }\n   * ```\n   */\n  dispose(): void;\n\n  /**\n   * Implements the TC39 Explicit Resource Management proposal.\n   * Called automatically when using the `using` keyword.\n   *\n   * @example\n   * ```ts\n   * {\n   *   using hook = createHook<{ message: string }>({ token: 'my-token' });\n   *   const payload = await hook;\n   *   // hook is automatically disposed when the block exits\n   * }\n   * ```\n   */\n  [Symbol.dispose](): void;\n}\n\n/**\n * A webhook that can be used to suspend and resume the workflow run\n * upon receiving an HTTP request to the specified URL.\n *\n * @see {@link createWebhook}\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Request\n */\nexport interface Webhook<T extends Request> extends Hook<T> {\n  /**\n   * The URL that external systems can call to send data to the workflow.\n   */\n  url: string;\n}\n\nexport interface HookOptions {\n  /**\n   * Unique token that is used to associate with the hook.\n   *\n   * When specifying an explicit token, the token should be constructed\n   * with information that the dispatching side can reliably reconstruct\n   * the token with the information it has available.\n   *\n   * Deterministic tokens are intended for use with `createHook()` and\n   * server-side `resumeHook()` only. For webhooks (`createWebhook()`),\n   * tokens are always randomly generated to prevent unauthorized access\n   * to the public webhook endpoint.\n   *\n   * If not provided, a randomly generated token will be assigned.\n   *\n   * @example\n   *\n   * ```ts\n   * // Explicit token for a Slack bot (one workflow run per channel)\n   * const hook = createHook<SlackMessage>({\n   *   token: `slack_webhook:${channelId}`,\n   * });\n   * ```\n   */\n  token?: string;\n\n  /**\n   * Additional user-defined data to include with the hook payload.\n   *\n   * @example\n   *\n   * ```ts\n   * const hook = createHook<{ name: string }>({\n   *   metadata: {\n   *     type: \"cat\",\n   *     color: \"orange\",\n   *   },\n   * });\n   * ```\n   */\n  metadata?: Serializable;\n\n  /**\n   * Whether this hook can be resumed via the public webhook endpoint.\n   *\n   * When `true`, the hook can be triggered by sending an HTTP request to the\n   * public `/.well-known/workflow/v1/webhook/{token}` URL. This is automatically\n   * set when using `createWebhook()`.\n   *\n   * When `false` (the default), the hook can only be resumed server-side\n   * via `resumeHook()`.\n   *\n   * @default false\n   */\n  isWebhook?: boolean;\n}\n\nexport interface WebhookOptions\n  extends Omit<HookOptions, 'token' | 'isWebhook'> {\n  /**\n   * If set to a `Response` object, the webhook will automatically\n   * respond with the specified response.\n   *\n   * If set to `\"manual\"`, each individual request will need to\n   * be responded to manually from within the workflow by calling the\n   * `respondWith()` method.\n   *\n   * If not set then the webhook will automatically respond with\n   * a `202 Accepted` response.\n   */\n  respondWith?: Response | 'manual';\n}\n\n/**\n * Creates a {@link Hook} that can be used to suspend and resume the workflow run with a payload.\n *\n * Hooks allow external systems to send arbitrary serializable data into a workflow.\n *\n * @param options - Configuration options for the hook.\n * @returns A `Hook` that can be awaited to receive one or more payloads.\n *\n * @example\n *\n * ```ts\n * export async function workflowWithHook() {\n *   \"use workflow\";\n *\n *   const hook = createHook<{ message: string }>();\n *   console.log('Hook token:', hook.token);\n *\n *   const payload = await hook;\n *   console.log('Received:', payload.message);\n * }\n * ```\n */\n// @ts-expect-error `options` is here for types/docs\nexport function createHook<T = any>(options?: HookOptions): Hook<T> {\n  throwNotInWorkflowContext(\n    'createHook()',\n    'https://workflow-sdk.dev/docs/api-reference/workflow/create-hook',\n    createHook\n  );\n}\n\n/**\n * Creates a {@link Webhook} that can be used to suspend and resume the workflow\n * run upon receiving an HTTP request to the specified URL.\n *\n * Webhooks will result in a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request} object\n * that can be interacted with in workflow functions.\n */\nexport function createWebhook(\n  options: WebhookOptions & { respondWith: 'manual' }\n): Webhook<RequestWithResponse>;\nexport function createWebhook(options?: WebhookOptions): Webhook<Request>;\nexport function createWebhook(\n  // @ts-expect-error `options` is here for types/docs\n  options?: WebhookOptions\n): Webhook<Request> | Webhook<RequestWithResponse> {\n  throwNotInWorkflowContext(\n    'createWebhook()',\n    'https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook',\n    createWebhook\n  );\n}\n"]}

package/dist/define-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"define-hook.d.ts","sourceRoot":"","sources":["../src/define-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG1D;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,MAAM,EAAE,OAAO;IACxC;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7C;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAC7D;AAED,yBAAiB,SAAS,CAAC;IACzB;;OAEG;IACH,KAAY,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,IAC7C,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,EAAE,EACnD,MAAM,GACP,GAAE;IACD,MAAM,CAAC,EAAE,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC,GAAG,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBlC"}
+{"version":3,"file":"define-hook.d.ts","sourceRoot":"","sources":["../src/define-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE1D,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG1D;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,MAAM,EAAE,OAAO;IACxC;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7C;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAC7D;AAED,yBAAiB,SAAS,CAAC;IACzB;;OAEG;IACH,KAAY,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,IAC7C,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,EAAE,EACnD,MAAM,GACP,GAAE;IACD,MAAM,CAAC,EAAE,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC,GAAG,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CA8ClC"}

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmaW5lLWhvb2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZGVmaW5lLWhvb2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBbUN0RDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBOEJHO0FBQ0gsTUFBTSxVQUFVLFVBQVUsQ0FBMkIsRUFDbkQsTUFBTSxNQUdKLEVBQUU7SUFDSixPQUFPO1FBQ0wsTUFBTSxDQUFDLFFBQXNCO1lBQzNCLE1BQU0sSUFBSSxLQUFLLENBQ2Isd0VBQXdFLENBQ3pFLENBQUM7UUFDSixDQUFDO1FBQ0QsS0FBSyxDQUFDLE1BQU0sQ0FBQyxLQUFhLEVBQUUsT0FBZTtZQUN6QyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQztnQkFDM0IsT0FBTyxNQUFNLFVBQVUsQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQUM7WUFDMUMsQ0FBQztZQUVELElBQUksTUFBTSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDbkQsSUFBSSxNQUFNLFlBQVksT0FBTyxFQUFFLENBQUM7Z0JBQzlCLE1BQU0sR0FBRyxNQUFNLE1BQU0sQ0FBQztZQUN4QixDQUFDO1lBRUQsc0RBQXNEO1lBQ3RELElBQUksTUFBTSxDQUFDLE1BQU0sRUFBRSxDQUFDO2dCQUNsQixNQUFNLElBQUksS0FBSyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUMxRCxDQUFDO1lBRUQsT0FBTyxNQUFNLFVBQVUsQ0FBVSxLQUFLLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3hELENBQUM7S0FDRixDQUFDO0FBQ0osQ0FBQyJ9
+//# 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;AA2CD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,oBAAoB,GAC3B,gBAAgB,CA+ClB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,SAAS,CAAC,EAAE,YAAY,GACvB,gBAAgB,CAoElB"}

package/dist/describe-error.js

@@ -0,0 +1,165 @@
+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 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.';
+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.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 (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,
+        };
+    }
+    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.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":"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","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 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.';\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.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 (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  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.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

@@ -22,10 +22,16 @@ export type CryptoKey = import('node:crypto').webcrypto.CryptoKey;
  * 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.
  *
@@ -37,6 +43,21 @@ export declare function encrypt(key: CryptoKey, data: Uint8Array): Promise<Uint8
 /**
  * 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]`
  * @returns Decrypted plaintext

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;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,UAAU,EACf,MAAM,GAAE,aAAa,CAAC,SAAS,GAAG,SAAS,CAA0B,iDAiBtE;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CA4BrB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CA0CrB"}