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

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/correlation-id.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Correlation-id generation for the entity families a replay can create.
+ *
+ * Correlation ids are minted by the workflow VM and are the server's identity
+ * gate: a conditional create on the id is what makes a duplicate write from a
+ * second live replay idempotent instead of additive. That only works if two
+ * replays of the same run mint the same id for the same entity.
+ *
+ * Historically every id was the Nth draw of *one* monotonic ULID sequence per
+ * run, shared by steps, waits, hooks, attribute writes, abort controllers and
+ * stream ids alike. Every id was therefore an ordinal over the whole run, and a
+ * single extra draw of any kind renumbered every entity of every kind after it.
+ * Two replays that agreed about every step but disagreed about one `sleep()`
+ * would mint different ids for all subsequent steps, so their writes appended
+ * side by side instead of colliding, and the settled log ended up holding two
+ * names for one logical step. Only one of them can be consumed on the next
+ * replay; the other is fatal (`onUnconsumedEvent`).
+ *
+ * Per-kind sources narrow that coupling to one kind at a time: each family
+ * draws from its own independent incrementing sequence, so a disagreement about
+ * how many hooks or sleeps were created no longer renames steps.
+ *
+ * Ids stay syntactically valid ULIDs (10 Crockford characters of
+ * `fixedTimestamp` plus 16 of body), because correlation ids are validated as
+ * prefixed 26-char ULIDs by the backend, and they stay monotonic *within* a
+ * kind, because `hooks.list` is ordered by hook id.
+ *
+ * Monotonicity is per kind, and two kinds mint `hook_` ids (`hook` and
+ * `abortHook`), so listing order is only creation order *within* each of them.
+ * No world filters system hooks out of a listing, so a run that constructs an
+ * abort controller and also creates its own hooks lists that system hook at a
+ * position decided by its kind's hash rather than at its creation position.
+ * Order among the user's own hooks is unaffected.
+ *
+ * This does not make ids independent of *ordinal position within their own
+ * kind*: two replays that disagree about how many steps ran still mint
+ * different ids for the next step. That is a narrower failure than the shared
+ * sequence's, not an eliminated one.
+ */
+/** Entity families that draw correlation ids, each from its own sequence. */
+export type CorrelationIdKind = 
+/** `step_` ids, one per step invocation. */
+'step'
+/** `wait_` ids, one per `sleep()`. */
+ | 'wait'
+/** `hook_` ids for hooks created by workflow code. */
+ | 'hook'
+/** `attr_` ids, one per attribute write. */
+ | 'attr'
+/**
+ * The abort controller's own id, which becomes its stream name and hook
+ * token. Separate from `hook` so constructing an abort controller does not
+ * renumber later user hooks.
+ */
+ | 'abort'
+/** `hook_` ids for the internal system hook backing an abort controller. */
+ | 'abortHook'
+/**
+ * Ids minted during serialization (`STABLE_ULID`): stream names, and an abort
+ * holder's stream name and `abrt_` hook token when it reaches serialization
+ * without an identity yet (`reduceAbortWithListener`), which is why `abort`
+ * above is not the only mint path for an abort identity. Not correlation ids,
+ * but they drew from the same shared sequence, so a workflow that serialized
+ * a stream renumbered every entity created after it.
+ */
+ | 'stream';
+/** Mints the ULID body of a correlation id for one entity family. */
+export type CorrelationIdGenerator = (kind: CorrelationIdKind) => string;
+/**
+ * Builds a replay's correlation-id generator.
+ *
+ * `perKind: false` returns the run's single shared monotonic sequence and
+ * ignores the kind entirely, so both schemes go through one call path and the
+ * flag is the only difference between them.
+ */
+export declare function createCorrelationIdGenerator(options: {
+    /**
+     * The run's replay-stable seed. Must not vary between replays of one run, and
+     * must differ between runs, or two runs would mint identical ids.
+     */
+    seed: string;
+    fixedTimestamp: number;
+    /** The run's shared monotonic sequence, used as-is when `perKind` is false. */
+    positional: () => string;
+    perKind: boolean;
+}): CorrelationIdGenerator;
+/** Length of a ULID, exported so tests need not restate it. */
+export declare const CORRELATION_ID_LENGTH: number;
+/**
+ * Whether each entity family draws correlation ids from its own sequence rather
+ * than from one sequence shared by the whole run. Off unless opted in, so an SDK
+ * upgrade alone never moves a run between schemes.
+ *
+ * The invariant either way: a run must replay under the scheme that minted its
+ * ids. A replay under the other scheme mints ids its own earlier events do not
+ * carry, so it can consume none of them and fails the run. Two things can break
+ * it, and both are about turning the flag on rather than about upgrading:
+ *
+ * - Enabling it while runs are in flight. On Vercel, skew protection keeps a run
+ *   on the deployment that started it, so a run only ever sees the value baked
+ *   into its own deployment. Elsewhere (world-postgres, world-local, a
+ *   self-hosted process) nothing pins a run to the code that started it, so
+ *   enable it during a quiet window.
+ * - A rolling deploy that leaves both values live, which puts two schemes on one
+ *   run concurrently — the side-by-side append this whole mechanism exists to
+ *   avoid. Roll the value out to the whole fleet at once.
+ */
+export declare function isPerKindCorrelationIdsEnabled(): boolean;
+//# sourceMappingURL=correlation-id.d.ts.map

package/dist/correlation-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correlation-id.d.ts","sourceRoot":"","sources":["../src/correlation-id.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,6EAA6E;AAC7E,MAAM,MAAM,iBAAiB;AAC3B,4CAA4C;AAC1C,MAAM;AACR,sCAAsC;GACpC,MAAM;AACR,sDAAsD;GACpD,MAAM;AACR,4CAA4C;GAC1C,MAAM;AACR;;;;GAIG;GACD,OAAO;AACT,4EAA4E;GAC1E,WAAW;AACb;;;;;;;GAOG;GACD,QAAQ,CAAC;AAEb,qEAAqE;AACrE,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE,iBAAiB,KAAK,MAAM,CAAC;AAoGzE;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE;IACpD;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG,sBAAsB,CAmBzB;AAED,+DAA+D;AAC/D,eAAO,MAAM,qBAAqB,QAA0B,CAAC;AAE7D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,8BAA8B,IAAI,OAAO,CAExD"}