footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/attempt/types.js

@@ -0,0 +1,16 @@
+/**
+ * attempt/types.ts — the attempt vocabulary: ONE record shape for every try the library runs.
+ *
+ * A retry is a loop, and every pass of it is an `AttemptRecord`: when it started, how long it took, how it
+ * ended, its failure category, and the retry-or-stop decision that followed it — a `DecisionEvidence`, the
+ * shape `decide()` produces, so a reader walks a retry exactly as it walks a decider (design
+ * docs/design/2026-10-time-and-failure-evidence.md, §3.1, §3.8, §4).
+ *
+ * WHERE it lives: on the execution tree (`StageSnapshot.attempts` / `attemptSummary`), on the `onAttempt`
+ * hook, and in recorders' stores — never on the commit bundle, so every log stays byte-identical (Q1).
+ *
+ * A LEAF (L0, scripts/layering.config.cjs): the frame's snapshot type (`memory/frameTypes.ts`, L4) names
+ * `AttemptRecord`, so this file imports only other leaves' types.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/attempt/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG","sourcesContent":["/**\n * attempt/types.ts — the attempt vocabulary: ONE record shape for every try the library runs.\n *\n * A retry is a loop, and every pass of it is an `AttemptRecord`: when it started, how long it took, how it\n * ended, its failure category, and the retry-or-stop decision that followed it — a `DecisionEvidence`, the\n * shape `decide()` produces, so a reader walks a retry exactly as it walks a decider (design\n * docs/design/2026-10-time-and-failure-evidence.md, §3.1, §3.8, §4).\n *\n * WHERE it lives: on the execution tree (`StageSnapshot.attempts` / `attemptSummary`), on the `onAttempt`\n * hook, and in recorders' stores — never on the commit bundle, so every log stays byte-identical (Q1).\n *\n * A LEAF (L0, scripts/layering.config.cjs): the frame's snapshot type (`memory/frameTypes.ts`, L4) names\n * `AttemptRecord`, so this file imports only other leaves' types.\n */\n\nimport type { DecisionEvidence } from '../decide/types.js';\nimport type { StructuredErrorInfo } from '../errors/errorInfo.js';\nimport type { RetryLoopCall } from './retryLoopTypes.js';\n\n/**\n * Declarative per-stage retry policy — the policy the attempt runner runs (`AttemptPolicy` in the design is\n * this one type, under this one name).\n *\n * WHY this exists: a retry hand-rolled inside a stage function is invisible to\n * the trace. The stage shows one execution, the commit log shows one bundle,\n * and the two failed calls that preceded the successful one left no mark\n * anywhere — an unexplained behaviour in a library whose whole thesis is that\n * nothing invisible happens. Declared here instead, every attempt is part of\n * the record: each attempt fires `FlowRecorder.onAttempt` with its\n * {@link AttemptRecord}, each failed attempt that is retried also fires\n * `FlowRecorder.onStageRetry`, and the stage's execution-tree node carries\n * `attempts` and `attemptSummary`.\n *\n * A POLICY, not a stage kind — `retry` sits on a normal stage the way\n * `isPausable` / `isStreaming` do. The serialized node `type` is unchanged and\n * every existing consumer keeps rendering the stage exactly as before.\n *\n * @example\n * ```ts\n * flowChart<State>('Fetch user', fetchFn, 'fetch-user')\n *   .retry({ attempts: 3, backoffMs: (n) => 100 * 2 ** (n - 1) })\n * ```\n */\nexport interface RetryPolicy {\n  /**\n   * How many times the stage function may run in total, INCLUDING the first\n   * run. Must be an integer >= 1; `1` means \"no retry\" (a declared no-op,\n   * accepted so a policy can be switched off without deleting it — such a\n   * stage runs once and records no attempts).\n   */\n  attempts: number;\n  /**\n   * How long to wait before the NEXT attempt. Either a fixed number of\n   * milliseconds, or a function of the attempt that just FAILED (1-based) and\n   * its error, returning milliseconds — `(n) => 100 * 2 ** (n - 1)` is\n   * exponential backoff; `(n, error) => statedWaitMs(error) ?? 100 * n` honours\n   * a wait the outside system stated (a `Retry-After`) without the engine\n   * parsing anything. A one-argument function is unchanged. Omitted (or a\n   * non-finite / negative result, or a throw) means no wait.\n   *\n   * The wait is a plain awaited timer that is CANCELLED by the run's\n   * `AbortSignal`. It is not a pause: a chart cannot be checkpointed in the\n   * middle of a backoff. Under a run deadline, a wait that would outlast it is\n   * never started: the series stops `no-time-left`.\n   */\n  backoffMs?: number | ((attempt: number, error: unknown) => number);\n  /**\n   * The most one wait may last, in milliseconds — a finite number >= 0. The\n   * runner ENFORCES it: every wait is `min(backoffMs's answer, maxBackoffMs)`,\n   * whatever the error stated, so the declaration cannot lie.\n   *\n   * It is what makes a FUNCTION backoff countable before the run. A function\n   * may read the error (a stated `Retry-After`), and no error exists at build,\n   * so the static budget check never asks it: with `maxBackoffMs` it counts\n   * each wait at the ceiling; without, the stage is unbounded (`'backoff'`).\n   *\n   * @example\n   * ```ts\n   * .retry({ attempts: 4, timeoutMs: 10_000, backoffMs: (n, error) => statedWaitMs(error) ?? 500 * n, maxBackoffMs: 5_000 })\n   * ```\n   */\n  maxBackoffMs?: number;\n  /**\n   * The cap on ONE attempt, in milliseconds — a finite number > 0. The attempt\n   * runs under `min(timeoutMs, time left before the run's deadline)`; when the\n   * cap runs out, the attempt's signal (`scope.$attempt().signal`) aborts with\n   * an `AttemptTimeoutError`, the engine stops waiting for it, and the attempt\n   * is recorded `timeout` (then retried like any failure, if the policy allows).\n   *\n   * What the engine stops is the WAITING. The function's own work stops only if\n   * it passes the signal on (`fetch(url, { signal: scope.$attempt().signal })`);\n   * whatever it writes after its attempt ended is dropped and recorded on the\n   * stage (`StageSnapshot.lateWrites`).\n   *\n   * Declared with `attempts: 1`, it is a timeout with no retry — the stage\n   * still records its one attempt.\n   */\n  timeoutMs?: number;\n  /**\n   * Is THIS error worth another attempt? Defaults to retrying every error.\n   * Returning `false` ends the stage immediately on the normal error path, with\n   * no retry event; the attempt's record says why it stopped (`reason:\n   * 'declined'`).\n   *\n   * A throw from this predicate is treated as `false` — a broken predicate\n   * must not turn a failing stage into an infinite retry loop. The record\n   * tells the two apart: a throw stops the series `declined` with\n   * `retryOnThrew: true`.\n   */\n  retryOn?: (error: unknown) => boolean;\n}\n\n/**\n * Who ran the attempt: the engine, for a stage's own policy (`'stage'`); the attempt runner, for a call a stage made\n * through `scope.$call` or for the standalone `attempt()` (`'call'`); an outside system on its own — an SDK's\n * internal retry — reported through `AttemptContext.observed` (`'observed'`, P2).\n */\nexport type AttemptKind = 'stage' | 'call' | 'observed';\n\n/**\n * How one attempt ended. `'timeout'` is the attempt's OWN timer (never the outside system failing — law 4);\n * `'paused'` is a pause (control flow, never retried). `'aborted'` is the run's signal ending the attempt: the\n * attempt threw the abort's own reason. An attempt that threw its own error is `'failed'`, with its category,\n * even when the run aborted around it — the abort is then the series' stop reason (`reason: 'aborted'`), never a\n * rewrite of what the attempt did.\n */\nexport type AttemptOutcome = 'ok' | 'failed' | 'timeout' | 'aborted' | 'paused';\n\n/**\n * The failure category of an attempt that did not succeed — ONE fixed set of seven, classified by\n * `errorCategory` (`attempt/category.ts`), so every recorder breaks failures down the same way (§3.9).\n * Evidence, never policy: the default `retryOn` retries every category.\n */\nexport type AttemptCategory = 'timeout' | 'rate-limited' | 'server' | 'network' | 'auth' | 'permanent' | 'unknown';\n\n/** What follows an attempt: another one, the value (`'done'`), or the attempt's own error (`'stop'`). */\nexport type AttemptNext = 'retry' | 'done' | 'stop';\n\n/**\n * Why the series went on or ended — the matched rule's label in `retryRules` (`attempt/decision.ts`), or the\n * default's (`'retryable'`).\n */\nexport type AttemptReason =\n  | 'succeeded'\n  | 'paused'\n  | 'aborted'\n  | 'exhausted'\n  | 'declined'\n  | 'no-time-left'\n  | 'retryable';\n\n/**\n * What an attempt did to the outside system a touching target names (design §3.3, P3) — present only on the records\n * of a target that declared `touches`:\n *   - `'applied'` — the attempt answered (`ok`);\n *   - `'none'` — it failed, and its error itself declares `effect: 'none'` (the adapter's word: nothing was sent);\n *   - `'unknown'` — anything else: a timeout, a cancellation, a pause, or a failure the adapter did not declare\n *     harmless. Nobody knows whether the effect happened, so the series never reports it as failed or ok: a last\n *     attempt of unknown effect fails with `UnknownEffectError` — reconcile, do not retry blindly.\n */\nexport type AttemptEffect = 'applied' | 'none' | 'unknown';\n\n/** What a stage's idempotency-key rule is handed — once per EXECUTION, before attempt 1 (`StageTouches`). */\nexport interface IdempotencyKeyContext {\n  /**\n   * The run's (or the subflow's) input, frozen. On the root of a resumed leg the run's input is gone (it does not\n   * cross a resume), so reading it there THROWS rather than hand the rule nothing — the stage fails before anything\n   * is sent. A paused stage itself resumes under the key its checkpoint carries; the rule is not asked again.\n   */\n  readonly args: unknown;\n  /** This run's id. Regenerated per run and per resume — never a key on its own (see `StageTouches`). */\n  readonly runId: string;\n  /** The execution the key is for (`charge#4`). */\n  readonly runtimeStageId: string;\n  /**\n   * A committed state value, read without tracking — the key is not a write. Use it for a key the chart keeps in\n   * state; it survives a resume, where `args` does not (reading `args` on a resumed leg's root throws). A selected\n   * value read here makes the recorded key the redaction placeholder. Read-only: a frozen copy, never the committed\n   * value itself.\n   */\n  getState(key: string): unknown;\n}\n\n/**\n * A stage that changes something outside the run — a charge, an email, a write to another service (design §3.3,\n * P3). Declared with `.touches(system, { idempotencyKey })` or a `touches` option; a POLICY-like field on the node,\n * like `retry` and `tags`. The built spec carries `system` only.\n *\n * `system` is a NAME from code (`'stripe'`) — never a value. `idempotencyKey` is the RULE that makes the key, run\n * ONCE per execution (not per attempt) and handed to every attempt as `scope.$attempt().idempotencyKey`. It must\n * name the OPERATION, so that every retry — and a resume's re-run, and a caller's whole-run retry — sends the same\n * key: derive it from the input (`order-${args.orderId}`) or from state (`getState('orderId')`), never from `runId`\n * alone (it changes on a resume) and never from what a model wrote. The builder refuses a touching stage that may retry with no rule, and the engine refuses an\n * `interrupt()` in a keyless touching stage (a resume re-runs it). Under a redaction rule, a key derived from an\n * input that holds a selected value is served as the placeholder (records, hook, `UnknownEffectError`) — the\n * caller recomputes it from the input it gave to reconcile.\n */\nexport interface StageTouches {\n  /** The outside system — a name, 1–128 characters, no control, format or line-separator character. */\n  readonly system: string;\n  /**\n   * The key rule — a function, so the key belongs to the execution (a constant would make every run one operation).\n   * Its answer must be 1–255 printable ASCII characters with no space (it travels in a request header); anything\n   * else fails the stage with a `TypeError` that never echoes it.\n   */\n  readonly idempotencyKey?: (context: IdempotencyKeyContext) => string;\n}\n\n/**\n * What `scope.$call(target, fn, policy, options)` declares beyond its policy (P3): the outside system the call\n * touches, and the key it is made under. A call that touches a system and may retry must carry a key; the key is a\n * VALUE the stage computed from its input or its state — never from model output — and is checked like a stage's.\n */\nexport interface CallOptions {\n  /** The outside system the call changes — a name like `target`. */\n  readonly touches?: string;\n  /**\n   * The key every attempt of the call is made under — only with `touches`. When the stage can `interrupt()`, derive it\n   * from state or from `scope.$attempt().idempotencyKey`, never from `$getArgs()`: the input does not cross a resume,\n   * so an args-derived key would differ on the re-run.\n   */\n  readonly idempotencyKey?: string;\n}\n\n/**\n * An attempt's error as the run SERVES it — `StructuredErrorInfo` under the run's redaction rule\n * (`RedactionRule.retainStageError`), without `raw`: a record must survive `structuredClone` and must never\n * hand out the thrown value itself.\n */\nexport type AttemptError = Omit<StructuredErrorInfo, 'raw'>;\n\n/**\n * What a retry-or-stop decision reads — the inputs `retryRules` evaluates, first match wins (§3.1). The runner\n * computes each one only when a rule reaches it, so `retryOn` and `backoffMs` run exactly when a retry needs\n * them.\n *\n * `category` and `keyPresent` are inputs no default rule reads; a chart's own rules over the same inputs may.\n * `timeLeftMs` is `Infinity` without a deadline, and so is `timeLeftAfterWaitMs` (= `timeLeftMs − delayMs`):\n * the no-time-left rule compares one input with a constant, as every `decide()` filter does.\n */\nexport interface AttemptInputs {\n  readonly outcome: AttemptOutcome;\n  readonly category?: AttemptCategory;\n  /**\n   * The run's signal has aborted — read when rule 3 is reached, so an abort raised inside `retryOn` is seen by\n   * the decision taken again after it. Always `true` for an `'aborted'` outcome.\n   */\n  readonly aborted: boolean;\n  /** This attempt, 1-based. */\n  readonly attempt: number;\n  /** The attempts the policy allows in total. */\n  readonly of: number;\n  readonly timeLeftMs: number;\n  /** The wait before the next attempt, from `backoffMs` (`0` when it is absent, invalid or throws). */\n  readonly delayMs: number;\n  readonly timeLeftAfterWaitMs: number;\n  /**\n   * The policy's `retryOn` verdict on this attempt's error (`true` when absent; a throw is `false`, and the\n   * record says it threw: `AttemptRecord.retryOnThrew`).\n   */\n  readonly retryOn: boolean;\n  /** Whether the target declared an idempotency key — never its value. */\n  readonly keyPresent: boolean;\n}\n\n/**\n * One attempt — the unit of time and failure evidence. Frozen; survives `structuredClone`.\n *\n * Identity: `series` (the stage execution's `runtimeStageId` for a stage attempt) plus `attempt`.\n */\nexport interface AttemptRecord {\n  /** Logical workflow/pass link, stamped by an explicit retry helper; physical series/attempt stay unchanged. */\n  readonly retryLoop?: RetryLoopCall;\n  /**\n   * The series the attempt belongs to. A stage attempt: its execution's `runtimeStageId`. A call — `$call`, or an\n   * observed SDK call — made during stage attempt `n`: `<runtimeStageId>@<n>.<k>`, the `k`-th call of that attempt,\n   * so `<series>@<attempt>` is the attempt id of foottrace's grammar (design §3.4). A standalone `attempt()`: the\n   * caller's name for the operation.\n   */\n  readonly series: string;\n  readonly kind: AttemptKind;\n  /**\n   * The outside target of a `'call'` or `'observed'` attempt — a NAME from code (`'stripe.quotes.create'`), never\n   * a value. Absent on a stage attempt: its stage names it.\n   */\n  readonly target?: string;\n  /** Who ran an `'observed'` attempt — the report's `source` (`'sdk'` unless it said otherwise). Absent otherwise. */\n  readonly source?: string;\n  /** 1-based within the series. */\n  readonly attempt: number;\n  /** The attempts the policy allows in total. */\n  readonly of?: number;\n  /** Epoch milliseconds when the attempt started. */\n  readonly startedAt: number;\n  readonly durationMs: number;\n  /** How the attempt itself ended — never rewritten by what the series did next (see {@link AttemptOutcome}). */\n  readonly outcome: AttemptOutcome;\n  /**\n   * Present when the attempt failed, timed out or was aborted; absent for `'ok'` and `'paused'`. Read off the\n   * error as it stood when the decision was made (after `retryOn` ran), like `error`.\n   */\n  readonly category?: AttemptCategory;\n  /** The retry-or-stop decision — the evidence `decide()` would record for `retryRules(policy)`. */\n  readonly decision: DecisionEvidence;\n  /** `decision.chosen` — the compact projection a badge reads. */\n  readonly next: AttemptNext;\n  readonly reason: AttemptReason;\n  /**\n   * `true` when the policy's `retryOn` THREW on this attempt's error (absent otherwise). A throw is \"do not\n   * retry\", so the reason is `'declined'`; this flag keeps a broken predicate apart from a real `false`.\n   */\n  readonly retryOnThrew?: true;\n  /**\n   * The wait before the next attempt — present when the decision computed it: a retry, or (under a deadline) a\n   * `no-time-left` stop, whose wait would have outlasted the time left.\n   */\n  readonly delayMs?: number;\n  /**\n   * The cap this attempt ran under, in milliseconds — `min(RetryPolicy.timeoutMs, time left before the deadline)`\n   * at its start. Absent when neither was set (the attempt ran uncapped).\n   */\n  readonly timeoutMs?: number;\n  /** The time left before the run's deadline when the decision was made (negative once past). Absent without one. */\n  readonly timeLeftMs?: number;\n  /** The served error of an attempt that failed, timed out or was aborted. */\n  readonly error?: AttemptError;\n  /** The outside system a touching target names (P3). Absent for a target that touches nothing. */\n  readonly system?: string;\n  /**\n   * The key the attempt was made under, as the run SERVES it — retained under the diagnostic rule as\n   * `{ idempotencyKey }`, so a redaction rule of that name (or `policy.diagnostics`) scrubs it. Absent without a key.\n   */\n  readonly idempotencyKey?: string;\n  /** What the attempt did to the outside system (see {@link AttemptEffect}). Present only on a touching target. */\n  readonly effect?: AttemptEffect;\n}\n\n/**\n * The attempt a function is running in — a stage's (`scope.$attempt()`, design §3.1), or a call's (the argument\n * `scope.$call` and `attempt()` hand their function, P2). Never serialised: it holds a live signal.\n *\n * A stage with no retry policy and no deadline is attempt 1 of 1, with the run's signal (or one that never\n * aborts) and `Infinity` left.\n */\nexport interface AttemptContext {\n  /** The series its record names (see {@link AttemptRecord.series}). */\n  readonly series: string;\n  /** This attempt, 1-based. */\n  readonly attempt: number;\n  /** The attempts the policy allows in total. */\n  readonly of: number;\n  /**\n   * Aborts when this attempt must stop: at its cap (`AttemptTimeoutError`), at the run's deadline, or when the run\n   * is cancelled. Pass it to `fetch` and SDK calls — the engine stops waiting at the cap either way, but only the\n   * function can stop its own work.\n   */\n  readonly signal: AbortSignal;\n  /** The run's deadline, epoch milliseconds — absent without one. */\n  readonly deadline?: number;\n  /** The cap this attempt runs under (see {@link AttemptRecord.timeoutMs}) — absent when uncapped. */\n  readonly timeoutMs?: number;\n  /** The outside system this attempt touches (P3) — absent when it touches none. */\n  readonly system?: string;\n  /**\n   * The key this attempt must be made under — the REAL key, computed once per execution from the declared rule (or\n   * the `$call`'s option). Pass it to the system (`{ idempotencyKey }`), so a retry, a resume and a caller's retry\n   * all name one operation. Absent without a key. Records carry its served form.\n   */\n  readonly idempotencyKey?: string;\n  /**\n   * Milliseconds before the run's deadline — `Infinity` without one. Read through the scope, it marks the stage's\n   * commit `untrackedSources: ['env']` when a deadline exists: time is an input the record cannot replay.\n   */\n  timeLeftMs(): number;\n  /**\n   * Report an attempt an outside system ran ON ITS OWN — an SDK's internal retry (design §3.6, P2). It becomes an\n   * `AttemptRecord` of kind `'observed'` beside this attempt's evidence, and fires `onAttempt`; it never changes\n   * control flow — in either direction: a report that comes after this attempt ended (an SDK's callback firing\n   * late) is dropped and recorded by name (`lateWrites`), never thrown. Only the report's named fields are read; its\n   * error is served under the run's redaction rule, and no hook is handed the error object itself. A malformed\n   * report is the adapter's bug: a `TypeError` naming the field. Prefer one loop: turn the SDK's own retries off and\n   * run the call under `scope.$call`.\n   */\n  observed(report: ObservedAttempt): void;\n}\n\n/**\n * An attempt an outside system ran on its own, as an adapter reports it (`AttemptContext.observed`). Only these\n * fields are read — each once; anything else on the object is dropped.\n *\n * A report with `of` stands for one attempt of the SDK's series; a report without one stands for the SDK's WHOLE\n * call, its count unknown — \"the SDK ran this\" rather than a pretended count.\n */\nexport interface ObservedAttempt {\n  /** The outside target — a name from code: 1–128 characters, no control, format or line-separator character. */\n  readonly target: string;\n  /** Which attempt of the SDK's own series, 1-based. Default `1`. */\n  readonly attempt?: number;\n  /** The attempts the SDK allows in total, when it says (≥ `attempt`). */\n  readonly of?: number;\n  /** How the SDK's attempt ended. An SDK cannot pause a flowchart, so `'paused'` is refused. */\n  readonly outcome: Exclude<AttemptOutcome, 'paused'>;\n  /** How long it took, milliseconds — finite and ≥ 0. */\n  readonly durationMs: number;\n  /** When it started, epoch milliseconds. Default: the report's arrival minus `durationMs`. */\n  readonly startedAt?: number;\n  /** Who ran it — a name like `target`. Default `'sdk'`. */\n  readonly source?: string;\n  /** The error of an attempt that did not succeed — served under the run's redaction rule, never kept as thrown. */\n  readonly error?: unknown;\n}\n\n/**\n * A write, emit, diagnostic, detach or call an attempt tried AFTER it had ended — timed out, aborted or failed —\n * dropped at the scope and recorded on its stage (`StageSnapshot.lateWrites`, the first 100 —\n * `StageContext · MAX_LATE_WRITES`). A name, never the value.\n */\nexport interface LateWrite {\n  /** The attempt that wrote late, 1-based. */\n  readonly attempt: number;\n  /**\n   * The state key (a dotted path for a nested write), the emitted event's name (a diagnostic's emit name —\n   * `log.debug.<key>`, `metric.<name>` — for `$debug` / `$metric` / …), `detach:<child root id>`, or — on the\n   * `'attempt'` channel (P2) — `call:<target>` (a `$call` started, or a call's record arriving, after its attempt\n   * ended) or `observed:<target>` (an observed report after it).\n   */\n  readonly key: string;\n  readonly channel: 'state' | 'emit' | 'detach' | 'attempt';\n}\n\n/**\n * A series at a glance — stamped once, when the series ends (the Lens badge, §3.10). `last` is how it ended:\n * the last record's `next` / `reason` (and `category`, `retryOnThrew`), or `stop` / `aborted` when the run's\n * signal cut a wait (no attempt followed, so none is recorded).\n *\n * The SERIES' outcome, not the STAGE's. `last.next: 'done'` says the stage function returned; the stage can\n * still fail after that — its commit can fail (a value nothing can clone), and a StageNode it returned can be\n * refused at the run-time door (R5) — and then its `onError` fires with this summary unchanged. Whether the\n * stage failed is the execution's own fact (its error), never read off this summary.\n */\nexport interface AttemptSummary {\n  readonly count: number;\n  readonly ok: number;\n  readonly failed: number;\n  readonly timeout: number;\n  readonly aborted: number;\n  readonly paused: number;\n  readonly last: {\n    readonly next: Exclude<AttemptNext, 'retry'>;\n    readonly reason: AttemptReason;\n    readonly category?: AttemptCategory;\n    readonly retryOnThrew?: true;\n    /** The series' effect — `unknown` once any attempt left it unknown, unless the series ended with an answer. Touching targets only. */\n    readonly effect?: AttemptEffect;\n  };\n}\n\n/**\n * The run's correlation — which outside trace and unit of work this run belongs to (design §3.4). Resolved ONCE\n * per leg (`run()`, and each `resume()`) from the env by `attempt/correlation.ts · resolveCorrelation`, frozen, and\n * handed by reference to `RuntimeSnapshot.correlation`, every flow event's `TraversalContext.correlation`, and\n * every scope and emit event's `correlation`. Absent — no key anywhere — when the env gives none.\n *\n * Correlation only: a NAME the record carries so a run can be found from a trace. Never identity, never\n * authorisation — a `traceparent` comes from whoever sent the request.\n */\nexport interface RunCorrelation {\n  /** `env.traceId`, else the trace id of `env.traceparent` (32 lowercase hex). */\n  readonly traceId: string;\n  /** `env.operationId`, else the header's parent-id (only while the trace is the header's): the caller's unit of work. */\n  readonly operationId?: string;\n  /** The header's sampled flag (bit 0 of trace-flags) — present only while the trace is the header's. A hint. */\n  readonly sampled?: boolean;\n  /**\n   * The canonical header of the EFFECTIVE ids (`formatTraceparent`) — for propagating the trace onward. Present\n   * only while the trace is the header's and the operation is a W3C parent-id; never the received bytes.\n   */\n  readonly traceparent?: string;\n}\n"]}

package/dist/esm/lib/budget/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * budget/ — the static time budget: the slowest a built chart can take, from its declared retry policies, and every
+ * stage that makes a path unbounded (design docs/design/2026-10-time-and-failure-evidence.md §3.2, packet P5).
+ *
+ * Public: `timeBudget` and its report types. `budgetRefusal` / `budgetWarning` are the builder's words for
+ * `build()`; `warnDeadlineUnderBudget` is the executor's run-start warning.
+ */
+export type { BudgetAssumptions, BudgetStep, TimeBudgetOptions, TimeBudgetReport, UnboundedReason, UnboundedStage, } from './timeBudget.js';
+export { budgetRefusal, budgetWarning, declaredBudget, timeBudget, warnDeadlineUnderBudget } from './timeBudget.js';

package/dist/esm/lib/budget/index.js

@@ -0,0 +1,9 @@
+/**
+ * budget/ — the static time budget: the slowest a built chart can take, from its declared retry policies, and every
+ * stage that makes a path unbounded (design docs/design/2026-10-time-and-failure-evidence.md §3.2, packet P5).
+ *
+ * Public: `timeBudget` and its report types. `budgetRefusal` / `budgetWarning` are the builder's words for
+ * `build()`; `warnDeadlineUnderBudget` is the executor's run-start warning.
+ */
+export { budgetRefusal, budgetWarning, declaredBudget, timeBudget, warnDeadlineUnderBudget } from './timeBudget.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2J1ZGdldC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFVSCxPQUFPLEVBQUUsYUFBYSxFQUFFLGFBQWEsRUFBRSxjQUFjLEVBQUUsVUFBVSxFQUFFLHVCQUF1QixFQUFFLE1BQU0saUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGJ1ZGdldC8g4oCUIHRoZSBzdGF0aWMgdGltZSBidWRnZXQ6IHRoZSBzbG93ZXN0IGEgYnVpbHQgY2hhcnQgY2FuIHRha2UsIGZyb20gaXRzIGRlY2xhcmVkIHJldHJ5IHBvbGljaWVzLCBhbmQgZXZlcnlcbiAqIHN0YWdlIHRoYXQgbWFrZXMgYSBwYXRoIHVuYm91bmRlZCAoZGVzaWduIGRvY3MvZGVzaWduLzIwMjYtMTAtdGltZS1hbmQtZmFpbHVyZS1ldmlkZW5jZS5tZCDCpzMuMiwgcGFja2V0IFA1KS5cbiAqXG4gKiBQdWJsaWM6IGB0aW1lQnVkZ2V0YCBhbmQgaXRzIHJlcG9ydCB0eXBlcy4gYGJ1ZGdldFJlZnVzYWxgIC8gYGJ1ZGdldFdhcm5pbmdgIGFyZSB0aGUgYnVpbGRlcidzIHdvcmRzIGZvclxuICogYGJ1aWxkKClgOyBgd2FybkRlYWRsaW5lVW5kZXJCdWRnZXRgIGlzIHRoZSBleGVjdXRvcidzIHJ1bi1zdGFydCB3YXJuaW5nLlxuICovXG5cbmV4cG9ydCB0eXBlIHtcbiAgQnVkZ2V0QXNzdW1wdGlvbnMsXG4gIEJ1ZGdldFN0ZXAsXG4gIFRpbWVCdWRnZXRPcHRpb25zLFxuICBUaW1lQnVkZ2V0UmVwb3J0LFxuICBVbmJvdW5kZWRSZWFzb24sXG4gIFVuYm91bmRlZFN0YWdlLFxufSBmcm9tICcuL3RpbWVCdWRnZXQuanMnO1xuZXhwb3J0IHsgYnVkZ2V0UmVmdXNhbCwgYnVkZ2V0V2FybmluZywgZGVjbGFyZWRCdWRnZXQsIHRpbWVCdWRnZXQsIHdhcm5EZWFkbGluZVVuZGVyQnVkZ2V0IH0gZnJvbSAnLi90aW1lQnVkZ2V0LmpzJztcbiJdfQ==

package/dist/esm/lib/budget/timeBudget.d.ts

@@ -0,0 +1,136 @@
+/**
+ * budget/timeBudget.ts — `timeBudget(chart)`: the slowest a chart can take, from what it declares (design
+ * docs/design/2026-10-time-and-failure-evidence.md §3.2, packet P5).
+ *
+ * WHY: a retry policy is a promise about time. `{ attempts: 4, timeoutMs: 40_000, backoffMs: 1_000 }` allows
+ * 4 × 40 000 + 3 × 1 000 = 163 000 ms, and a caller who gave the chart 120 s is not served by it — which is
+ * knowable before a single stage runs. `.budget(ms)` declares the caller's contract on the chart; `build()` refuses
+ * a chart whose declared policies already allow longer (owner ruling Q2) and warns, by name, about every stage it
+ * cannot bound. An unbounded stage is never guessed around: it is counted as 0 and named.
+ *
+ * THE RULES (one walk of the built StageNode graph; each chain of `next` pointers is computed once per start):
+ *   - a stage with a function: `attempts × timeoutMs` plus the waits between its attempts, as the runner waits them
+ *     (`attempt/policy.ts`). A number `backoffMs` is arithmetic, under `maxBackoffMs` when declared. A FUNCTION is
+ *     never asked: it may read the error (a stated `Retry-After`) and no error exists here, so asking it with none
+ *     could UNDERESTIMATE. It counts at its declared ceiling, `maxBackoffMs` per wait (the runner enforces it); with
+ *     no ceiling the stage is unbounded `'backoff'`. No `timeoutMs` → unbounded `'no-timeout'`;
+ *   - a sequence: the sum. A decider, a selector, a fork: the node's own stage plus its slowest child (a fork's
+ *     children, and a selector's picks, run at once);
+ *   - a mounted subflow: its chart, walked the same way, under the ids the run gives its stages (`pay/charge`);
+ *     a lazy one is unbounded `'lazy-subflow'` unless `assume.lazy[subflowId]` names the chart it resolves to;
+ *   - `parallelForEach`: ONE branch — the branches run at once and `maxBranches` truncates, so the item count never
+ *     adds time. The branch chart is built at run time, so it is unbounded `'items'` unless
+ *     `assume.branches[stageId]` names it (its stages are reported under the first branch, `review~0/score`);
+ *   - a loop is NEVER iterated. With no assumption it is unbounded `'loop'`, named by its target, and counted once.
+ *     `assume.loops[targetId] = n` bounds it: each time the chart reaches the loop, every stage from the target to
+ *     the loop's furthest source runs at most `n` times, each at its slowest. Nested loops multiply; two loops that
+ *     overlap without nesting are one region bounded by the product of their passes (each can re-enter the other).
+ *
+ * TWO NUMBERS. `knownMs` counts what is bounded (an unbounded stage as 0, an unassumed loop once). Without
+ * assumptions it is a time the declared policies ALLOW a run to take (`retryOn` is not read: it may only end a series
+ * sooner), so a budget below it cannot be promised — `over` and the build refusal read it, on an unbounded path too.
+ * `worstCaseMs` is `knownMs` when every path is bounded, `null` otherwise; with an assumed loop it is an upper bound
+ * under that assumption (every pass is counted at its slowest branch).
+ *
+ * THREAT MODEL. The walk terminates on any graph: a chain is walked with a visited set (a `next` that closes on
+ * itself is a loop), nesting is an explicit stack (no recursion — a 5 000-deep subflow nesting walks), a chain that
+ * reaches itself through its children or a subflow is a loop, and every chain is computed once per start however
+ * often it is mounted. The walk is CAPPED: past `MAX_WALK` node visits it stops with a `RangeError` — a builder chart
+ * visits each node at most twice, but a hand-built graph whose chains share their tails is walked once per chain.
+ * Sums and products saturate at `Number.MAX_SAFE_INTEGER` — never `Infinity` or `NaN`. Assumptions are copied ONCE,
+ * own enumerable properties only, into fresh null-prototype records, and only that copy is read.
+ *
+ * What it does NOT count: the engine's own work between stages, a stage function that blocks the thread (a timeout
+ * stops the WAITING, see the attempt runner), and a StageNode a stage returns at run time — any stage may grow the
+ * graph that way, so the budget is of the graph the chart DECLARES.
+ */
+import type { FlowChart } from '../builder/types.js';
+/**
+ * Why a stage keeps a path unbounded: no per-attempt cap (`'no-timeout'`); a function backoff with no declared
+ * `maxBackoffMs` (`'backoff'` — its waits may depend on an error that does not exist at build); a loop with no
+ * assumed passes (`'loop'`, named by its target); a lazy subflow whose chart is unknown at build (`'lazy-subflow'`);
+ * a `parallelForEach` whose branch chart is built at run time (`'items'`).
+ */
+export type UnboundedReason = 'no-timeout' | 'backoff' | 'loop' | 'lazy-subflow' | 'items';
+/** A stage on the slowest path, with what it declares and how many times the path runs it. */
+export interface BudgetStep {
+    /** The stage id as the run names it — a subflow's stages under their mount (`pay/charge`). */
+    readonly stageId: string;
+    /** How many attempts its policy allows (1 without one). */
+    readonly attempts: number;
+    /** The cap on one attempt; absent when the stage declares none (then `worstMs` is `null`). */
+    readonly timeoutMs?: number;
+    /** The waits between its attempts, in total. */
+    readonly backoffMs: number;
+    /** `attempts × timeoutMs + backoffMs` — `null` when the stage is unbounded. */
+    readonly worstMs: number | null;
+    /** How many times the path runs it — more than 1 only inside an assumed loop. */
+    readonly passes: number;
+}
+/** A stage the check cannot bound, and why. */
+export interface UnboundedStage {
+    readonly stageId: string;
+    readonly why: UnboundedReason;
+}
+/** What the caller knows that the chart does not declare. Keys are ids as the run names them. */
+export interface BudgetAssumptions {
+    /** A loop's TARGET id (what `loopTo` names) → the most passes through it each time the chart reaches it (≥ 1). */
+    readonly loops?: Readonly<Record<string, number>>;
+    /** A lazy mount's subflow id → the chart it resolves to. */
+    readonly lazy?: Readonly<Record<string, FlowChart>>;
+    /** A `parallelForEach` stage id → the chart one branch runs. */
+    readonly branches?: Readonly<Record<string, FlowChart>>;
+}
+export interface TimeBudgetOptions {
+    /** The budget to check against. Defaults to the chart's declared `.budget(ms)`. A finite number > 0. */
+    readonly budgetMs?: number;
+    readonly assume?: BudgetAssumptions;
+}
+/** What `timeBudget(chart)` reports. JSON-safe and frozen. */
+export interface TimeBudgetReport {
+    /** The worst case of the slowest path — `null` when any path is unbounded (see `unbounded`). */
+    readonly worstCaseMs: number | null;
+    /** The worst case of what IS bounded: an unbounded stage counts 0, an unassumed loop one pass. */
+    readonly knownMs: number;
+    /** The stages of the slowest path, in the order a run first reaches them — the path that makes `worstCaseMs`,
+     *  or `knownMs` when a path is unbounded. `knownMs = Σ passes × (attempts × (timeoutMs ?? 0) + backoffMs)`. */
+    readonly criticalPath: readonly BudgetStep[];
+    /** Every stage that keeps a path unbounded, each named once, in chart order. */
+    readonly unbounded: readonly UnboundedStage[];
+    /** The budget checked against — absent when there is none. */
+    readonly budgetMs?: number;
+    /** `knownMs > budgetMs`: the declared policies allow longer than the budget. Always `false` without one. */
+    readonly over: boolean;
+}
+/**
+ * The most node visits one walk makes. A builder chart visits each node at most twice, so 250 000 is far past any
+ * real chart; a hand-built graph whose chains share their tails can need more (each chain walks the shared tail),
+ * and the check stops there with a `RangeError` rather than grow without bound.
+ */
+export declare const MAX_WALK = 250000;
+/**
+ * The slowest the chart can take, computed from its declared retry policies — and every stage that makes a path
+ * unbounded, by name. See the module header for the rules.
+ *
+ * @example
+ * ```ts
+ * const report = timeBudget(chart, { budgetMs: 120_000, assume: { loops: { 'ask-again': 3 } } });
+ * report.worstCaseMs;  // number, or null when a path is unbounded
+ * report.criticalPath; // [{ stageId, attempts, timeoutMs, backoffMs, worstMs, passes }]
+ * report.unbounded;    // [{ stageId, why: 'no-timeout' | 'backoff' | 'loop' | 'lazy-subflow' | 'items' }]
+ * report.over;         // true when the declared policies allow longer than budgetMs
+ * ```
+ */
+export declare function timeBudget(chart: FlowChart, options?: TimeBudgetOptions): TimeBudgetReport;
+/** The chart's declared budget (`.budget(ms)`, the spec root's `budgetMs`), or `undefined`. */
+export declare function declaredBudget(chart: FlowChart): number | undefined;
+/** `build()`'s refusal for a declared budget the chart can already exceed, or `undefined` when it can keep it. */
+export declare function budgetRefusal(report: TimeBudgetReport): string | undefined;
+/** `build()`'s dev-mode warning for a declared budget it cannot check on every path, or `undefined`. */
+export declare function budgetWarning(report: TimeBudgetReport, chartName: string): string | undefined;
+/**
+ * The run-start warning (dev mode, once per chart): the run's deadline leaves the chart less time than its declared
+ * budget, so a run that takes the time the chart declares will be cut short. `startedAt` is read BEFORE the run's
+ * deadline is armed, so `timeoutMs` equal to the budget never warns.
+ */
+export declare function warnDeadlineUnderBudget(chart: FlowChart, deadline: number | undefined, startedAt: number): void;