footprintjs 10.6.0 → 10.7.0

package/CLAUDE.md

@@ -18,7 +18,8 @@ Entry points: `footprintjs` (engine API), `/recorders`, `/trace` (engine recorde
 | reactive/ | TypedScope deep Proxy over the facade — four write laws + the honest boundary (what `find`/`for…of` hands back is raw and WARNED ABOUT in dev mode, not intercepted; a proxy held past its stage IS refused — `ScopeFacade` · `assertLive`); handles.ts = the registry of every proxy the factories built → the value behind it, asked wherever an app value enters the record (the set traps since 9.24.0 — no JSON round-trip any more; fan-out `resolveItems`, subflow in/out mappers, `$setValue`/`$update`/`$batchArray` since 9.23.3, after a fan-out over object items seeded the handle and lost every child); see src/lib/reactive/README.md |
 | decide/ | decide()/select() evidence capture |
 | filter/ | `evaluator.ts · evaluateFilter` — the ONE filter-rule law, shared by decide() and the attempt rule table; its own leaf module since P2 (10.1), because in decide/ it made attempt/ reach scope/ and `scope.$call` closed an attempt ⇄ decide ⇄ scope module cycle |
-| attempt/ | the ONE retry loop and its record (10.1, docs/design/2026-10-time-and-failure-evidence.md): `runner.ts · runAttempts` runs a policy and makes one frozen `AttemptRecord` per try (timing, outcome, category, the retry-or-stop decision as `DecisionEvidence`) + an `AttemptSummary`; `decision.ts · retryRules` = the one rule table as `decide()` rules (first match, labels ARE the reasons) + `decideAttempt`, decide()'s evaluation without a scope (filter rows from `filter/evaluator`; a property test pins equal evidence); `category.ts · errorCategory` = the one classifier (seven fixed values); `errors.ts`, `anySignal.ts`. L5 beside decide/, but `types.ts` (with `decide/types.ts`) is an L0 leaf because `StageSnapshot` (L4) names it. `RetryPolicy` is declared here, re-exported by engine/types.ts |
+| attempt/ | the ONE retry loop and its record (10.1, docs/design/2026-10-time-and-failure-evidence.md): `runner.ts · runAttempts` runs a policy and makes one frozen `AttemptRecord` per try (timing, outcome, category, the retry-or-stop decision as `DecisionEvidence`) + an `AttemptSummary`; `decision.ts · retryRules` = the one rule table as `decide()` rules (first match, labels ARE the reasons) + `decideAttempt`, decide()'s evaluation without a scope (filter rows from `filter/evaluator`; a property test pins equal evidence); `category.ts · errorCategory` = the one classifier (seven fixed values); `errors.ts`, `anySignal.ts`; `backoff.ts · exponentialBackoff` / `statedWaitFirst` build the function `RetryPolicy.backoffMs` takes (exponential ceiling, `'none'`/`'equal'`/`'full'` jitter from an injectable `random`, a stated wait first — the cap stays `maxBackoffMs`, so the budget still counts it). L5 beside decide/, but `types.ts` (with `decide/types.ts`) is an L0 leaf because `StageSnapshot` (L4) names it. `RetryPolicy` is declared here, re-exported by engine/types.ts |
+| timers/ | the ONE long-timer law, a neutral L0 leaf folder (like `ids/`): `longTimeout.ts · setLongTimeout(fn, ms, { unref? })` — `Infinity` arms no timer; a delay past 2^31 − 1 ms is waited in chunks, never 1 ms; anything not a number > 0 is due at once. Every caller-supplied wait in `src/` arms it (the runner's caps, waits and deadline, the observer queue's `drain` at L1, `flushAllDetached`, `flushRecord`, the file sink, the indexed reader, the `attempts()` recorder, capture history, the `setTimeout` detach driver). `test/architecture/timer-law.test.ts` refuses, outside it: a raw `setTimeout` / `setInterval` whose delay is not a literal a host timer holds (or a constant on its named allow-list), any indirect reach of one (alias, `globalThis['setTimeout']`, `.call`, destructuring, `Reflect.apply`), a `timers` / `timers/promises` import, `scheduler.wait`, and `AbortSignal.timeout` past 2^31 − 1 or non-literal; see src/lib/timers/README.md |
 | recorder/ | engine stores (KeyedStore/SequenceStore/BoundaryStateStore), CombinedRecorder routing, and built-in Topology/InOut/ControlDep/Quality recorders. `CommitRangeIndex` is owned and exported by foottrace. `attemptSeries.ts` = the ONE predicate every built-in recorder uses for attempt rows (P1c, 10.1: a series that RETRIED, GAVE UP or TIMED OUT; a first-time success adds no row anywhere, so no-retry runs stay byte-identical) — it lives here, not in attempt/, because a recorder → attempt runtime edge closes the attempt⇄decide⇄recorder⇄scope module cycle. Quality/Debug see `onAttempt` only through `attachCombinedRecorder` |
 | pause/ | PauseSignal / FlowchartCheckpoint types + `interrupt(scope, payload)` (throws InterruptSignal; converted to PauseSignal at the StageRunner boundary, `pausedBy:'interrupt'`) |
 | engine/ | FlowchartTraverser + handlers/; narrative/ = the whole FlowRecorder channel (dispatcher + 9 strategies), not just text; `lib/ids/branchSegment.ts` (moved to the `ids/` leaf in 9.37.0) = the ONE owner of the generated-segment grammar (`<stageId>~<index>`, marker `~` RESERVED); `executeStage` (:720) = the ONE funnel every stage fn passes through — and therefore the ONE owner of the declarative `retry` loop; `handlers/ResumeEntry.ts` = the ONE owner of a resume's ONE-SHOT re-entry (M2, 9.28.0: start + one hop per subflow on the pause path, each level's dispatcher continuation read from the chart, waiting sibling pauses queued at their fan-out) |

package/dist/esm/index.d.ts

@@ -75,9 +75,19 @@ export type { AttemptOutcomeCounts, AttemptRef } from './lib/recorder/attemptSer
  *
  * `attempt()` — the attempt runner for code that is not a stage (records go to its `onAttempt`); `errorCategory`
  * — the one failure classifier (seven fixed categories); `retryRules` — the one retry rule table, as `decide()`
- * rules; the attempt contract's two errors.
+ * rules; the attempt contract's two errors; `exponentialBackoff` / `statedWaitFirst` — deterministic builders of
+ * the function a `RetryPolicy.backoffMs` takes (`BackoffSpec.maxDelayMs` caps the schedule before the jitter draw; the
+ * policy's `maxBackoffMs` still caps every wait after it).
  */
-export { attempt, AttemptTimeoutError, errorCategory, retryRules, UnknownEffectError } from './lib/attempt/index.js';
+export { attempt, AttemptTimeoutError, errorCategory, exponentialBackoff, retryRules, statedWaitFirst, UnknownEffectError, } from './lib/attempt/index.js';
+/**
+ * @category Attempts
+ *
+ * What the backoff builders take and build: an exponential schedule (`BackoffSpec`, its `BackoffJitter`), the
+ * `RetryPolicy.backoffMs` function they return (`BackoffFunction`), and the reader of a stated wait
+ * (`StatedWaitReader` — a parsed `Retry-After`, in milliseconds).
+ */
+export type { BackoffFunction, BackoffJitter, BackoffSpec, StatedWaitReader } from './lib/attempt/index.js';
 /**
  * @category Correlation
  *

package/dist/esm/index.js

@@ -27,9 +27,11 @@ export { decide, select } from './lib/decide/index.js';
  *
  * `attempt()` — the attempt runner for code that is not a stage (records go to its `onAttempt`); `errorCategory`
  * — the one failure classifier (seven fixed categories); `retryRules` — the one retry rule table, as `decide()`
- * rules; the attempt contract's two errors.
+ * rules; the attempt contract's two errors; `exponentialBackoff` / `statedWaitFirst` — deterministic builders of
+ * the function a `RetryPolicy.backoffMs` takes (`BackoffSpec.maxDelayMs` caps the schedule before the jitter draw; the
+ * policy's `maxBackoffMs` still caps every wait after it).
  */
-export { attempt, AttemptTimeoutError, errorCategory, retryRules, UnknownEffectError } from './lib/attempt/index.js';
+export { attempt, AttemptTimeoutError, errorCategory, exponentialBackoff, retryRules, statedWaitFirst, UnknownEffectError, } from './lib/attempt/index.js';
 export { formatTraceparent, parseTraceparent, TraceparentError } from './lib/attempt/index.js';
 /** @category Run */
 export { RecordSinkError } from './lib/runner/index.js';
@@ -95,4 +97,4 @@ export { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';
  */
 export { disableDevMode, enableDevMode, isDevMode } from './lib/devMode.js';
 export { stringifySnapshot } from './lib/runner/stringifySnapshot.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AASH,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAsCxF,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAQnD,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAoB3C,mCAAmC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAiDvD;;;;;;GAMG;AACH,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAWrH,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAgC/F,oBAAoB;AACpB,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAQxD,oBAAoB;AACpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,oBAAoB;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAqBnD,+BAA+B;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,+BAA+B;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,oCAAoC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAmC5D,qEAAqE;AACrE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,GACZ,MAAM,yBAAyB,CAAC;AAkDjC,+BAA+B;AAC/B,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAK9D,+BAA+B;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAEtE,+BAA+B;AAC/B,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAEvE,+BAA+B;AAC/B,OAAO,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAC;AAEzE,+BAA+B;AAC/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAEtE,+BAA+B;AAC/B,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAEpE,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAmBtE,uCAAuC;AACvC,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE7E,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AA0B5D,6BAA6B;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAgEjD,sCAAsC;AACtC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE3E,sCAAsC;AACtC,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AASrG,gCAAgC;AAChC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE1E,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AA0B5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC","sourcesContent":["/**\n * FootPrint — Public API (v3)\n *\n * The flowchart pattern for backend code.\n * Build → Run → Observe.\n *\n * **The common import paths:**\n * ```ts\n * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here\n * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories\n * import { stateAt, causalChain } from 'foottrace';     // read a finished run\n * import { RecordFrame, EventLog } from 'foottrace/write';     // write a record yourself\n * import { StageContext }                 from 'footprintjs/advanced';  // engine internals\n * ```\n *\n * @module\n */\n\n// ============================================================================\n// Quick Start — Everything you need for 90% of use cases\n// ============================================================================\n\n/** @category Quick Start */\nexport type { FlowChart, StageFunction as StageHandler, StreamHandlers } from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';\n\n/**\n * @category Quick Start\n *\n * Config for `.addParallelForEach()` — one branch per item, branch count\n * decided at run time from the payload. `maxBranches` and `into` are required\n * on purpose (see docs/design/execution-control.md).\n */\nexport type { BranchChart, ParallelForEachConfig, RetryPolicy } from './lib/builder/index.js';\n\n/** @category Quick Start — build-time observer (twin of FlowRecorder) */\nexport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureEdgeKind,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureStageTaggedEvent,\n  StructureSubflowMountedEvent,\n} from './lib/builder/index.js';\n\n/**\n * @category Time Budget\n *\n * `timeBudget(chart)` — the slowest a chart can take, from its declared retry policies (`attempts × timeoutMs` plus\n * the waits, summed along the slowest path), and every stage that makes a path unbounded, by name. `.budget(ms)`\n * declares the caller's contract; `build()` refuses a chart that cannot keep it. Also `chart.timeBudget()`.\n */\nexport type {\n  BudgetAssumptions,\n  BudgetStep,\n  TimeBudgetOptions,\n  TimeBudgetReport,\n  UnboundedReason,\n  UnboundedStage,\n} from './lib/budget/index.js';\nexport { timeBudget } from './lib/budget/index.js';\n\n/** @category Quick Start */\nexport type { TypedStageFunction } from './lib/builder/typedFlowChart.js';\n\n/** @category Quick Start */\nexport type { ScopeMethods, TypedScope } from './lib/reactive/index.js';\n\n/** @category Quick Start */\nexport { narrative } from './recorders.js';\n\n// ============================================================================\n// Decision Branching — decide() / select() with evidence capture\n// ============================================================================\n\n/** @category Decision Branching */\nexport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  DefaultBranch,\n  FilterOps,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhenClause,\n  WhereFilter,\n} from './lib/decide/index.js';\n\n/** @category Decision Branching */\nexport { decide, select } from './lib/decide/index.js';\n\n/** @category Errors */\nexport type { TerminalFailureContext } from './lib/errors/terminalFailure.js';\n\n// ============================================================================\n// Attempts — every try of a retried stage, and the decision that followed it\n// ============================================================================\n\n/**\n * @category Attempts\n *\n * One `AttemptRecord` per attempt of a stage with a declared `retry` policy, a `timeoutMs`, or a run deadline —\n * timing, outcome, failure category, and the retry-or-stop decision as `DecisionEvidence` — on the stage's\n * execution-tree node (`StageSnapshot.attempts` / `attemptSummary`) and on `FlowRecorder.onAttempt`.\n * A call a stage makes through `scope.$call` is recorded the same way (kind `'call'`), and so is an SDK's own retry\n * an adapter reports through `observed()` (`ObservedAttempt`, kind `'observed'`). `AttemptContext` is what\n * `scope.$attempt()` returns, and what a call's function gets (the attempt's signal, the time left, `observed`);\n * `LateWrite` is a write (or call) an ended attempt tried (`StageSnapshot.lateWrites`). A stage that changes an\n * outside system declares it (`StageTouches`, `.touches()`), and a call does (`CallOptions`): every attempt then\n * carries its `AttemptEffect`, and the key rule is handed an `IdempotencyKeyContext` once per execution.\n */\nexport type {\n  AttemptCategory,\n  AttemptContext,\n  AttemptEffect,\n  AttemptError,\n  AttemptInputs,\n  AttemptKind,\n  AttemptNext,\n  AttemptOptions,\n  AttemptOutcome,\n  AttemptReason,\n  AttemptRecord,\n  AttemptSummary,\n  CallOptions,\n  IdempotencyKeyContext,\n  LateWrite,\n  ObservedAttempt,\n  StageTouches,\n  UnknownEffectInit,\n} from './lib/attempt/index.js';\n/**\n * @category Attempts\n *\n * An attempt by name (`series` + `attempt`) and per-outcome counts — what recorder rows hold of attempts.\n */\nexport type { AttemptOutcomeCounts, AttemptRef } from './lib/recorder/attemptSeries.js';\n\n/**\n * @category Attempts\n *\n * `attempt()` — the attempt runner for code that is not a stage (records go to its `onAttempt`); `errorCategory`\n * — the one failure classifier (seven fixed categories); `retryRules` — the one retry rule table, as `decide()`\n * rules; the attempt contract's two errors.\n */\nexport { attempt, AttemptTimeoutError, errorCategory, retryRules, UnknownEffectError } from './lib/attempt/index.js';\n\n/**\n * @category Correlation\n *\n * The run's correlation (10.1): `env.traceparent` (W3C, parsed strictly) or `env.traceId` + `env.operationId`\n * become ONE frozen `RunCorrelation` per run — on `getSnapshot().correlation`, every flow event's\n * `traversalContext.correlation` and every scope and emit event's `correlation`. `parseTraceparent` /\n * `formatTraceparent` are the W3C codec; a refused header throws `TraceparentError` with a named `reason`.\n */\nexport type { ParsedTraceparent, RunCorrelation, TraceparentFields, TraceparentRefusal } from './lib/attempt/index.js';\nexport { formatTraceparent, parseTraceparent, TraceparentError } from './lib/attempt/index.js';\n\n// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type {\n  CaptureHistoryOptions,\n  CaptureHistoryReceipt,\n  CaptureHistoryStatus,\n  CaptureHistoryTarget,\n} from './lib/runner/index.js';\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } from './lib/runner/index.js';\n\n/**\n * The crash-safe record (10.1): the executor's `sink` option, its accounting on `getSnapshot().sink`,\n * `executor.flushRecord()`'s result, and the error a run with `onFailure: 'fail'` rejects with. The port\n * (`RecordSink`, `memorySink`) is `foottrace/write`'s; the file adapter is `footprintjs/sinks`.\n * @category Run\n */\nexport type {\n  RecordFlushResult,\n  RecordSinkFailureMode,\n  RecordSinkFlushMode,\n  RecordSinkOption,\n  RecordSinkOptions,\n  RecordSinkStats,\n} from './lib/runner/index.js';\n/** @category Run */\nexport { RecordSinkError } from './lib/runner/index.js';\n\n/**\n * The four observability dials `FlowChartExecutorOptions` inherits.\n * @category Run\n */\nexport type { RunDials } from './lib/memory/index.js';\n\n/** @category Run */\nexport { FlowChartExecutor } from './lib/runner/index.js';\n\n/** @category Run */\nexport { RunContext } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { ChartOpenAPIOptions, MCPToolDescription, RunnableFlowChart } from './lib/runner/RunnableChart.js';\n\n// ============================================================================\n// Observe — Data (scope recorders, fire during stage execution)\n// ============================================================================\n\n/** @category Observe — Data */\nexport type {\n  CommitEvent,\n  ErrorEvent,\n  ReadEvent,\n  RedactionPolicy,\n  RedactionReport,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { MetricRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { DebugRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Operation */\nexport { RecorderOperation } from './lib/recorder/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * Every `attach*Recorder` call accepts an options bag:\n * `executor.attachScopeRecorder(rec, { delivery: 'deferred' })` takes the\n * recorder OUT of the engine's hot path — events are captured into one\n * bounded, totally-ordered queue and delivered at the next microtask\n * checkpoint (\"one beat behind\"). Omit `delivery` for the historical\n * synchronous call (byte-identical to previous releases). Accounting\n * surfaces on `snapshot.observerStats`; `executor.drainObservers()` settles\n * async listeners before shutdown. See `docs/guides/observers-deferred.md`.\n */\nexport type {\n  AttachRecorderOptions,\n  ObserverDelivery,\n  ObserverDrainResult,\n  ObserverStats,\n} from './lib/runner/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * `CapturePolicy` — how a deferred event's payload is materialized at\n * capture time (`'clone'` by default for attach options / `'summary'` / `'ref'`). `OverflowPolicy`\n * — what a saturated queue does (`'drop-oldest'` default / `'sample'` /\n * `'block'`). `DispatcherStats` / `ListenerStats` — the accounting shapes\n * embedded in `ObserverStats`. Types only — the observer-queue module\n * itself is internal; consumers use the attach options.\n */\nexport type { CapturePolicy, DispatcherStats, ListenerStats, OverflowPolicy } from './lib/observer-queue/index.js';\n\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport type { CombinedRecorder } from './lib/recorder/index.js';\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport {\n  hasEmitRecorderMethods,\n  hasFlowRecorderMethods,\n  hasRecorderMethods,\n  isFlowEvent,\n} from './lib/recorder/index.js';\n\n/**\n * @category Observe — Emit (user-authored structured events)\n *\n * Third observer channel (alongside `ScopeRecorder` and `FlowRecorder`). Consumer\n * code calls `scope.$emit(name, payload)` from inside a stage; every attached\n * `EmitRecorder.onEmit(event)` fires synchronously with stage-context\n * enrichment. Pass-through — no buffering, zero allocation when no recorder\n * is attached.\n */\nexport type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Observe — Flow (FlowRecorder, fires after stage execution)\n// ============================================================================\n\n/** @category Observe — Flow */\nexport type {\n  FlowAttemptEvent,\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowStageRetryEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n  FlowThrottledEvent,\n  ResumeLink,\n  TraversalContext,\n} from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { CombinedNarrativeEntry } from './lib/engine/index.js';\n\n/**\n * @category Observe — Flow\n *\n * `NarrativeFormatter` — pluggable formatter that converts event context\n * objects into the text lines of the narrative.\n */\nexport type { NarrativeFormatter } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { NarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { ManifestAttemptRow, ManifestEntry } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ManifestFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { AdaptiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { MilestoneNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ProgressiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { RLENarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SeparateNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SilentNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';\n\n// ============================================================================\n// Self-Describing — .contract(), toOpenAPI(), toMCPTool()\n// ============================================================================\n\n/** @category Self-Describing */\nexport type { JsonSchema } from './lib/contract/index.js';\n\n// ============================================================================\n// Snapshot & Composition — Subflow navigation and ComposableRunner\n// ============================================================================\n\n/** @category Snapshot & Composition */\nexport type { ComposableRunner } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport type { RecorderSnapshot, RuntimeSnapshot, SubtreeSnapshot } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';\n\n// ============================================================================\n// ScopeRecorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category ScopeRecorder */\nexport { CompositeRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Pause/Resume — Serializable checkpoints for long-running or human-in-the-loop flows\n// ============================================================================\n\n/** @category Pause/Resume */\n/** @category Pause/Resume */\nexport type {\n  FlowchartCheckpoint,\n  PausableHandler,\n  PausedExecution,\n  PendingPause,\n  RedactionMarks,\n} from './lib/pause/index.js';\n\n/**\n * @category Pause/Resume\n *\n * `interrupt(scope, { reason, expects? })` — stop mid-stage to ask a question,\n * and get the answer back at the same call site when the run resumes. Resume\n * re-enters the stage from its TOP (stages are atomic), so keep the half\n * before the call idempotent.\n */\nexport type { InterruptPayload } from './lib/pause/index.js';\n\n/** @category Pause/Resume */\nexport { interrupt } from './lib/pause/index.js';\n\n/** @category ScopeRecorder */\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\n\n// ============================================================================\n// Configuration — Types passed to FlowChartExecutor and run()\n// ============================================================================\n\n/** @category Configuration */\nexport type { ExecutionEnv, ExecutorResult, PausedResult, RunOptions } from './lib/engine/index.js';\n\n/** @category Configuration */\nexport type { ScopeFactory } from './lib/engine/index.js';\n\n/**\n * @category Configuration\n *\n * Read-tracking policy for `StageSnapshot.stageReads` (#14):\n * `'full'` (default — per-read value clone, historical behavior) /\n * `'summary'` (cheap `ReadSummaryMarker` per read) / `'off'` (no tracking,\n * zero per-read clone). Pass as `new FlowChartExecutor(chart, { readTracking })`\n * or call `executor.setReadTracking(mode)` before `run()`.\n */\nexport type { ReadSummaryMarker, ReadTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Write-tracking policy for `StageSnapshot.stageWrites` (#13c-A) — the\n * sibling of `ReadTrackingMode`; both alias the shared `RetentionPolicy`\n * family from `lib/capture`. `'full'` (default — per-write value clone,\n * historical behavior) / `'summary'` (cheap `WriteSummaryMarker` per write)\n * / `'off'` (no tracking; `stageWrites` absent and the `onCommit` mutations\n * payload is empty — writes themselves still commit, and the commit log is\n * unaffected). Pass as `new FlowChartExecutor(chart, { writeTracking })` or\n * call `executor.setWriteTracking(mode)` before `run()`.\n */\nexport type { RetentionPolicy, WriteSummaryMarker, WriteTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Commit-values encoding for the COMMIT LOG (#13c-B) — the third dial of\n * the family, and the only LOSSLESS one (it changes the log's encoding,\n * never its information). `'full'` (default — every surviving `set` stores\n * the full final value, byte-identical to history) / `'delta'` (array\n * net-changes that are \"base plus a tail\" commit as an `append` verb\n * storing only the tail; `deleteValue()` commits as a real `delete` verb;\n * one trace entry per surviving path). Replay reconstructs every step's\n * full state exactly. Consumers reading `bundle.overwrite[key]` as the full\n * value must use `commitValueAt` from `foottrace`. Pass as\n * `new FlowChartExecutor(chart, { commitValues })` or call\n * `executor.setCommitValues(mode)` before `run()`; the active mode is the\n * snapshot discriminant `getSnapshot().commitValues`.\n */\n\n// ============================================================================\n// Contract & Validation\n// ============================================================================\n\n/** @category Contract & Validation */\nexport type { SchemaKind, ValidationIssue, ValidationResult } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { detectSchema, isValidatable, isZod } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { InputValidationError, validateAgainstSchema, validateOrThrow } from './lib/schema/index.js';\n\n// ============================================================================\n// Error Utilities\n// ============================================================================\n\n/** @category Error Utilities */\nexport type { StructuredErrorInfo } from './lib/engine/index.js';\n\n/** @category Error Utilities */\nexport { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';\n\n// ============================================================================\n// Dev Tools — Mode flags and Zod scope utilities\n// ============================================================================\n\n/**\n * @category Dev Tools\n *\n * Global dev-mode flag. Call `enableDevMode()` at application startup to\n * turn on developer-only diagnostics across the library — circular-reference\n * detection in scope writes, warnings when a recorder has no observer\n * methods, suspicious-predicate warnings in decide/select, structural\n * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.\n *\n * Production leaves it OFF by default (zero overhead). See the JSDoc on\n * `enableDevMode` for the full list and usage example.\n */\nexport { disableDevMode, enableDevMode, isDevMode } from './lib/devMode.js';\n\n// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in\n// `footprintjs/zod` entry — keeping zod out of the core load path (it is an\n// optional peer). Import them from 'footprintjs/zod'.\n// A run's record as JSON without the engine's recursion limit (9.26.0): the\n// same bytes JSON.stringify emits, for a deep `next` chain it cannot encode.\nexport type { RetryLoopCall, RetryLoopDecision, RetryLoopIdentity } from './lib/attempt/retryLoopTypes.js';\nexport type { RetryLoopContext, RetryLoopOptions, RetryLoopState } from './lib/builder/retryLoop.js';\nexport type {\n  CaptureChannelStatus,\n  CaptureLimitation,\n  NativeCaptureNote,\n  RecorderCaptureAcknowledgement,\n} from './lib/capture/nativeCoverage.js';\nexport type {\n  EngineReadSources,\n  NativeCaptureObservation,\n  NativeReadCaptureNote,\n  SourceLimitation,\n} from './lib/capture/readSources.js';\nexport type {\n  SourceExecutionOwnership,\n  SourceOwnershipGap,\n  SourceOwnershipWitness,\n} from './lib/capture/sourceOwnershipFormat.js';\nexport { stringifySnapshot } from './lib/runner/stringifySnapshot.js';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * FootPrint — Public API (v3)\n *\n * The flowchart pattern for backend code.\n * Build → Run → Observe.\n *\n * **The common import paths:**\n * ```ts\n * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here\n * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories\n * import { stateAt, causalChain } from 'foottrace';     // read a finished run\n * import { RecordFrame, EventLog } from 'foottrace/write';     // write a record yourself\n * import { StageContext }                 from 'footprintjs/advanced';  // engine internals\n * ```\n *\n * @module\n */\n\n// ============================================================================\n// Quick Start — Everything you need for 90% of use cases\n// ============================================================================\n\n/** @category Quick Start */\nexport type { FlowChart, StageFunction as StageHandler, StreamHandlers } from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';\n\n/**\n * @category Quick Start\n *\n * Config for `.addParallelForEach()` — one branch per item, branch count\n * decided at run time from the payload. `maxBranches` and `into` are required\n * on purpose (see docs/design/execution-control.md).\n */\nexport type { BranchChart, ParallelForEachConfig, RetryPolicy } from './lib/builder/index.js';\n\n/** @category Quick Start — build-time observer (twin of FlowRecorder) */\nexport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureEdgeKind,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureStageTaggedEvent,\n  StructureSubflowMountedEvent,\n} from './lib/builder/index.js';\n\n/**\n * @category Time Budget\n *\n * `timeBudget(chart)` — the slowest a chart can take, from its declared retry policies (`attempts × timeoutMs` plus\n * the waits, summed along the slowest path), and every stage that makes a path unbounded, by name. `.budget(ms)`\n * declares the caller's contract; `build()` refuses a chart that cannot keep it. Also `chart.timeBudget()`.\n */\nexport type {\n  BudgetAssumptions,\n  BudgetStep,\n  TimeBudgetOptions,\n  TimeBudgetReport,\n  UnboundedReason,\n  UnboundedStage,\n} from './lib/budget/index.js';\nexport { timeBudget } from './lib/budget/index.js';\n\n/** @category Quick Start */\nexport type { TypedStageFunction } from './lib/builder/typedFlowChart.js';\n\n/** @category Quick Start */\nexport type { ScopeMethods, TypedScope } from './lib/reactive/index.js';\n\n/** @category Quick Start */\nexport { narrative } from './recorders.js';\n\n// ============================================================================\n// Decision Branching — decide() / select() with evidence capture\n// ============================================================================\n\n/** @category Decision Branching */\nexport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  DefaultBranch,\n  FilterOps,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhenClause,\n  WhereFilter,\n} from './lib/decide/index.js';\n\n/** @category Decision Branching */\nexport { decide, select } from './lib/decide/index.js';\n\n/** @category Errors */\nexport type { TerminalFailureContext } from './lib/errors/terminalFailure.js';\n\n// ============================================================================\n// Attempts — every try of a retried stage, and the decision that followed it\n// ============================================================================\n\n/**\n * @category Attempts\n *\n * One `AttemptRecord` per attempt of a stage with a declared `retry` policy, a `timeoutMs`, or a run deadline —\n * timing, outcome, failure category, and the retry-or-stop decision as `DecisionEvidence` — on the stage's\n * execution-tree node (`StageSnapshot.attempts` / `attemptSummary`) and on `FlowRecorder.onAttempt`.\n * A call a stage makes through `scope.$call` is recorded the same way (kind `'call'`), and so is an SDK's own retry\n * an adapter reports through `observed()` (`ObservedAttempt`, kind `'observed'`). `AttemptContext` is what\n * `scope.$attempt()` returns, and what a call's function gets (the attempt's signal, the time left, `observed`);\n * `LateWrite` is a write (or call) an ended attempt tried (`StageSnapshot.lateWrites`). A stage that changes an\n * outside system declares it (`StageTouches`, `.touches()`), and a call does (`CallOptions`): every attempt then\n * carries its `AttemptEffect`, and the key rule is handed an `IdempotencyKeyContext` once per execution.\n */\nexport type {\n  AttemptCategory,\n  AttemptContext,\n  AttemptEffect,\n  AttemptError,\n  AttemptInputs,\n  AttemptKind,\n  AttemptNext,\n  AttemptOptions,\n  AttemptOutcome,\n  AttemptReason,\n  AttemptRecord,\n  AttemptSummary,\n  CallOptions,\n  IdempotencyKeyContext,\n  LateWrite,\n  ObservedAttempt,\n  StageTouches,\n  UnknownEffectInit,\n} from './lib/attempt/index.js';\n/**\n * @category Attempts\n *\n * An attempt by name (`series` + `attempt`) and per-outcome counts — what recorder rows hold of attempts.\n */\nexport type { AttemptOutcomeCounts, AttemptRef } from './lib/recorder/attemptSeries.js';\n\n/**\n * @category Attempts\n *\n * `attempt()` — the attempt runner for code that is not a stage (records go to its `onAttempt`); `errorCategory`\n * — the one failure classifier (seven fixed categories); `retryRules` — the one retry rule table, as `decide()`\n * rules; the attempt contract's two errors; `exponentialBackoff` / `statedWaitFirst` — deterministic builders of\n * the function a `RetryPolicy.backoffMs` takes (`BackoffSpec.maxDelayMs` caps the schedule before the jitter draw; the\n * policy's `maxBackoffMs` still caps every wait after it).\n */\nexport {\n  attempt,\n  AttemptTimeoutError,\n  errorCategory,\n  exponentialBackoff,\n  retryRules,\n  statedWaitFirst,\n  UnknownEffectError,\n} from './lib/attempt/index.js';\n/**\n * @category Attempts\n *\n * What the backoff builders take and build: an exponential schedule (`BackoffSpec`, its `BackoffJitter`), the\n * `RetryPolicy.backoffMs` function they return (`BackoffFunction`), and the reader of a stated wait\n * (`StatedWaitReader` — a parsed `Retry-After`, in milliseconds).\n */\nexport type { BackoffFunction, BackoffJitter, BackoffSpec, StatedWaitReader } from './lib/attempt/index.js';\n\n/**\n * @category Correlation\n *\n * The run's correlation (10.1): `env.traceparent` (W3C, parsed strictly) or `env.traceId` + `env.operationId`\n * become ONE frozen `RunCorrelation` per run — on `getSnapshot().correlation`, every flow event's\n * `traversalContext.correlation` and every scope and emit event's `correlation`. `parseTraceparent` /\n * `formatTraceparent` are the W3C codec; a refused header throws `TraceparentError` with a named `reason`.\n */\nexport type { ParsedTraceparent, RunCorrelation, TraceparentFields, TraceparentRefusal } from './lib/attempt/index.js';\nexport { formatTraceparent, parseTraceparent, TraceparentError } from './lib/attempt/index.js';\n\n// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type {\n  CaptureHistoryOptions,\n  CaptureHistoryReceipt,\n  CaptureHistoryStatus,\n  CaptureHistoryTarget,\n} from './lib/runner/index.js';\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } from './lib/runner/index.js';\n\n/**\n * The crash-safe record (10.1): the executor's `sink` option, its accounting on `getSnapshot().sink`,\n * `executor.flushRecord()`'s result, and the error a run with `onFailure: 'fail'` rejects with. The port\n * (`RecordSink`, `memorySink`) is `foottrace/write`'s; the file adapter is `footprintjs/sinks`.\n * @category Run\n */\nexport type {\n  RecordFlushResult,\n  RecordSinkFailureMode,\n  RecordSinkFlushMode,\n  RecordSinkOption,\n  RecordSinkOptions,\n  RecordSinkStats,\n} from './lib/runner/index.js';\n/** @category Run */\nexport { RecordSinkError } from './lib/runner/index.js';\n\n/**\n * The four observability dials `FlowChartExecutorOptions` inherits.\n * @category Run\n */\nexport type { RunDials } from './lib/memory/index.js';\n\n/** @category Run */\nexport { FlowChartExecutor } from './lib/runner/index.js';\n\n/** @category Run */\nexport { RunContext } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { ChartOpenAPIOptions, MCPToolDescription, RunnableFlowChart } from './lib/runner/RunnableChart.js';\n\n// ============================================================================\n// Observe — Data (scope recorders, fire during stage execution)\n// ============================================================================\n\n/** @category Observe — Data */\nexport type {\n  CommitEvent,\n  ErrorEvent,\n  ReadEvent,\n  RedactionPolicy,\n  RedactionReport,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { MetricRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { DebugRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Operation */\nexport { RecorderOperation } from './lib/recorder/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * Every `attach*Recorder` call accepts an options bag:\n * `executor.attachScopeRecorder(rec, { delivery: 'deferred' })` takes the\n * recorder OUT of the engine's hot path — events are captured into one\n * bounded, totally-ordered queue and delivered at the next microtask\n * checkpoint (\"one beat behind\"). Omit `delivery` for the historical\n * synchronous call (byte-identical to previous releases). Accounting\n * surfaces on `snapshot.observerStats`; `executor.drainObservers()` settles\n * async listeners before shutdown. See `docs/guides/observers-deferred.md`.\n */\nexport type {\n  AttachRecorderOptions,\n  ObserverDelivery,\n  ObserverDrainResult,\n  ObserverStats,\n} from './lib/runner/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * `CapturePolicy` — how a deferred event's payload is materialized at\n * capture time (`'clone'` by default for attach options / `'summary'` / `'ref'`). `OverflowPolicy`\n * — what a saturated queue does (`'drop-oldest'` default / `'sample'` /\n * `'block'`). `DispatcherStats` / `ListenerStats` — the accounting shapes\n * embedded in `ObserverStats`. Types only — the observer-queue module\n * itself is internal; consumers use the attach options.\n */\nexport type { CapturePolicy, DispatcherStats, ListenerStats, OverflowPolicy } from './lib/observer-queue/index.js';\n\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport type { CombinedRecorder } from './lib/recorder/index.js';\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport {\n  hasEmitRecorderMethods,\n  hasFlowRecorderMethods,\n  hasRecorderMethods,\n  isFlowEvent,\n} from './lib/recorder/index.js';\n\n/**\n * @category Observe — Emit (user-authored structured events)\n *\n * Third observer channel (alongside `ScopeRecorder` and `FlowRecorder`). Consumer\n * code calls `scope.$emit(name, payload)` from inside a stage; every attached\n * `EmitRecorder.onEmit(event)` fires synchronously with stage-context\n * enrichment. Pass-through — no buffering, zero allocation when no recorder\n * is attached.\n */\nexport type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Observe — Flow (FlowRecorder, fires after stage execution)\n// ============================================================================\n\n/** @category Observe — Flow */\nexport type {\n  FlowAttemptEvent,\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowStageRetryEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n  FlowThrottledEvent,\n  ResumeLink,\n  TraversalContext,\n} from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { CombinedNarrativeEntry } from './lib/engine/index.js';\n\n/**\n * @category Observe — Flow\n *\n * `NarrativeFormatter` — pluggable formatter that converts event context\n * objects into the text lines of the narrative.\n */\nexport type { NarrativeFormatter } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { NarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { ManifestAttemptRow, ManifestEntry } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ManifestFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { AdaptiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { MilestoneNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ProgressiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { RLENarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SeparateNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SilentNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';\n\n// ============================================================================\n// Self-Describing — .contract(), toOpenAPI(), toMCPTool()\n// ============================================================================\n\n/** @category Self-Describing */\nexport type { JsonSchema } from './lib/contract/index.js';\n\n// ============================================================================\n// Snapshot & Composition — Subflow navigation and ComposableRunner\n// ============================================================================\n\n/** @category Snapshot & Composition */\nexport type { ComposableRunner } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport type { RecorderSnapshot, RuntimeSnapshot, SubtreeSnapshot } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';\n\n// ============================================================================\n// ScopeRecorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category ScopeRecorder */\nexport { CompositeRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Pause/Resume — Serializable checkpoints for long-running or human-in-the-loop flows\n// ============================================================================\n\n/** @category Pause/Resume */\n/** @category Pause/Resume */\nexport type {\n  FlowchartCheckpoint,\n  PausableHandler,\n  PausedExecution,\n  PendingPause,\n  RedactionMarks,\n} from './lib/pause/index.js';\n\n/**\n * @category Pause/Resume\n *\n * `interrupt(scope, { reason, expects? })` — stop mid-stage to ask a question,\n * and get the answer back at the same call site when the run resumes. Resume\n * re-enters the stage from its TOP (stages are atomic), so keep the half\n * before the call idempotent.\n */\nexport type { InterruptPayload } from './lib/pause/index.js';\n\n/** @category Pause/Resume */\nexport { interrupt } from './lib/pause/index.js';\n\n/** @category ScopeRecorder */\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\n\n// ============================================================================\n// Configuration — Types passed to FlowChartExecutor and run()\n// ============================================================================\n\n/** @category Configuration */\nexport type { ExecutionEnv, ExecutorResult, PausedResult, RunOptions } from './lib/engine/index.js';\n\n/** @category Configuration */\nexport type { ScopeFactory } from './lib/engine/index.js';\n\n/**\n * @category Configuration\n *\n * Read-tracking policy for `StageSnapshot.stageReads` (#14):\n * `'full'` (default — per-read value clone, historical behavior) /\n * `'summary'` (cheap `ReadSummaryMarker` per read) / `'off'` (no tracking,\n * zero per-read clone). Pass as `new FlowChartExecutor(chart, { readTracking })`\n * or call `executor.setReadTracking(mode)` before `run()`.\n */\nexport type { ReadSummaryMarker, ReadTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Write-tracking policy for `StageSnapshot.stageWrites` (#13c-A) — the\n * sibling of `ReadTrackingMode`; both alias the shared `RetentionPolicy`\n * family from `lib/capture`. `'full'` (default — per-write value clone,\n * historical behavior) / `'summary'` (cheap `WriteSummaryMarker` per write)\n * / `'off'` (no tracking; `stageWrites` absent and the `onCommit` mutations\n * payload is empty — writes themselves still commit, and the commit log is\n * unaffected). Pass as `new FlowChartExecutor(chart, { writeTracking })` or\n * call `executor.setWriteTracking(mode)` before `run()`.\n */\nexport type { RetentionPolicy, WriteSummaryMarker, WriteTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Commit-values encoding for the COMMIT LOG (#13c-B) — the third dial of\n * the family, and the only LOSSLESS one (it changes the log's encoding,\n * never its information). `'full'` (default — every surviving `set` stores\n * the full final value, byte-identical to history) / `'delta'` (array\n * net-changes that are \"base plus a tail\" commit as an `append` verb\n * storing only the tail; `deleteValue()` commits as a real `delete` verb;\n * one trace entry per surviving path). Replay reconstructs every step's\n * full state exactly. Consumers reading `bundle.overwrite[key]` as the full\n * value must use `commitValueAt` from `foottrace`. Pass as\n * `new FlowChartExecutor(chart, { commitValues })` or call\n * `executor.setCommitValues(mode)` before `run()`; the active mode is the\n * snapshot discriminant `getSnapshot().commitValues`.\n */\n\n// ============================================================================\n// Contract & Validation\n// ============================================================================\n\n/** @category Contract & Validation */\nexport type { SchemaKind, ValidationIssue, ValidationResult } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { detectSchema, isValidatable, isZod } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { InputValidationError, validateAgainstSchema, validateOrThrow } from './lib/schema/index.js';\n\n// ============================================================================\n// Error Utilities\n// ============================================================================\n\n/** @category Error Utilities */\nexport type { StructuredErrorInfo } from './lib/engine/index.js';\n\n/** @category Error Utilities */\nexport { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';\n\n// ============================================================================\n// Dev Tools — Mode flags and Zod scope utilities\n// ============================================================================\n\n/**\n * @category Dev Tools\n *\n * Global dev-mode flag. Call `enableDevMode()` at application startup to\n * turn on developer-only diagnostics across the library — circular-reference\n * detection in scope writes, warnings when a recorder has no observer\n * methods, suspicious-predicate warnings in decide/select, structural\n * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.\n *\n * Production leaves it OFF by default (zero overhead). See the JSDoc on\n * `enableDevMode` for the full list and usage example.\n */\nexport { disableDevMode, enableDevMode, isDevMode } from './lib/devMode.js';\n\n// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in\n// `footprintjs/zod` entry — keeping zod out of the core load path (it is an\n// optional peer). Import them from 'footprintjs/zod'.\n// A run's record as JSON without the engine's recursion limit (9.26.0): the\n// same bytes JSON.stringify emits, for a deep `next` chain it cannot encode.\nexport type { RetryLoopCall, RetryLoopDecision, RetryLoopIdentity } from './lib/attempt/retryLoopTypes.js';\nexport type { RetryLoopContext, RetryLoopOptions, RetryLoopState } from './lib/builder/retryLoop.js';\nexport type {\n  CaptureChannelStatus,\n  CaptureLimitation,\n  NativeCaptureNote,\n  RecorderCaptureAcknowledgement,\n} from './lib/capture/nativeCoverage.js';\nexport type {\n  EngineReadSources,\n  NativeCaptureObservation,\n  NativeReadCaptureNote,\n  SourceLimitation,\n} from './lib/capture/readSources.js';\nexport type {\n  SourceExecutionOwnership,\n  SourceOwnershipGap,\n  SourceOwnershipWitness,\n} from './lib/capture/sourceOwnershipFormat.js';\nexport { stringifySnapshot } from './lib/runner/stringifySnapshot.js';\n"]}

package/dist/esm/lib/attempt/backoff.d.ts

@@ -0,0 +1,96 @@
+/**
+ * attempt/backoff.ts — deterministic builders of a `RetryPolicy.backoffMs` function.
+ *
+ * WHY: every retry loop needs the same few lines — an exponential ceiling and some jitter — and every hand copy of them
+ * drifts: a different base, a different jitter, a stated `Retry-After` honoured in one loop and not the next. These
+ * helpers build the FUNCTION `RetryPolicy.backoffMs` already takes, so the policy keeps its one shape and the runner
+ * keeps its one law: it asks the function once per retry, caps the answer at `maxBackoffMs`, stops a series whose wait
+ * would outlast the run's deadline (`no-time-left`), and records the wait it chose (`AttemptRecord.delayMs`,
+ * `onStageRetry`'s `delayMs`). The trace explains every wait as it was waited; nothing is redrawn to explain it.
+ *
+ *   exponentialBackoff({ baseDelayMs, multiplier = 2, maxDelayMs?, jitter = 'none', random = Math.random })
+ *     the wait after failed attempt n, under its ceiling c = min(maxDelayMs, baseDelayMs × multiplier^(n − 1)):
+ *       'none'  → c                   deterministic: `random` is never called
+ *       'equal' → c/2 + r × c/2       half fixed, half random (r = random(), in [0, 1])
+ *       'full'  → r × c
+ *   statedWaitFirst(readStatedWaitMs, inner)
+ *     a wait the outside system STATED (a `Retry-After`, read off the error) wins; otherwise `inner` decides.
+ *
+ * TWO CAPS, two jobs:
+ *   - `BackoffSpec.maxDelayMs` caps the SCHEDULE: it bounds the ceiling BEFORE the draw, so a capped schedule keeps its
+ *     jitter. Capping after the draw instead would flatten every jittered wait to one constant once the schedule
+ *     passes twice the cap — a fleet would retry in lockstep, which is what jitter is for preventing.
+ *   - `RetryPolicy.maxBackoffMs` caps EVERY wait, a stated one included, after the draw; the runner enforces it and the
+ *     static time budget counts a function backoff at it without calling it.
+ * A stated wait is never capped by the inner schedule's `maxDelayMs` — only `maxBackoffMs` and the deadline bound it.
+ * Without `maxDelayMs` a ceiling saturates at `Number.MAX_SAFE_INTEGER` ms, so no attempt makes a wait `Infinity`.
+ *
+ * THE SERVER CHOOSES A STATED WAIT. `statedWaitFirst` hands the wait to the outside system — a broken or hostile one
+ * can ask for an hour. Whenever the wait comes from the server, declare the policy's `maxBackoffMs` (the runner caps
+ * every wait at it) or run under a deadline (the runner stops a series whose wait would outlast it).
+ *
+ * Refused when built — by the field's name and the shape it needs, NEVER the value it was given (a field can hold a
+ * secret): a `TypeError` for a wrong type (`'100'` included), a `RangeError` for a number out of range. The rules: a
+ * `baseDelayMs` that is a finite number >= 0, a `multiplier` >= 1, a `maxDelayMs` >= `baseDelayMs`, a `jitter` of the
+ * three names, a `random` or a reader that is a function, an `inner` that is a function or a finite number >= 0.
+ *
+ * A DRAW IS NOT TRUSTED BLINDLY: a `random()` that answers anything but a number in [0, 1] — or throws — makes that
+ * wait the ceiling `c`, the longest the schedule allows. Never 0: a broken source cannot make every jittered retry
+ * fire at once. The default source is `Math.random`, looked up at each draw (so a spy installed later takes effect).
+ */
+import type { RetryPolicy } from './types.js';
+/** How much of an exponential wait is random: none of it, half of it, or all of it. */
+export type BackoffJitter = 'none' | 'equal' | 'full';
+/** The schedule {@link exponentialBackoff} builds a `RetryPolicy.backoffMs` function from. */
+export interface BackoffSpec {
+    /** The ceiling of the first wait (after attempt 1), in milliseconds — a finite number >= 0. */
+    readonly baseDelayMs: number;
+    /** How much each ceiling grows over the one before — a finite number >= 1. Default `2`. */
+    readonly multiplier?: number;
+    /**
+     * The most a ceiling may grow to, in milliseconds — a finite number >= `baseDelayMs`. It caps the SCHEDULE before
+     * the jitter is drawn, so waits at the cap still spread (`'equal'` between `maxDelayMs / 2` and `maxDelayMs`). It
+     * is not `RetryPolicy.maxBackoffMs`, which caps every wait after the draw, a stated one included. Absent: the
+     * ceiling grows until it saturates at `Number.MAX_SAFE_INTEGER`.
+     */
+    readonly maxDelayMs?: number;
+    /** How much of each wait is random. Default `'none'`: the wait IS the ceiling. */
+    readonly jitter?: BackoffJitter;
+    /**
+     * The jitter's random source, answering in [0, 1]. Default `Math.random`, looked up at each draw; a fixed one makes a
+     * test exact. A draw outside [0, 1] (or a throw) makes that wait the ceiling — never 0.
+     */
+    readonly random?: () => number;
+}
+/** A `RetryPolicy.backoffMs` function: the wait in milliseconds after failed attempt `attempt` (1-based). */
+export type BackoffFunction = (attempt: number, error?: unknown) => number;
+/** Reads the wait an error states (a parsed `Retry-After`), in milliseconds, or `undefined` when it states none. */
+export type StatedWaitReader = (error: unknown) => number | undefined;
+/**
+ * A `RetryPolicy.backoffMs` function for an exponential schedule: the wait after failed attempt `n` is drawn under the
+ * ceiling `min(maxDelayMs, baseDelayMs × multiplier^(n − 1))` by the declared jitter — the schedule is capped BEFORE
+ * the draw, so it keeps its spread. The policy's `maxBackoffMs` still caps every wait after it.
+ *
+ * @example
+ * ```ts
+ * .retry({ attempts: 6, backoffMs: exponentialBackoff({ baseDelayMs: 200, maxDelayMs: 2_000, jitter: 'equal' }), maxBackoffMs: 5_000 })
+ * ```
+ */
+export declare function exponentialBackoff(spec: BackoffSpec): BackoffFunction;
+/**
+ * A `RetryPolicy.backoffMs` function that honours a wait the outside system stated: when `readStatedWaitMs(error)`
+ * answers a finite number >= 0, that is the wait; otherwise `inner` (a backoff function, or a fixed number of
+ * milliseconds) decides. A reader that throws or answers anything else states nothing — a malformed `Retry-After`
+ * falls back to the schedule rather than to a wrong wait. The runner still caps the stated wait at `maxBackoffMs` and
+ * stops the series when it would outlast the run's deadline.
+ *
+ * The outside system chooses this wait, and a broken or hostile one can ask for an hour: whenever the wait comes from
+ * the server, declare the policy's `maxBackoffMs` (or run under a deadline).
+ *
+ * @example
+ * ```ts
+ * const retryAfterMs = (error: unknown) => (error as { retryAfterMs?: number }).retryAfterMs;
+ * .retry({ attempts: 3, backoffMs: statedWaitFirst(retryAfterMs, exponentialBackoff({ baseDelayMs: 100 })), maxBackoffMs: 10_000 })
+ * ```
+ */
+export declare function statedWaitFirst(readStatedWaitMs: StatedWaitReader, inner: NonNullable<RetryPolicy['backoffMs']>): BackoffFunction;

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

@@ -0,0 +1,173 @@
+/**
+ * attempt/backoff.ts — deterministic builders of a `RetryPolicy.backoffMs` function.
+ *
+ * WHY: every retry loop needs the same few lines — an exponential ceiling and some jitter — and every hand copy of them
+ * drifts: a different base, a different jitter, a stated `Retry-After` honoured in one loop and not the next. These
+ * helpers build the FUNCTION `RetryPolicy.backoffMs` already takes, so the policy keeps its one shape and the runner
+ * keeps its one law: it asks the function once per retry, caps the answer at `maxBackoffMs`, stops a series whose wait
+ * would outlast the run's deadline (`no-time-left`), and records the wait it chose (`AttemptRecord.delayMs`,
+ * `onStageRetry`'s `delayMs`). The trace explains every wait as it was waited; nothing is redrawn to explain it.
+ *
+ *   exponentialBackoff({ baseDelayMs, multiplier = 2, maxDelayMs?, jitter = 'none', random = Math.random })
+ *     the wait after failed attempt n, under its ceiling c = min(maxDelayMs, baseDelayMs × multiplier^(n − 1)):
+ *       'none'  → c                   deterministic: `random` is never called
+ *       'equal' → c/2 + r × c/2       half fixed, half random (r = random(), in [0, 1])
+ *       'full'  → r × c
+ *   statedWaitFirst(readStatedWaitMs, inner)
+ *     a wait the outside system STATED (a `Retry-After`, read off the error) wins; otherwise `inner` decides.
+ *
+ * TWO CAPS, two jobs:
+ *   - `BackoffSpec.maxDelayMs` caps the SCHEDULE: it bounds the ceiling BEFORE the draw, so a capped schedule keeps its
+ *     jitter. Capping after the draw instead would flatten every jittered wait to one constant once the schedule
+ *     passes twice the cap — a fleet would retry in lockstep, which is what jitter is for preventing.
+ *   - `RetryPolicy.maxBackoffMs` caps EVERY wait, a stated one included, after the draw; the runner enforces it and the
+ *     static time budget counts a function backoff at it without calling it.
+ * A stated wait is never capped by the inner schedule's `maxDelayMs` — only `maxBackoffMs` and the deadline bound it.
+ * Without `maxDelayMs` a ceiling saturates at `Number.MAX_SAFE_INTEGER` ms, so no attempt makes a wait `Infinity`.
+ *
+ * THE SERVER CHOOSES A STATED WAIT. `statedWaitFirst` hands the wait to the outside system — a broken or hostile one
+ * can ask for an hour. Whenever the wait comes from the server, declare the policy's `maxBackoffMs` (the runner caps
+ * every wait at it) or run under a deadline (the runner stops a series whose wait would outlast it).
+ *
+ * Refused when built — by the field's name and the shape it needs, NEVER the value it was given (a field can hold a
+ * secret): a `TypeError` for a wrong type (`'100'` included), a `RangeError` for a number out of range. The rules: a
+ * `baseDelayMs` that is a finite number >= 0, a `multiplier` >= 1, a `maxDelayMs` >= `baseDelayMs`, a `jitter` of the
+ * three names, a `random` or a reader that is a function, an `inner` that is a function or a finite number >= 0.
+ *
+ * A DRAW IS NOT TRUSTED BLINDLY: a `random()` that answers anything but a number in [0, 1] — or throws — makes that
+ * wait the ceiling `c`, the longest the schedule allows. Never 0: a broken source cannot make every jittered retry
+ * fire at once. The default source is `Math.random`, looked up at each draw (so a spy installed later takes effect).
+ */
+const JITTERS = ['none', 'equal', 'full'];
+/** Where a ceiling saturates: a wait is never `Infinity` and never `NaN`. */
+const MAX_WAIT_MS = Number.MAX_SAFE_INTEGER;
+/** The default random source: `Math.random`, looked up at each draw — so a spy installed after building takes effect. */
+const drawMathRandom = () => Math.random();
+/**
+ * A `RetryPolicy.backoffMs` function for an exponential schedule: the wait after failed attempt `n` is drawn under the
+ * ceiling `min(maxDelayMs, baseDelayMs × multiplier^(n − 1))` by the declared jitter — the schedule is capped BEFORE
+ * the draw, so it keeps its spread. The policy's `maxBackoffMs` still caps every wait after it.
+ *
+ * @example
+ * ```ts
+ * .retry({ attempts: 6, backoffMs: exponentialBackoff({ baseDelayMs: 200, maxDelayMs: 2_000, jitter: 'equal' }), maxBackoffMs: 5_000 })
+ * ```
+ */
+export function exponentialBackoff(spec) {
+    const { baseDelayMs, multiplier, maxDelayMs, jitter, random } = readSpec(spec);
+    return (attempt) => {
+        const ceiling = ceilingOf(baseDelayMs, multiplier, maxDelayMs, stepOf(attempt));
+        if (jitter === 'none')
+            return ceiling;
+        const r = draw(random);
+        // An untrusted draw waits the ceiling — never 0, so a broken source cannot fire every jittered retry at once.
+        if (r === undefined)
+            return ceiling;
+        // Never above the ceiling, rounding included: halving a subnormal ceiling is inexact and can round up.
+        return jitter === 'equal' ? Math.min(ceiling, ceiling / 2 + (r * ceiling) / 2) : r * ceiling;
+    };
+}
+/**
+ * A `RetryPolicy.backoffMs` function that honours a wait the outside system stated: when `readStatedWaitMs(error)`
+ * answers a finite number >= 0, that is the wait; otherwise `inner` (a backoff function, or a fixed number of
+ * milliseconds) decides. A reader that throws or answers anything else states nothing — a malformed `Retry-After`
+ * falls back to the schedule rather than to a wrong wait. The runner still caps the stated wait at `maxBackoffMs` and
+ * stops the series when it would outlast the run's deadline.
+ *
+ * The outside system chooses this wait, and a broken or hostile one can ask for an hour: whenever the wait comes from
+ * the server, declare the policy's `maxBackoffMs` (or run under a deadline).
+ *
+ * @example
+ * ```ts
+ * const retryAfterMs = (error: unknown) => (error as { retryAfterMs?: number }).retryAfterMs;
+ * .retry({ attempts: 3, backoffMs: statedWaitFirst(retryAfterMs, exponentialBackoff({ baseDelayMs: 100 })), maxBackoffMs: 10_000 })
+ * ```
+ */
+export function statedWaitFirst(readStatedWaitMs, inner) {
+    if (typeof readStatedWaitMs !== 'function') {
+        throw new TypeError('statedWaitFirst: readStatedWaitMs must be a function');
+    }
+    if (typeof inner !== 'function') {
+        checkNumber('statedWaitFirst: inner', inner, 0, 'a backoff function or a finite number >= 0');
+    }
+    return (attempt, error) => {
+        const stated = statedWaitOf(readStatedWaitMs, error);
+        if (stated !== undefined)
+            return stated;
+        return typeof inner === 'function' ? inner(attempt, error) : inner;
+    };
+}
+/** Each field read ONCE, then checked: what is checked is exactly what the function keeps (a getter cannot differ). */
+function readSpec(spec) {
+    if (spec === null || typeof spec !== 'object') {
+        throw new TypeError('exponentialBackoff: the spec must be an object ({ baseDelayMs, multiplier?, maxDelayMs?, jitter?, random? })');
+    }
+    const { baseDelayMs, multiplier = 2, maxDelayMs, jitter = 'none', random = drawMathRandom } = spec;
+    checkNumber('exponentialBackoff: baseDelayMs', baseDelayMs, 0, 'a finite number >= 0');
+    checkNumber('exponentialBackoff: multiplier', multiplier, 1, 'a finite number >= 1');
+    // At least the base: a cap below it would make every wait the cap — a fixed schedule written as an exponential one.
+    if (maxDelayMs !== undefined) {
+        checkNumber('exponentialBackoff: maxDelayMs', maxDelayMs, baseDelayMs, 'a finite number >= baseDelayMs');
+    }
+    const jitterRule = "exponentialBackoff: jitter must be 'none', 'equal' or 'full'";
+    if (typeof jitter !== 'string')
+        throw new TypeError(jitterRule);
+    if (!JITTERS.includes(jitter))
+        throw new RangeError(jitterRule);
+    if (typeof random !== 'function') {
+        throw new TypeError('exponentialBackoff: random must be a function answering a number in [0, 1]');
+    }
+    return { baseDelayMs, multiplier, maxDelayMs: maxDelayMs ?? MAX_WAIT_MS, jitter, random };
+}
+/**
+ * A finite number >= `min`, or the error that names `field` and the shape it needs — never the value it was given (a
+ * field can hold a secret): a `TypeError` for a non-number, a `RangeError` for a number out of range.
+ */
+function checkNumber(field, value, min, rule) {
+    if (typeof value !== 'number')
+        throw new TypeError(`${field} must be ${rule}`);
+    if (!Number.isFinite(value) || value < min)
+        throw new RangeError(`${field} must be ${rule}`);
+}
+/** The attempt as a schedule step: its whole part, at least 1 (anything that is not a finite number reads as 1). */
+function stepOf(attempt) {
+    return typeof attempt === 'number' && Number.isFinite(attempt) && attempt >= 1 ? Math.floor(attempt) : 1;
+}
+/**
+ * `min(maxDelayMs, baseDelayMs × multiplier^(step − 1))` — the schedule's cap, applied BEFORE any jitter is drawn
+ * (`maxDelayMs` is {@link MAX_WAIT_MS} when none was declared, so the ceiling saturates rather than overflows).
+ */
+function ceilingOf(baseDelayMs, multiplier, maxDelayMs, step) {
+    if (baseDelayMs === 0)
+        return 0;
+    const ceiling = baseDelayMs * multiplier ** (step - 1);
+    return ceiling < maxDelayMs ? ceiling : maxDelayMs;
+}
+/**
+ * One draw from the random source: a number in [0, 1] (`-0` reads as `0`), or `undefined` when the source answers
+ * anything else or throws — an untrusted draw, which the caller turns into the ceiling.
+ */
+function draw(random) {
+    let r;
+    try {
+        r = random();
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof r !== 'number' || !(r >= 0 && r <= 1))
+        return undefined;
+    return r === 0 ? 0 : r;
+}
+/** The wait `error` states, read once — none when the reader throws or answers anything but a finite number >= 0. */
+function statedWaitOf(read, error) {
+    let value;
+    try {
+        value = read(error);
+    }
+    catch {
+        return undefined;
+    }
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backoff.js","sourceRoot":"","sources":["../../../../src/lib/attempt/backoff.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/backoff.ts — deterministic builders of a `RetryPolicy.backoffMs` function.\n *\n * WHY: every retry loop needs the same few lines — an exponential ceiling and some jitter — and every hand copy of them\n * drifts: a different base, a different jitter, a stated `Retry-After` honoured in one loop and not the next. These\n * helpers build the FUNCTION `RetryPolicy.backoffMs` already takes, so the policy keeps its one shape and the runner\n * keeps its one law: it asks the function once per retry, caps the answer at `maxBackoffMs`, stops a series whose wait\n * would outlast the run's deadline (`no-time-left`), and records the wait it chose (`AttemptRecord.delayMs`,\n * `onStageRetry`'s `delayMs`). The trace explains every wait as it was waited; nothing is redrawn to explain it.\n *\n *   exponentialBackoff({ baseDelayMs, multiplier = 2, maxDelayMs?, jitter = 'none', random = Math.random })\n *     the wait after failed attempt n, under its ceiling c = min(maxDelayMs, baseDelayMs × multiplier^(n − 1)):\n *       'none'  → c                   deterministic: `random` is never called\n *       'equal' → c/2 + r × c/2       half fixed, half random (r = random(), in [0, 1])\n *       'full'  → r × c\n *   statedWaitFirst(readStatedWaitMs, inner)\n *     a wait the outside system STATED (a `Retry-After`, read off the error) wins; otherwise `inner` decides.\n *\n * TWO CAPS, two jobs:\n *   - `BackoffSpec.maxDelayMs` caps the SCHEDULE: it bounds the ceiling BEFORE the draw, so a capped schedule keeps its\n *     jitter. Capping after the draw instead would flatten every jittered wait to one constant once the schedule\n *     passes twice the cap — a fleet would retry in lockstep, which is what jitter is for preventing.\n *   - `RetryPolicy.maxBackoffMs` caps EVERY wait, a stated one included, after the draw; the runner enforces it and the\n *     static time budget counts a function backoff at it without calling it.\n * A stated wait is never capped by the inner schedule's `maxDelayMs` — only `maxBackoffMs` and the deadline bound it.\n * Without `maxDelayMs` a ceiling saturates at `Number.MAX_SAFE_INTEGER` ms, so no attempt makes a wait `Infinity`.\n *\n * THE SERVER CHOOSES A STATED WAIT. `statedWaitFirst` hands the wait to the outside system — a broken or hostile one\n * can ask for an hour. Whenever the wait comes from the server, declare the policy's `maxBackoffMs` (the runner caps\n * every wait at it) or run under a deadline (the runner stops a series whose wait would outlast it).\n *\n * Refused when built — by the field's name and the shape it needs, NEVER the value it was given (a field can hold a\n * secret): a `TypeError` for a wrong type (`'100'` included), a `RangeError` for a number out of range. The rules: a\n * `baseDelayMs` that is a finite number >= 0, a `multiplier` >= 1, a `maxDelayMs` >= `baseDelayMs`, a `jitter` of the\n * three names, a `random` or a reader that is a function, an `inner` that is a function or a finite number >= 0.\n *\n * A DRAW IS NOT TRUSTED BLINDLY: a `random()` that answers anything but a number in [0, 1] — or throws — makes that\n * wait the ceiling `c`, the longest the schedule allows. Never 0: a broken source cannot make every jittered retry\n * fire at once. The default source is `Math.random`, looked up at each draw (so a spy installed later takes effect).\n */\n\nimport type { RetryPolicy } from './types.js';\n\n/** How much of an exponential wait is random: none of it, half of it, or all of it. */\nexport type BackoffJitter = 'none' | 'equal' | 'full';\n\n/** The schedule {@link exponentialBackoff} builds a `RetryPolicy.backoffMs` function from. */\nexport interface BackoffSpec {\n  /** The ceiling of the first wait (after attempt 1), in milliseconds — a finite number >= 0. */\n  readonly baseDelayMs: number;\n  /** How much each ceiling grows over the one before — a finite number >= 1. Default `2`. */\n  readonly multiplier?: number;\n  /**\n   * The most a ceiling may grow to, in milliseconds — a finite number >= `baseDelayMs`. It caps the SCHEDULE before\n   * the jitter is drawn, so waits at the cap still spread (`'equal'` between `maxDelayMs / 2` and `maxDelayMs`). It\n   * is not `RetryPolicy.maxBackoffMs`, which caps every wait after the draw, a stated one included. Absent: the\n   * ceiling grows until it saturates at `Number.MAX_SAFE_INTEGER`.\n   */\n  readonly maxDelayMs?: number;\n  /** How much of each wait is random. Default `'none'`: the wait IS the ceiling. */\n  readonly jitter?: BackoffJitter;\n  /**\n   * The jitter's random source, answering in [0, 1]. Default `Math.random`, looked up at each draw; a fixed one makes a\n   * test exact. A draw outside [0, 1] (or a throw) makes that wait the ceiling — never 0.\n   */\n  readonly random?: () => number;\n}\n\n/** A `RetryPolicy.backoffMs` function: the wait in milliseconds after failed attempt `attempt` (1-based). */\nexport type BackoffFunction = (attempt: number, error?: unknown) => number;\n\n/** Reads the wait an error states (a parsed `Retry-After`), in milliseconds, or `undefined` when it states none. */\nexport type StatedWaitReader = (error: unknown) => number | undefined;\n\nconst JITTERS: readonly BackoffJitter[] = ['none', 'equal', 'full'];\n\n/** Where a ceiling saturates: a wait is never `Infinity` and never `NaN`. */\nconst MAX_WAIT_MS = Number.MAX_SAFE_INTEGER;\n\n/** The default random source: `Math.random`, looked up at each draw — so a spy installed after building takes effect. */\nconst drawMathRandom = (): number => Math.random();\n\n/**\n * A `RetryPolicy.backoffMs` function for an exponential schedule: the wait after failed attempt `n` is drawn under the\n * ceiling `min(maxDelayMs, baseDelayMs × multiplier^(n − 1))` by the declared jitter — the schedule is capped BEFORE\n * the draw, so it keeps its spread. The policy's `maxBackoffMs` still caps every wait after it.\n *\n * @example\n * ```ts\n * .retry({ attempts: 6, backoffMs: exponentialBackoff({ baseDelayMs: 200, maxDelayMs: 2_000, jitter: 'equal' }), maxBackoffMs: 5_000 })\n * ```\n */\nexport function exponentialBackoff(spec: BackoffSpec): BackoffFunction {\n  const { baseDelayMs, multiplier, maxDelayMs, jitter, random } = readSpec(spec);\n  return (attempt: number): number => {\n    const ceiling = ceilingOf(baseDelayMs, multiplier, maxDelayMs, stepOf(attempt));\n    if (jitter === 'none') return ceiling;\n    const r = draw(random);\n    // An untrusted draw waits the ceiling — never 0, so a broken source cannot fire every jittered retry at once.\n    if (r === undefined) return ceiling;\n    // Never above the ceiling, rounding included: halving a subnormal ceiling is inexact and can round up.\n    return jitter === 'equal' ? Math.min(ceiling, ceiling / 2 + (r * ceiling) / 2) : r * ceiling;\n  };\n}\n\n/**\n * A `RetryPolicy.backoffMs` function that honours a wait the outside system stated: when `readStatedWaitMs(error)`\n * answers a finite number >= 0, that is the wait; otherwise `inner` (a backoff function, or a fixed number of\n * milliseconds) decides. A reader that throws or answers anything else states nothing — a malformed `Retry-After`\n * falls back to the schedule rather than to a wrong wait. The runner still caps the stated wait at `maxBackoffMs` and\n * stops the series when it would outlast the run's deadline.\n *\n * The outside system chooses this wait, and a broken or hostile one can ask for an hour: whenever the wait comes from\n * the server, declare the policy's `maxBackoffMs` (or run under a deadline).\n *\n * @example\n * ```ts\n * const retryAfterMs = (error: unknown) => (error as { retryAfterMs?: number }).retryAfterMs;\n * .retry({ attempts: 3, backoffMs: statedWaitFirst(retryAfterMs, exponentialBackoff({ baseDelayMs: 100 })), maxBackoffMs: 10_000 })\n * ```\n */\nexport function statedWaitFirst(\n  readStatedWaitMs: StatedWaitReader,\n  inner: NonNullable<RetryPolicy['backoffMs']>,\n): BackoffFunction {\n  if (typeof readStatedWaitMs !== 'function') {\n    throw new TypeError('statedWaitFirst: readStatedWaitMs must be a function');\n  }\n  if (typeof inner !== 'function') {\n    checkNumber('statedWaitFirst: inner', inner, 0, 'a backoff function or a finite number >= 0');\n  }\n  return (attempt: number, error?: unknown): number => {\n    const stated = statedWaitOf(readStatedWaitMs, error);\n    if (stated !== undefined) return stated;\n    return typeof inner === 'function' ? inner(attempt, error) : inner;\n  };\n}\n\n/** Each field read ONCE, then checked: what is checked is exactly what the function keeps (a getter cannot differ). */\nfunction readSpec(spec: BackoffSpec): Required<BackoffSpec> {\n  if (spec === null || typeof spec !== 'object') {\n    throw new TypeError(\n      'exponentialBackoff: the spec must be an object ({ baseDelayMs, multiplier?, maxDelayMs?, jitter?, random? })',\n    );\n  }\n  const { baseDelayMs, multiplier = 2, maxDelayMs, jitter = 'none', random = drawMathRandom } = spec;\n  checkNumber('exponentialBackoff: baseDelayMs', baseDelayMs, 0, 'a finite number >= 0');\n  checkNumber('exponentialBackoff: multiplier', multiplier, 1, 'a finite number >= 1');\n  // At least the base: a cap below it would make every wait the cap — a fixed schedule written as an exponential one.\n  if (maxDelayMs !== undefined) {\n    checkNumber('exponentialBackoff: maxDelayMs', maxDelayMs, baseDelayMs, 'a finite number >= baseDelayMs');\n  }\n  const jitterRule = \"exponentialBackoff: jitter must be 'none', 'equal' or 'full'\";\n  if (typeof jitter !== 'string') throw new TypeError(jitterRule);\n  if (!JITTERS.includes(jitter)) throw new RangeError(jitterRule);\n  if (typeof random !== 'function') {\n    throw new TypeError('exponentialBackoff: random must be a function answering a number in [0, 1]');\n  }\n  return { baseDelayMs, multiplier, maxDelayMs: maxDelayMs ?? MAX_WAIT_MS, jitter, random };\n}\n\n/**\n * A finite number >= `min`, or the error that names `field` and the shape it needs — never the value it was given (a\n * field can hold a secret): a `TypeError` for a non-number, a `RangeError` for a number out of range.\n */\nfunction checkNumber(field: string, value: unknown, min: number, rule: string): void {\n  if (typeof value !== 'number') throw new TypeError(`${field} must be ${rule}`);\n  if (!Number.isFinite(value) || value < min) throw new RangeError(`${field} must be ${rule}`);\n}\n\n/** The attempt as a schedule step: its whole part, at least 1 (anything that is not a finite number reads as 1). */\nfunction stepOf(attempt: unknown): number {\n  return typeof attempt === 'number' && Number.isFinite(attempt) && attempt >= 1 ? Math.floor(attempt) : 1;\n}\n\n/**\n * `min(maxDelayMs, baseDelayMs × multiplier^(step − 1))` — the schedule's cap, applied BEFORE any jitter is drawn\n * (`maxDelayMs` is {@link MAX_WAIT_MS} when none was declared, so the ceiling saturates rather than overflows).\n */\nfunction ceilingOf(baseDelayMs: number, multiplier: number, maxDelayMs: number, step: number): number {\n  if (baseDelayMs === 0) return 0;\n  const ceiling = baseDelayMs * multiplier ** (step - 1);\n  return ceiling < maxDelayMs ? ceiling : maxDelayMs;\n}\n\n/**\n * One draw from the random source: a number in [0, 1] (`-0` reads as `0`), or `undefined` when the source answers\n * anything else or throws — an untrusted draw, which the caller turns into the ceiling.\n */\nfunction draw(random: () => number): number | undefined {\n  let r: unknown;\n  try {\n    r = random();\n  } catch {\n    return undefined;\n  }\n  if (typeof r !== 'number' || !(r >= 0 && r <= 1)) return undefined;\n  return r === 0 ? 0 : r;\n}\n\n/** The wait `error` states, read once — none when the reader throws or answers anything but a finite number >= 0. */\nfunction statedWaitOf(read: StatedWaitReader, error: unknown): number | undefined {\n  let value: unknown;\n  try {\n    value = read(error);\n  } catch {\n    return undefined;\n  }\n  return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;\n}\n"]}

package/dist/esm/lib/attempt/deadline.d.ts

@@ -24,11 +24,6 @@ export declare function isDeadlineReason(reason: unknown): boolean;
 export declare function isCancelled(signal: AbortSignal | undefined): boolean;
 /** A deadline as the engine reads one: a finite number (epoch ms), else none. */
 export declare function readDeadline(value: unknown): number | undefined;
-/**
- * `setTimeout` for any delay: a delay past the host's limit is waited in chunks, so a 30-day deadline does not fire
- * in a millisecond. Returns the one call that cancels it.
- */
-export declare function setLongTimeout(fn: () => void, ms: number): () => void;
 /** Whether `value` is an AbortSignal (structurally — a signal from another realm counts). */
 export declare function isAbortSignal(value: unknown): value is AbortSignal;
 /** A signal that aborts at a deadline (or with its input), and the one call that releases both. */