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

package/dist/context-errors.d.ts

@@ -0,0 +1,27 @@
+import { ContextViolationError, type DocsUrl, NotInStepContextError, NotInWorkflowContextError, NotInWorkflowOrStepContextError } from './context-violation-error.js';
+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 declare class UnavailableInWorkflowContextError extends ContextViolationError {
+    name: string;
+    constructor(functionName: string, docsUrl: 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 declare function throwNotInWorkflowContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+/** See {@link throwNotInWorkflowContext}. */
+export declare function throwNotInStepContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+/** See {@link throwNotInWorkflowContext}. */
+export declare function throwNotInWorkflowOrStepContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+/** See {@link throwNotInWorkflowContext}. */
+export declare function throwUnavailableInWorkflowContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+//# sourceMappingURL=context-errors.d.ts.map

package/dist/context-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-errors.d.ts","sourceRoot":"","sources":["../src/context-errors.ts"],"names":[],"mappings":"AACA,OAAO,EACL,qBAAqB,EAErB,KAAK,OAAO,EACZ,qBAAqB,EACrB,yBAAyB,EACzB,+BAA+B,EAChC,MAAM,8BAA8B,CAAC;AAUtC,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,+BAA+B,GAChC,CAAC;AAEF;;;;GAIG;AACH,qBAAa,iCAAkC,SAAQ,qBAAqB;IAC1E,IAAI,SAAuC;gBAE/B,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;CAgDnD;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,EAEhB,YAAY,EAAE,QAAQ,GACrB,KAAK,CAIP;AAED,6CAA6C;AAC7C,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,EAEhB,YAAY,EAAE,QAAQ,GACrB,KAAK,CAIP;AAED,6CAA6C;AAC7C,wBAAgB,+BAA+B,CAC7C,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,EAEhB,YAAY,EAAE,QAAQ,GACrB,KAAK,CAIP;AAED,6CAA6C;AAC7C,wBAAgB,iCAAiC,CAC/C,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,EAEhB,YAAY,EAAE,QAAQ,GACrB,KAAK,CAIP"}

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,CAepD;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,149 @@
+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) => {\n      lines.push(`${i === 0 ? first : cont}${line}`);\n    });\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,5 @@
+import type { StringValue } from 'ms';
+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 +26,30 @@ export interface Hook<T = any> extends AsyncIterable<T>, Thenable<T> {
      * The token used to identify this hook.
      */
     token: string;
+    /**
+     * Returns the {@link Run} already using this token, or `null` when this Hook
+     * registers successfully.
+     *
+     * 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 without waiting for
+     * payload data.
+     *
+     * If it returns a run, this Hook was not created. Awaiting the Hook instead
+     * rejects with `HookConflictError`.
+     *
+     * @example
+     * ```ts
+     * using hook = createHook({ token: `order:${orderId}` });
+     * const conflict = await hook.getConflict();
+     * if (conflict) {
+     *   // another run already owns this token
+     *   return { status: 'duplicate', runId: conflict.runId };
+     * }
+     * // this Hook registered without waiting for payload data
+     * ```
+     */
+    getConflict(): Promise<Run<unknown> | null>;
     /**
      * Disposes the hook, releasing its token for reuse by other workflows.
      *
@@ -86,7 +112,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
      *
@@ -98,6 +126,36 @@ export interface HookOptions {
      * ```
      */
     token?: string;
+    /**
+     * **Experimental.** Keeps this Hook's token unavailable for at least the
+     * configured time after `createHook()` runs.
+     *
+     * Accepts the same values as `sleep()`: a duration string, a number of
+     * milliseconds, or an absolute `Date`. Relative durations start when
+     * `createHook()` runs, not when the workflow ends.
+     *
+     * The Hook remains active until the workflow ends, even if the configured
+     * time passes first. Another Hook can use the token only after both the run
+     * has ended and the configured time has passed.
+     * After the run ends, the Hook can still be found with `getHookByToken()`
+     * until retention ends, but it cannot be resumed.
+     *
+     * Calling `dispose()` (including through `using`) releases the token
+     * immediately.
+     *
+     * `createHook()` throws if the configured World does not support this
+     * experimental option.
+     *
+     * @example
+     *
+     * ```ts
+     * const hook = createHook({
+     *   token: `order:${orderId}`,
+     *   experimental_minRetention: '30d',
+     * });
+     * ```
+     */
+    experimental_minRetention?: StringValue | Date | number;
     /**
      * Additional user-defined data to include with the hook payload.
      *
@@ -117,8 +175,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()`.
@@ -127,7 +185,7 @@ export interface HookOptions {
      */
     isWebhook?: boolean;
 }
-export interface WebhookOptions extends Omit<HookOptions, 'token' | 'isWebhook'> {
+export interface WebhookOptions extends Omit<HookOptions, 'token' | 'isWebhook' | 'experimental_minRetention'> {
     /**
      * If set to a `Response` object, the webhook will automatically
      * respond with the specified response.

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":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC;AAEtC,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;;;;;;;;;;;;;;;;;;;;;;OAsBG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,yBAAyB,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM,CAAC;IAExD;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cACf,SAAQ,IAAI,CACV,WAAW,EACX,OAAO,GAAG,WAAW,GAAG,2BAA2B,CACpD;IACD;;;;;;;;;;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":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AA0NhE;;;;;;;;;;;;;;;;;;;;;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 type { StringValue } from 'ms';\nimport { 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 the {@link Run} already using this token, or `null` when this Hook\n   * registers successfully.\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 without waiting for\n   * payload data.\n   *\n   * If it returns a run, this Hook was not created. Awaiting the Hook instead\n   * rejects with `HookConflictError`.\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 { status: 'duplicate', runId: conflict.runId };\n   * }\n   * // this Hook registered 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   * **Experimental.** Keeps this Hook's token unavailable for at least the\n   * configured time after `createHook()` runs.\n   *\n   * Accepts the same values as `sleep()`: a duration string, a number of\n   * milliseconds, or an absolute `Date`. Relative durations start when\n   * `createHook()` runs, not when the workflow ends.\n   *\n   * The Hook remains active until the workflow ends, even if the configured\n   * time passes first. Another Hook can use the token only after both the run\n   * has ended and the configured time has passed.\n   * After the run ends, the Hook can still be found with `getHookByToken()`\n   * until retention ends, but it cannot be resumed.\n   *\n   * Calling `dispose()` (including through `using`) releases the token\n   * immediately.\n   *\n   * `createHook()` throws if the configured World does not support this\n   * experimental option.\n   *\n   * @example\n   *\n   * ```ts\n   * const hook = createHook({\n   *   token: `order:${orderId}`,\n   *   experimental_minRetention: '30d',\n   * });\n   * ```\n   */\n  experimental_minRetention?: StringValue | Date | number;\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<\n    HookOptions,\n    'token' | 'isWebhook' | 'experimental_minRetention'\n  > {\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"}