@workflow/core 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/context-errors.js

@@ -0,0 +1,101 @@
+import { redirectStackToCaller } from './capture-stack.js';
+import { ContextViolationError, NotInStepContextError, NotInWorkflowContextError, NotInWorkflowOrStepContextError, } from './context-violation-error.js';
+import { WORKFLOW_CONTEXT_SYMBOL, } from './workflow/get-workflow-metadata.js';
+// Re-export the structural base + subclasses so the public surface is a
+// single import point. The base + simpler subclasses live in
+// `context-violation-error.ts` because `get-workflow-metadata.ts` needs to
+// throw one without creating an import cycle with this file.
+export { ContextViolationError, NotInStepContextError, NotInWorkflowContextError, NotInWorkflowOrStepContextError, };
+/**
+ * Thrown when an API that MUST NOT run inside a workflow function is called
+ * from one (e.g. `resumeHook()`, which would cause determinism issues).
+ * The message names the specific workflow that made the offending call.
+ */
+export class UnavailableInWorkflowContextError extends ContextViolationError {
+    name = 'UnavailableInWorkflowContextError';
+    constructor(functionName, docsUrl) {
+        const ctx = globalThis[WORKFLOW_CONTEXT_SYMBOL];
+        const workflowName = ctx?.workflowName;
+        // Apply dim styling to `workflow/` / `step/` prefixes in the qualified
+        // name so the part the user named stands out.
+        const nameSegs = (() => {
+            if (!workflowName)
+                return null;
+            const m = workflowName.match(/^(workflow\/|step\/)(.*)$/);
+            if (m)
+                return [{ dim: m[1] }, { text: m[2] }];
+            return [{ text: workflowName }];
+        })();
+        const contextLine = nameSegs
+            ? {
+                type: 'plain',
+                segments: [
+                    { text: 'this call was made from the ' },
+                    ...nameSegs,
+                    { text: ' workflow context.' },
+                ],
+            }
+            : {
+                type: 'plain',
+                segments: [{ text: 'this call was made from a workflow context.' }],
+            };
+        super({
+            title: [
+                { code: functionName },
+                { text: ' cannot be called from a workflow context.' },
+            ],
+            details: [
+                {
+                    type: 'plain',
+                    segments: [
+                        {
+                            text: 'calling this in a workflow context can cause determinism issues.',
+                        },
+                    ],
+                },
+                contextLine,
+                { type: 'docs', url: docsUrl },
+            ],
+        });
+    }
+}
+/**
+ * Throw a {@link NotInWorkflowContextError} whose stack trace points at the
+ * user code that called `stackStartFn`, not at our framework internals.
+ *
+ * Prefer this over `throw new NotInWorkflowContextError(...)` so tooling
+ * (Next.js error overlay, VS Code terminal linkifier, Sentry, etc.) shows
+ * the user's call site as the relevant frame.
+ */
+export function throwNotInWorkflowContext(functionName, docsUrl, 
+// biome-ignore lint/complexity/noBannedTypes: matches Error.captureStackTrace
+stackStartFn) {
+    const err = new NotInWorkflowContextError(functionName, docsUrl);
+    redirectStackToCaller(err, stackStartFn);
+    throw err;
+}
+/** See {@link throwNotInWorkflowContext}. */
+export function throwNotInStepContext(functionName, docsUrl, 
+// biome-ignore lint/complexity/noBannedTypes: matches Error.captureStackTrace
+stackStartFn) {
+    const err = new NotInStepContextError(functionName, docsUrl);
+    redirectStackToCaller(err, stackStartFn);
+    throw err;
+}
+/** See {@link throwNotInWorkflowContext}. */
+export function throwNotInWorkflowOrStepContext(functionName, docsUrl, 
+// biome-ignore lint/complexity/noBannedTypes: matches Error.captureStackTrace
+stackStartFn) {
+    const err = new NotInWorkflowOrStepContextError(functionName, docsUrl);
+    redirectStackToCaller(err, stackStartFn);
+    throw err;
+}
+/** See {@link throwNotInWorkflowContext}. */
+export function throwUnavailableInWorkflowContext(functionName, docsUrl, 
+// biome-ignore lint/complexity/noBannedTypes: matches Error.captureStackTrace
+stackStartFn) {
+    const err = new UnavailableInWorkflowContextError(functionName, docsUrl);
+    redirectStackToCaller(err, stackStartFn);
+    throw err;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-errors.js","sourceRoot":"","sources":["../src/context-errors.ts"],"names":[],"mappings":"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","sourcesContent":["import { redirectStackToCaller } from './capture-stack.js';\nimport {\n  ContextViolationError,\n  type Detail,\n  type DocsUrl,\n  NotInStepContextError,\n  NotInWorkflowContextError,\n  NotInWorkflowOrStepContextError,\n} from './context-violation-error.js';\nimport {\n  WORKFLOW_CONTEXT_SYMBOL,\n  type WorkflowMetadata,\n} from './workflow/get-workflow-metadata.js';\n\n// Re-export the structural base + subclasses so the public surface is a\n// single import point. The base + simpler subclasses live in\n// `context-violation-error.ts` because `get-workflow-metadata.ts` needs to\n// throw one without creating an import cycle with this file.\nexport {\n  ContextViolationError,\n  NotInStepContextError,\n  NotInWorkflowContextError,\n  NotInWorkflowOrStepContextError,\n};\n\n/**\n * Thrown when an API that MUST NOT run inside a workflow function is called\n * from one (e.g. `resumeHook()`, which would cause determinism issues).\n * The message names the specific workflow that made the offending call.\n */\nexport class UnavailableInWorkflowContextError extends ContextViolationError {\n  name = 'UnavailableInWorkflowContextError';\n\n  constructor(functionName: string, docsUrl: DocsUrl) {\n    const ctx = (globalThis as any)[WORKFLOW_CONTEXT_SYMBOL] as\n      | WorkflowMetadata\n      | undefined;\n    const workflowName = ctx?.workflowName;\n\n    // Apply dim styling to `workflow/` / `step/` prefixes in the qualified\n    // name so the part the user named stands out.\n    const nameSegs = (() => {\n      if (!workflowName) return null;\n      const m = workflowName.match(/^(workflow\\/|step\\/)(.*)$/);\n      if (m) return [{ dim: m[1] }, { text: m[2] }] as const;\n      return [{ text: workflowName }] as const;\n    })();\n\n    const contextLine: Detail = nameSegs\n      ? {\n          type: 'plain',\n          segments: [\n            { text: 'this call was made from the ' },\n            ...nameSegs,\n            { text: ' workflow context.' },\n          ],\n        }\n      : {\n          type: 'plain',\n          segments: [{ text: 'this call was made from a workflow context.' }],\n        };\n\n    super({\n      title: [\n        { code: functionName },\n        { text: ' cannot be called from a workflow context.' },\n      ],\n      details: [\n        {\n          type: 'plain',\n          segments: [\n            {\n              text: 'calling this in a workflow context can cause determinism issues.',\n            },\n          ],\n        },\n        contextLine,\n        { type: 'docs', url: docsUrl },\n      ],\n    });\n  }\n}\n\n/**\n * Throw a {@link NotInWorkflowContextError} whose stack trace points at the\n * user code that called `stackStartFn`, not at our framework internals.\n *\n * Prefer this over `throw new NotInWorkflowContextError(...)` so tooling\n * (Next.js error overlay, VS Code terminal linkifier, Sentry, etc.) shows\n * the user's call site as the relevant frame.\n */\nexport function throwNotInWorkflowContext(\n  functionName: string,\n  docsUrl: DocsUrl,\n  // biome-ignore lint/complexity/noBannedTypes: matches Error.captureStackTrace\n  stackStartFn: Function\n): never {\n  const err = new NotInWorkflowContextError(functionName, docsUrl);\n  redirectStackToCaller(err, stackStartFn);\n  throw err;\n}\n\n/** See {@link throwNotInWorkflowContext}. */\nexport function throwNotInStepContext(\n  functionName: string,\n  docsUrl: DocsUrl,\n  // biome-ignore lint/complexity/noBannedTypes: matches Error.captureStackTrace\n  stackStartFn: Function\n): never {\n  const err = new NotInStepContextError(functionName, docsUrl);\n  redirectStackToCaller(err, stackStartFn);\n  throw err;\n}\n\n/** See {@link throwNotInWorkflowContext}. */\nexport function throwNotInWorkflowOrStepContext(\n  functionName: string,\n  docsUrl: DocsUrl,\n  // biome-ignore lint/complexity/noBannedTypes: matches Error.captureStackTrace\n  stackStartFn: Function\n): never {\n  const err = new NotInWorkflowOrStepContextError(functionName, docsUrl);\n  redirectStackToCaller(err, stackStartFn);\n  throw err;\n}\n\n/** See {@link throwNotInWorkflowContext}. */\nexport function throwUnavailableInWorkflowContext(\n  functionName: string,\n  docsUrl: DocsUrl,\n  // biome-ignore lint/complexity/noBannedTypes: matches Error.captureStackTrace\n  stackStartFn: Function\n): never {\n  const err = new UnavailableInWorkflowContextError(functionName, docsUrl);\n  redirectStackToCaller(err, stackStartFn);\n  throw err;\n}\n"]}

package/dist/context-violation-error.d.ts

@@ -0,0 +1,97 @@
+/**
+ * A `docs:` line URL. The leading protocol is part of the type so call sites
+ * can't accidentally pass a protocol-relative or bare path.
+ */
+export type DocsUrl = `https://${string}`;
+declare const INSPECT_CUSTOM: unique symbol;
+/**
+ * Structured data for a framed error. The base class takes this and renders
+ * it to plain text (for `.message` / `.stack` / structured logs) or to an
+ * ANSI-framed string (for terminal display via `util.inspect` / `toString`).
+ *
+ * Keeping the pieces structured means we never have to strip ANSI back out
+ * once it's in the message — we just don't put it there in the first place.
+ */
+export interface FramedContent {
+    /** Headline. `{ code: 'foo()' }` segments render as backticked inline code. */
+    readonly title: readonly Segment[];
+    /** One framed branch per entry. The last uses `╰▶`, others use `├▶`. */
+    readonly details: readonly Detail[];
+}
+export type Segment = {
+    readonly text: string;
+} | {
+    readonly code: string;
+} | {
+    readonly dim: string;
+};
+export type Detail = {
+    readonly type: 'plain';
+    readonly segments: readonly Segment[];
+} | {
+    readonly type: 'docs';
+    readonly url: DocsUrl;
+};
+export declare function renderPlain(c: FramedContent): string;
+export declare function renderPretty(c: FramedContent): string;
+/**
+ * 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 declare abstract class ContextViolationError extends Error {
+    #private;
+    /** Non-retryable — see class doc. */
+    readonly fatal = true;
+    constructor(content: FramedContent);
+    /**
+     * `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](): string;
+    toString(): string;
+}
+/**
+ * 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 declare class NotInWorkflowContextError extends ContextViolationError {
+    name: string;
+    constructor(functionName: string, docsUrl: DocsUrl);
+}
+/**
+ * Thrown when an API that must run inside a step function is called from
+ * outside a step context.
+ */
+export declare class NotInStepContextError extends ContextViolationError {
+    name: string;
+    constructor(functionName: string, docsUrl: DocsUrl);
+}
+/**
+ * Thrown when an API that must run inside either a workflow or step function
+ * is called from regular application code.
+ */
+export declare class NotInWorkflowOrStepContextError extends ContextViolationError {
+    name: string;
+    constructor(functionName: string, docsUrl: DocsUrl);
+}
+export {};
+//# sourceMappingURL=context-violation-error.d.ts.map

package/dist/context-violation-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-violation-error.d.ts","sourceRoot":"","sources":["../src/context-violation-error.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,WAAW,MAAM,EAAE,CAAC;AAE1C,QAAA,MAAM,cAAc,eAA2C,CAAC;AAEhE;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,CAAC;IACnC,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,MAAM,MAAM,OAAO,GACf;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7B,MAAM,MAAM,MAAM,GACd;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAA;CAAE,GACjE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;CAAE,CAAC;AAwBrD,wBAAgB,WAAW,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAapD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAGrD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8BAAsB,qBAAsB,SAAQ,KAAK;;IACvD,qCAAqC;IACrC,QAAQ,CAAC,KAAK,QAAQ;gBAIV,OAAO,EAAE,aAAa;IAKlC;;;;;OAKG;IACH,CAAC,cAAc,CAAC,IAAI,MAAM;IAgB1B,QAAQ,IAAI,MAAM;CAGnB;AAED;;;;GAIG;AACH,qBAAa,yBAA0B,SAAQ,qBAAqB;IAClE,IAAI,SAA+B;gBAEvB,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;CASnD;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,qBAAqB;IAC9D,IAAI,SAA2B;gBAEnB,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;CASnD;AAED;;;GAGG;AACH,qBAAa,+BAAgC,SAAQ,qBAAqB;IACxE,IAAI,SAAqC;gBAE7B,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;CASnD"}

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

@@ -1,3 +1,4 @@
+import type { Run } from './runtime/run.js';
 import type { Serializable } from './schemas.js';
 /**
  * An object that can be awaited to receive a value.
@@ -24,6 +25,42 @@ export interface Hook<T = any> extends AsyncIterable<T>, Thenable<T> {
      * The token used to identify this hook.
      */
     token: string;
+    /**
+     * Returns a promise that resolves with the conflicting {@link Run} if
+     * another active hook already owns this hook's token, or `null` once
+     * the hook has been registered and is ready to receive payloads.
+     *
+     * Calling `createHook()` alone does not register the hook — registration
+     * only happens when the workflow suspends. Awaiting `getConflict()`
+     * suspends the workflow to commit the hook registration, so it can be
+     * used to claim the token (and detect token conflicts early) without
+     * waiting for payload data.
+     *
+     * When a conflict is detected, the resolved `Run` is the run that
+     * currently owns the token. The workflow can decide how to handle the
+     * duplicate in code: return or log `conflict.runId`, inspect
+     * `await conflict.status`, await `conflict.returnValue`, or cancel the
+     * owner with `await conflict.cancel()` and continue in the current run.
+     *
+     * Note that awaiting the hook's payload (`await hook`) when the token is
+     * already owned by another active hook still rejects with
+     * `HookConflictError`. In the rare case where the conflicting run cannot
+     * be identified (a `hook_conflict` event persisted by an old world that
+     * did not record the owning run's ID), `getConflict()` also rejects with
+     * `HookConflictError` rather than resolving with an incomplete value.
+     *
+     * @example
+     * ```ts
+     * using hook = createHook({ token: `order:${orderId}` });
+     * const conflict = await hook.getConflict();
+     * if (conflict) {
+     *   // another run already owns this token
+     *   return { dedupedTo: conflict.runId };
+     * }
+     * // token is now claimed, without waiting for payload data
+     * ```
+     */
+    getConflict(): Promise<Run<unknown> | null>;
     /**
      * Disposes the hook, releasing its token for reuse by other workflows.
      *
@@ -86,7 +123,9 @@ export interface HookOptions {
      * tokens are always randomly generated to prevent unauthorized access
      * to the public webhook endpoint.
      *
-     * If not provided, a randomly generated token will be assigned.
+     * If provided, the token must be a non-empty string; passing an empty
+     * string throws. If not provided (or `undefined`), a randomly generated
+     * token will be assigned.
      *
      * @example
      *
@@ -117,8 +156,8 @@ export interface HookOptions {
      * Whether this hook can be resumed via the public webhook endpoint.
      *
      * When `true`, the hook can be triggered by sending an HTTP request to the
-     * public `/.well-known/workflow/v1/webhook/{token}` URL. This is automatically
-     * set when using `createWebhook()`.
+     * public workflow webhook URL. This is automatically set when using
+     * `createWebhook()`.
      *
      * When `false` (the default), the hook can only be resumed server-side
      * via `resumeHook()`.

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,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAC5C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;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,{"version":3,"file":"create-hook.js","sourceRoot":"","sources":["../src/create-hook.ts"],"names":[],"mappings":"AA2JA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oDAAoD;AACpD,MAAM,UAAU,UAAU,CAAU,OAAqB;IACvD,MAAM,IAAI,KAAK,CACb,8DAA8D,CAC/D,CAAC;AACJ,CAAC;AAaD,MAAM,UAAU,aAAa;AAC3B,oDAAoD;AACpD,OAAwB;IAExB,MAAM,IAAI,KAAK,CACb,iEAAiE,CAClE,CAAC;AACJ,CAAC","sourcesContent":["import 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  throw new Error(\n    '`createHook()` can only be called inside a workflow function'\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  throw new Error(\n    '`createWebhook()` can only be called inside a workflow function'\n  );\n}\n"]}
+//# 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;AAoMhE;;;;;;;;;;;;;;;;;;;;;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 { Run } from './runtime/run.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   * Returns a promise that resolves with the conflicting {@link Run} if\n   * another active hook already owns this hook's token, or `null` once\n   * the hook has been registered and is ready to receive payloads.\n   *\n   * Calling `createHook()` alone does not register the hook — registration\n   * only happens when the workflow suspends. Awaiting `getConflict()`\n   * suspends the workflow to commit the hook registration, so it can be\n   * used to claim the token (and detect token conflicts early) without\n   * waiting for payload data.\n   *\n   * When a conflict is detected, the resolved `Run` is the run that\n   * currently owns the token. The workflow can decide how to handle the\n   * duplicate in code: return or log `conflict.runId`, inspect\n   * `await conflict.status`, await `conflict.returnValue`, or cancel the\n   * owner with `await conflict.cancel()` and continue in the current run.\n   *\n   * Note that awaiting the hook's payload (`await hook`) when the token is\n   * already owned by another active hook still rejects with\n   * `HookConflictError`. In the rare case where the conflicting run cannot\n   * be identified (a `hook_conflict` event persisted by an old world that\n   * did not record the owning run's ID), `getConflict()` also rejects with\n   * `HookConflictError` rather than resolving with an incomplete value.\n   *\n   * @example\n   * ```ts\n   * using hook = createHook({ token: `order:${orderId}` });\n   * const conflict = await hook.getConflict();\n   * if (conflict) {\n   *   // another run already owns this token\n   *   return { dedupedTo: conflict.runId };\n   * }\n   * // token is now claimed, without waiting for payload data\n   * ```\n   */\n  getConflict(): Promise<Run<unknown> | null>;\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 provided, the token must be a non-empty string; passing an empty\n   * string throws. If not provided (or `undefined`), a randomly generated\n   * 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 workflow webhook URL. This is automatically set when using\n   * `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,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
+//# sourceMappingURL=data:application/json;base64,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