@workflow/core 5.0.0-beta.5 → 5.0.0-beta.51

package/dist/classify-error.js

@@ -1,8 +1,28 @@
-import { RUN_ERROR_CODES, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRuntimeError, } from '@workflow/errors';
+import { CorruptedEventLogError, MaxEventsExceededError, ReplayDivergenceError, RUN_ERROR_CODES, RuntimeDecryptionError, StepNotRegisteredError, StreamError, ThrottleError, WorkflowDeploymentMismatchError, WorkflowNotRegisteredError, WorkflowRuntimeError, WorkflowWorldError, } from '@workflow/errors';
+const WORLD_CONTRACT_ERROR_CODES = new Set([
+    'PARSE_ERROR',
+    'SCHEMA_VALIDATION',
+    RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,
+]);
 /**
- * Set of error names that should classify as `RUNTIME_ERROR`. Each
+ * `WorkflowWorldError.code` values that mark a transient transport failure
+ * (set by world-vercel's HTTP client): `TRANSPORT` covers an exhausted
+ * RetryAgent (`UND_ERR_REQ_RETRY`, e.g. the firewall in front of
+ * workflow-server shedding load with 429/503), a dropped socket, or a
+ * connect/DNS failure; `TIMEOUT` covers a request that exceeded the client
+ * timeout. Both are infrastructure failures a fresh invocation can recover
+ * from. Kept distinct from `WORLD_CONTRACT_ERROR_CODES` so a transport blip is
+ * never misclassified as the server returning a malformed response.
+ */
+const RETRYABLE_WORLD_ERROR_CODES = new Set([
+    'TRANSPORT',
+    'TIMEOUT',
+    RUN_ERROR_CODES.STREAM_ERROR,
+]);
+/**
+ * Set of error names that should classify as generic `RUNTIME_ERROR`. Each
  * `*.is()` static does a name-based duck check, so subclassing alone is
- * not enough — we have to enumerate every concrete subclass we want to
+ * not enough, so we have to enumerate every concrete subclass we want to
  * recognize. Keep in sync with the `WorkflowRuntimeError` class hierarchy
  * in `@workflow/errors`.
  */
@@ -10,6 +30,11 @@ const RUNTIME_ERROR_CHECKS = [
     WorkflowRuntimeError.is,
     StepNotRegisteredError.is,
     WorkflowNotRegisteredError.is,
+    // SDK-level encryption failures (most notably AES-GCM auth-tag
+    // mismatches surfacing as a native `OperationError` from
+    // `AESCipherJob.onDone`) are wrapped in `RuntimeDecryptionError` at
+    // the encryption module boundary.
+    RuntimeDecryptionError.is,
 ];
 /**
  * Classify an error that caused a workflow run to fail.
@@ -17,8 +42,8 @@ const RUNTIME_ERROR_CHECKS = [
  * After the structural separation of infrastructure vs user code error
  * handling, the only errors that reach the `run_failed` try/catch are:
  * - User code errors (throws from workflow functions, propagated step failures)
- * - WorkflowRuntimeError and subclasses (corrupted event log, missing
- *   timestamps, workflow/step not registered, etc.)
+ * - WorkflowRuntimeError and subclasses (missing timestamps, workflow/step
+ *   not registered, corrupted event log, etc.)
  *
  * Uses each subclass's `.is()` static (a name-based duck check) instead of
  * a single `instanceof` check because workflows execute in a separate
@@ -27,7 +52,74 @@ const RUNTIME_ERROR_CHECKS = [
  * thrown inside the workflow VM and we'd misclassify genuine runtime
  * errors as user errors.
  */
+export function isWorldContractError(err) {
+    if (!WorkflowWorldError.is(err) || err.status !== undefined) {
+        return false;
+    }
+    const cause = 'cause' in err ? err.cause : undefined;
+    return ((err.code !== undefined && WORLD_CONTRACT_ERROR_CODES.has(err.code)) ||
+        err.message.startsWith('Failed to parse response body for ') ||
+        err.message.startsWith('Schema validation failed for ') ||
+        (typeof cause === 'object' &&
+            cause !== null &&
+            'name' in cause &&
+            cause.name === 'ZodError'));
+}
+/**
+ * True when an error from a world (workflow-server) call is a transient
+ * infrastructure failure that should be retried by redelivering the queue
+ * message, rather than failing the run. A fresh invocation will likely
+ * succeed once the backend (or the firewall in front of it) recovers.
+ *
+ * - `ThrottleError` (429): rate limited / load shed
+ * - `WorkflowWorldError` with `status >= 500`: server-side error
+ * - `WorkflowWorldError` with a retryable transport `code` (`TRANSPORT` /
+ *   `TIMEOUT`): the request never produced a usable response
+ *
+ * Uses `.is()` name-based duck checks (not `instanceof`) for the same
+ * cross-`vm`-realm reason described on `classifyRunError`.
+ */
+export function isRetryableWorldError(err) {
+    if (ThrottleError.is(err)) {
+        return true;
+    }
+    if (StreamError.is(err)) {
+        return err.status === undefined || err.status >= 500;
+    }
+    if (!WorkflowWorldError.is(err)) {
+        return false;
+    }
+    if (err.status !== undefined && err.status >= 500) {
+        return true;
+    }
+    return err.code !== undefined && RETRYABLE_WORLD_ERROR_CODES.has(err.code);
+}
 export function classifyRunError(err) {
+    if (ReplayDivergenceError.is(err)) {
+        return RUN_ERROR_CODES.REPLAY_DIVERGENCE;
+    }
+    if (CorruptedEventLogError.is(err)) {
+        return RUN_ERROR_CODES.CORRUPTED_EVENT_LOG;
+    }
+    if (MaxEventsExceededError.is(err)) {
+        return RUN_ERROR_CODES.MAX_EVENTS_EXCEEDED;
+    }
+    if (WorkflowDeploymentMismatchError.is(err)) {
+        return RUN_ERROR_CODES.DEPLOYMENT_MISMATCH;
+    }
+    // World-layer faults, both a malformed response (contract violation) and a
+    // transient infrastructure failure (throttle / 5xx / transport / timeout,
+    // e.g. a firewall challenge), are the backend's fault, not the user's.
+    // Bucket them under WORLD_CONTRACT_ERROR rather than USER_ERROR so dashboards
+    // attribute an outage correctly. Note the retryable variants are normally
+    // redelivered via the queue (see `isRetryableWorldError`) and only reach this
+    // terminal classification if the run ultimately gives up.
+    if (StreamError.is(err)) {
+        return RUN_ERROR_CODES.STREAM_ERROR;
+    }
+    if (isWorldContractError(err) || isRetryableWorldError(err)) {
+        return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;
+    }
     for (const isMatch of RUNTIME_ERROR_CHECKS) {
         if (isMatch(err)) {
             return RUN_ERROR_CODES.RUNTIME_ERROR;
@@ -35,4 +127,4 @@ export function classifyRunError(err) {
     }
     return RUN_ERROR_CODES.USER_ERROR;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classify-error.js","sourceRoot":"","sources":["../src/classify-error.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CorruptedEventLogError,\n  MaxEventsExceededError,\n  ReplayDivergenceError,\n  RUN_ERROR_CODES,\n  type RunErrorCode,\n  RuntimeDecryptionError,\n  StepNotRegisteredError,\n  StreamError,\n  ThrottleError,\n  WorkflowDeploymentMismatchError,\n  WorkflowNotRegisteredError,\n  WorkflowRuntimeError,\n  WorkflowWorldError,\n} from '@workflow/errors';\n\nconst WORLD_CONTRACT_ERROR_CODES = new Set([\n  'PARSE_ERROR',\n  'SCHEMA_VALIDATION',\n  RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,\n]);\n\n/**\n * `WorkflowWorldError.code` values that mark a transient transport failure\n * (set by world-vercel's HTTP client): `TRANSPORT` covers an exhausted\n * RetryAgent (`UND_ERR_REQ_RETRY`, e.g. the firewall in front of\n * workflow-server shedding load with 429/503), a dropped socket, or a\n * connect/DNS failure; `TIMEOUT` covers a request that exceeded the client\n * timeout. Both are infrastructure failures a fresh invocation can recover\n * from. Kept distinct from `WORLD_CONTRACT_ERROR_CODES` so a transport blip is\n * never misclassified as the server returning a malformed response.\n */\nconst RETRYABLE_WORLD_ERROR_CODES = new Set([\n  'TRANSPORT',\n  'TIMEOUT',\n  RUN_ERROR_CODES.STREAM_ERROR,\n]);\n\n/**\n * Set of error names that should classify as generic `RUNTIME_ERROR`. Each\n * `*.is()` static does a name-based duck check, so subclassing alone is\n * not enough, so we have to enumerate every concrete subclass we want to\n * recognize. Keep in sync with the `WorkflowRuntimeError` class hierarchy\n * in `@workflow/errors`.\n */\nconst RUNTIME_ERROR_CHECKS = [\n  WorkflowRuntimeError.is,\n  StepNotRegisteredError.is,\n  WorkflowNotRegisteredError.is,\n  // SDK-level encryption failures (most notably AES-GCM auth-tag\n  // mismatches surfacing as a native `OperationError` from\n  // `AESCipherJob.onDone`) are wrapped in `RuntimeDecryptionError` at\n  // the encryption module boundary.\n  RuntimeDecryptionError.is,\n];\n\n/**\n * Classify an error that caused a workflow run to fail.\n *\n * After the structural separation of infrastructure vs user code error\n * handling, the only errors that reach the `run_failed` try/catch are:\n * - User code errors (throws from workflow functions, propagated step failures)\n * - WorkflowRuntimeError and subclasses (missing timestamps, workflow/step\n *   not registered, corrupted event log, etc.)\n *\n * Uses each subclass's `.is()` static (a name-based duck check) instead of\n * a single `instanceof` check because workflows execute in a separate\n * `vm` realm: the VM-context `WorkflowRuntimeError` and the host-context\n * one are distinct classes, so `instanceof` returns `false` for any error\n * thrown inside the workflow VM and we'd misclassify genuine runtime\n * errors as user errors.\n */\nexport function isWorldContractError(err: unknown): err is WorkflowWorldError {\n  if (!WorkflowWorldError.is(err) || err.status !== undefined) {\n    return false;\n  }\n\n  const cause = 'cause' in err ? err.cause : undefined;\n  return (\n    (err.code !== undefined && WORLD_CONTRACT_ERROR_CODES.has(err.code)) ||\n    err.message.startsWith('Failed to parse response body for ') ||\n    err.message.startsWith('Schema validation failed for ') ||\n    (typeof cause === 'object' &&\n      cause !== null &&\n      'name' in cause &&\n      cause.name === 'ZodError')\n  );\n}\n\n/**\n * True when an error from a world (workflow-server) call is a transient\n * infrastructure failure that should be retried by redelivering the queue\n * message, rather than failing the run. A fresh invocation will likely\n * succeed once the backend (or the firewall in front of it) recovers.\n *\n * - `ThrottleError` (429): rate limited / load shed\n * - `WorkflowWorldError` with `status >= 500`: server-side error\n * - `WorkflowWorldError` with a retryable transport `code` (`TRANSPORT` /\n *   `TIMEOUT`): the request never produced a usable response\n *\n * Uses `.is()` name-based duck checks (not `instanceof`) for the same\n * cross-`vm`-realm reason described on `classifyRunError`.\n */\nexport function isRetryableWorldError(err: unknown): boolean {\n  if (ThrottleError.is(err)) {\n    return true;\n  }\n  if (StreamError.is(err)) {\n    return err.status === undefined || err.status >= 500;\n  }\n  if (!WorkflowWorldError.is(err)) {\n    return false;\n  }\n  if (err.status !== undefined && err.status >= 500) {\n    return true;\n  }\n  return err.code !== undefined && RETRYABLE_WORLD_ERROR_CODES.has(err.code);\n}\n\nexport function classifyRunError(err: unknown): RunErrorCode {\n  if (ReplayDivergenceError.is(err)) {\n    return RUN_ERROR_CODES.REPLAY_DIVERGENCE;\n  }\n\n  if (CorruptedEventLogError.is(err)) {\n    return RUN_ERROR_CODES.CORRUPTED_EVENT_LOG;\n  }\n\n  if (MaxEventsExceededError.is(err)) {\n    return RUN_ERROR_CODES.MAX_EVENTS_EXCEEDED;\n  }\n\n  if (WorkflowDeploymentMismatchError.is(err)) {\n    return RUN_ERROR_CODES.DEPLOYMENT_MISMATCH;\n  }\n\n  // World-layer faults, both a malformed response (contract violation) and a\n  // transient infrastructure failure (throttle / 5xx / transport / timeout,\n  // e.g. a firewall challenge), are the backend's fault, not the user's.\n  // Bucket them under WORLD_CONTRACT_ERROR rather than USER_ERROR so dashboards\n  // attribute an outage correctly. Note the retryable variants are normally\n  // redelivered via the queue (see `isRetryableWorldError`) and only reach this\n  // terminal classification if the run ultimately gives up.\n  if (StreamError.is(err)) {\n    return RUN_ERROR_CODES.STREAM_ERROR;\n  }\n\n  if (isWorldContractError(err) || isRetryableWorldError(err)) {\n    return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;\n  }\n\n  for (const isMatch of RUNTIME_ERROR_CHECKS) {\n    if (isMatch(err)) {\n      return RUN_ERROR_CODES.RUNTIME_ERROR;\n    }\n  }\n  return RUN_ERROR_CODES.USER_ERROR;\n}\n"]}

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

@@ -10,7 +10,7 @@ declare const INSPECT_CUSTOM: unique symbol;
  * 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.
+ * once it's in the message because we don't put it there in the first place.
  */
 export interface FramedContent {
     /** Headline. `{ code: 'foo()' }` segments render as backticked inline code. */
@@ -41,7 +41,7 @@ export declare function renderPretty(c: FramedContent): string;
  *
  * - `.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
+ *   `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
@@ -50,13 +50,13 @@ export declare function renderPretty(c: FramedContent): string;
  *   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
+ *   from a step function will never succeed no matter how many retries.
+ *   Burning attempts 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. */
+    /** Non-retryable, see class doc. */
     readonly fatal = true;
     constructor(content: FramedContent);
     /**

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

@@ -1 +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"}
+{"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,oCAAoC;IACpC,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

@@ -34,7 +34,9 @@ export function renderPlain(c) {
         const first = isLast ? '╰▶ ' : '├▶ ';
         const cont = isLast ? '   ' : '│  ';
         const raw = renderDetailPlain(detail).split('\n');
-        raw.forEach((line, i) => lines.push(`${i === 0 ? first : cont}${line}`));
+        raw.forEach((line, i) => {
+            lines.push(`${i === 0 ? first : cont}${line}`);
+        });
     });
     return lines.join('\n');
 }
@@ -49,7 +51,7 @@ export function renderPretty(c) {
  *
  * - `.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
+ *   `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
@@ -58,12 +60,12 @@ export function renderPretty(c) {
  *   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
+ *   from a step function will never succeed no matter how many retries.
+ *   Burning attempts 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. */
+    /** Non-retryable, see class doc. */
     fatal = true;
     #content;
     constructor(content) {
@@ -144,4 +146,4 @@ export class NotInWorkflowOrStepContextError extends ContextViolationError {
         });
     }
 }
-//# 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"]}
+//# 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 because we 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 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.
      *
@@ -82,11 +108,17 @@ export interface HookOptions {
      * the token with the information it has available.
      *
      * Deterministic tokens are intended for use with `createHook()` and
-     * server-side `resumeHook()` only. For webhooks (`createWebhook()`),
-     * tokens are always randomly generated to prevent unauthorized access
-     * to the public webhook endpoint.
+     * server-side `resumeHook()` only. For webhooks (`createWebhook()`), an
+     * explicit token is not accepted, one is always generated for you.
      *
-     * If not provided, a randomly generated token will be assigned.
+     * A generated token is not trivial to guess but is not a security
+     * contract, so authenticate webhook requests themselves rather than
+     * relying on URL secrecy:
+     * https://workflow-sdk.dev/docs/foundations/hooks#token-design
+     *
+     * If provided, the token must be a non-empty string; passing an empty
+     * string throws. If not provided (or `undefined`), a token is generated
+     * for you.
      *
      * @example
      *
@@ -98,9 +130,42 @@ 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.
      *
+     * Read it back outside the workflow with `getHookByToken()`, where
+     * `hook.metadata` is a Promise: `await hook.metadata`.
+     *
      * @example
      *
      * ```ts
@@ -117,8 +182,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 +192,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":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;GAEG;AACH,UAAU,QAAQ,CAAC,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IAClD,WAAW,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;;;;;;;;;;;OAYG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,SAAS,OAAO,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;IACzD;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC;IAChD;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAMlE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,GAAG;IAAE,WAAW,EAAE,QAAQ,CAAA;CAAE,GAClD,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,yBAAyB,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM,CAAC;IAExD;;;;;;;;;;;;;;;;OAgBG;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

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

@@ -35,7 +35,7 @@ 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.
+        // = defineHook(); create()`), since in that case `this` is undefined.
         throwNotInWorkflowContext('defineHook().create()', 'https://workflow-sdk.dev/docs/api-reference/workflow/define-hook', create);
     }
     return {
@@ -66,4 +66,4 @@ export function defineHook({ schema, } = {}) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/describe-error.d.ts

@@ -4,7 +4,7 @@ import { type RunErrorCode } from '@workflow/errors';
  *
  * - `user`: the error came from customer code (a step or workflow function
  *   threw, or a value they passed across a boundary wasn't serializable).
- * - `sdk`: the SDK produced the error itself — an internal invariant broke,
+ * - `sdk`: the SDK produced the error itself: an internal invariant broke,
  *   or a runtime guard rejected the call. These should be rare; when they
  *   happen we want to frame the terminal output as "this is us, not you."
  */
@@ -26,7 +26,7 @@ export interface ErrorDescription {
  *
  * - `errorCode` is typed as `string` rather than `RunErrorCode` because
  *   the value comes from stored JSON/CBOR and may predate the current
- *   enum — callers should not narrow on it blindly. Values that don't
+ *   enum, so callers should not narrow on it blindly. Values that don't
  *   match a known `RUN_ERROR_CODES` entry fall through to USER_ERROR.
  * - `errorName` is the thrown `Error#name`. It is not universally
  *   persisted today; callers that have access to it (either via an
@@ -40,13 +40,13 @@ export interface PersistedErrorSignal {
 }
 /**
  * Data-driven variant of {@link describeError} that works from persisted
- * event fields instead of a live `Error` instance. Intended for CLI/web
- * renderers that read failure events and no longer have the original
- * thrown object.
+ * event fields instead of a live `Error` instance. Intended for command-line
+ * interface (CLI) and web renderers that read failure events and no longer
+ * have the original thrown object.
  */
 export declare function describeRunError(signal: PersistedErrorSignal): ErrorDescription;
 /**
- * Describe an error for user-facing presentation. Purely informational —
+ * Describe an error for user-facing presentation. Purely informational: it
  * does not change any persisted event data or error classification used by
  * the runtime.
  *
@@ -58,7 +58,7 @@ export declare function describeRunError(signal: PersistedErrorSignal): ErrorDes
  * - Context-violation errors (`NotInWorkflowContextError`, etc.) likewise
  *   describe a user mistake.
  * - `WorkflowRuntimeError` (and subclasses like `StepNotRegisteredError`)
- *   indicates an internal SDK invariant broke — surface that as `sdk`.
+ *   indicates an internal SDK invariant broke, so surface that as `sdk`.
  *
  * @param err The error value thrown by the workflow / step.
  * @param errorCode Optional precomputed error code. Callers that already

package/dist/describe-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"describe-error.d.ts","sourceRoot":"","sources":["../src/describe-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAC;AAS1B;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,KAAK,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,EAAE,YAAY,CAAC;IACxB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAuCD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,oBAAoB,GAC3B,gBAAgB,CAuBlB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,SAAS,CAAC,EAAE,YAAY,GACvB,gBAAgB,CA4ClB"}
+{"version":3,"file":"describe-error.d.ts","sourceRoot":"","sources":["../src/describe-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAC;AAS1B;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,KAAK,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,EAAE,YAAY,CAAC;IACxB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAiDD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,oBAAoB,GAC3B,gBAAgB,CA4DlB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,SAAS,CAAC,EAAE,YAAY,GACvB,gBAAgB,CA8FlB"}