footprintjs 10.0.1 → 10.2.0

package/dist/esm/index.d.ts

@@ -29,6 +29,15 @@ export { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/in
 export type { BranchChart, ParallelForEachConfig, RetryPolicy } from './lib/builder/index.js';
 /** @category Quick Start — build-time observer (twin of FlowRecorder) */
 export type { StructureDeciderCompleteEvent, StructureEdgeAddedEvent, StructureEdgeKind, StructureLoopEdgeAddedEvent, StructureRecorder, StructureStageAddedEvent, StructureStageTaggedEvent, StructureSubflowMountedEvent, } from './lib/builder/index.js';
+/**
+ * @category Time Budget
+ *
+ * `timeBudget(chart)` — the slowest a chart can take, from its declared retry policies (`attempts × timeoutMs` plus
+ * the waits, summed along the slowest path), and every stage that makes a path unbounded, by name. `.budget(ms)`
+ * declares the caller's contract; `build()` refuses a chart that cannot keep it. Also `chart.timeBudget()`.
+ */
+export type { BudgetAssumptions, BudgetStep, TimeBudgetOptions, TimeBudgetReport, UnboundedReason, UnboundedStage, } from './lib/budget/index.js';
+export { timeBudget } from './lib/budget/index.js';
 /** @category Quick Start */
 export type { TypedStageFunction } from './lib/builder/typedFlowChart.js';
 /** @category Quick Start */
@@ -39,10 +48,59 @@ export { narrative } from './recorders.js';
 export type { DecideRule, DecisionEvidence, DecisionResult, DefaultBranch, FilterOps, RuleEvidence, SelectionEvidence, SelectionResult, WhenClause, WhereFilter, } from './lib/decide/index.js';
 /** @category Decision Branching */
 export { decide, select } from './lib/decide/index.js';
+/** @category Errors */
+export type { TerminalFailureContext } from './lib/errors/terminalFailure.js';
+/**
+ * @category Attempts
+ *
+ * One `AttemptRecord` per attempt of a stage with a declared `retry` policy, a `timeoutMs`, or a run deadline —
+ * timing, outcome, failure category, and the retry-or-stop decision as `DecisionEvidence` — on the stage's
+ * execution-tree node (`StageSnapshot.attempts` / `attemptSummary`) and on `FlowRecorder.onAttempt`.
+ * A call a stage makes through `scope.$call` is recorded the same way (kind `'call'`), and so is an SDK's own retry
+ * an adapter reports through `observed()` (`ObservedAttempt`, kind `'observed'`). `AttemptContext` is what
+ * `scope.$attempt()` returns, and what a call's function gets (the attempt's signal, the time left, `observed`);
+ * `LateWrite` is a write (or call) an ended attempt tried (`StageSnapshot.lateWrites`). A stage that changes an
+ * outside system declares it (`StageTouches`, `.touches()`), and a call does (`CallOptions`): every attempt then
+ * carries its `AttemptEffect`, and the key rule is handed an `IdempotencyKeyContext` once per execution.
+ */
+export type { AttemptCategory, AttemptContext, AttemptEffect, AttemptError, AttemptInputs, AttemptKind, AttemptNext, AttemptOptions, AttemptOutcome, AttemptReason, AttemptRecord, AttemptSummary, CallOptions, IdempotencyKeyContext, LateWrite, ObservedAttempt, StageTouches, UnknownEffectInit, } from './lib/attempt/index.js';
+/**
+ * @category Attempts
+ *
+ * An attempt by name (`series` + `attempt`) and per-outcome counts — what recorder rows hold of attempts.
+ */
+export type { AttemptOutcomeCounts, AttemptRef } from './lib/recorder/attemptSeries.js';
+/**
+ * @category Attempts
+ *
+ * `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.
+ */
+export { attempt, AttemptTimeoutError, errorCategory, retryRules, UnknownEffectError } from './lib/attempt/index.js';
+/**
+ * @category Correlation
+ *
+ * The run's correlation (10.1): `env.traceparent` (W3C, parsed strictly) or `env.traceId` + `env.operationId`
+ * become ONE frozen `RunCorrelation` per run — on `getSnapshot().correlation`, every flow event's
+ * `traversalContext.correlation` and every scope and emit event's `correlation`. `parseTraceparent` /
+ * `formatTraceparent` are the W3C codec; a refused header throws `TraceparentError` with a named `reason`.
+ */
+export type { ParsedTraceparent, RunCorrelation, TraceparentFields, TraceparentRefusal } from './lib/attempt/index.js';
+export { formatTraceparent, parseTraceparent, TraceparentError } from './lib/attempt/index.js';
 /** @category Run */
 export type { RunResult } from './lib/runner/index.js';
 /** @category Run */
 export type { FlowChartExecutorOptions } from './lib/runner/index.js';
+/**
+ * The crash-safe record (10.1): the executor's `sink` option, its accounting on `getSnapshot().sink`,
+ * `executor.flushRecord()`'s result, and the error a run with `onFailure: 'fail'` rejects with. The port
+ * (`RecordSink`, `memorySink`) is `foottrace/write`'s; the file adapter is `footprintjs/sinks`.
+ * @category Run
+ */
+export type { RecordFlushResult, RecordSinkFailureMode, RecordSinkFlushMode, RecordSinkOption, RecordSinkOptions, RecordSinkStats, } from './lib/runner/index.js';
+/** @category Run */
+export { RecordSinkError } from './lib/runner/index.js';
 /**
  * The four observability dials `FlowChartExecutorOptions` inherits.
  * @category Run
@@ -101,7 +159,7 @@ export { hasEmitRecorderMethods, hasFlowRecorderMethods, hasRecorderMethods, isF
  */
 export type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';
 /** @category Observe — Flow */
-export type { FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowRunEvent, FlowRunFailedEvent, FlowSelectedEvent, FlowStageEvent, FlowStageRetryEvent, FlowSubflowEvent, FlowSubflowRegisteredEvent, FlowThrottledEvent, ResumeLink, TraversalContext, } from './lib/engine/index.js';
+export type { FlowAttemptEvent, FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowRunEvent, FlowRunFailedEvent, FlowSelectedEvent, FlowStageEvent, FlowStageRetryEvent, FlowSubflowEvent, FlowSubflowRegisteredEvent, FlowThrottledEvent, ResumeLink, TraversalContext, } from './lib/engine/index.js';
 /** @category Observe — Flow */
 export type { CombinedNarrativeEntry } from './lib/engine/index.js';
 /**
@@ -114,7 +172,7 @@ export type { NarrativeFormatter } from './lib/engine/index.js';
 /** @category Observe — Flow */
 export { NarrativeFlowRecorder } from './lib/engine/index.js';
 /** @category Observe — Flow */
-export type { ManifestEntry } from './lib/engine/index.js';
+export type { ManifestAttemptRow, ManifestEntry } from './lib/engine/index.js';
 /** @category Observe — Flow */
 export { ManifestFlowRecorder } from './lib/engine/index.js';
 /** @category Observe — Flow */
@@ -223,4 +281,6 @@ export { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';
  * `enableDevMode` for the full list and usage example.
  */
 export { disableDevMode, enableDevMode, isDevMode } from './lib/devMode.js';
+export type { RetryLoopCall, RetryLoopDecision, RetryLoopIdentity } from './lib/attempt/retryLoopTypes.js';
+export type { RetryLoopContext, RetryLoopOptions, RetryLoopState } from './lib/builder/retryLoop.js';
 export { stringifySnapshot } from './lib/runner/stringifySnapshot.js';

package/dist/esm/index.js

@@ -17,10 +17,22 @@
  */
 /** @category Quick Start */
 export { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';
+export { timeBudget } from './lib/budget/index.js';
 /** @category Quick Start */
 export { narrative } from './recorders.js';
 /** @category Decision Branching */
 export { decide, select } from './lib/decide/index.js';
+/**
+ * @category Attempts
+ *
+ * `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.
+ */
+export { attempt, AttemptTimeoutError, errorCategory, retryRules, UnknownEffectError } from './lib/attempt/index.js';
+export { formatTraceparent, parseTraceparent, TraceparentError } from './lib/attempt/index.js';
+/** @category Run */
+export { RecordSinkError } from './lib/runner/index.js';
 /** @category Run */
 export { FlowChartExecutor } from './lib/runner/index.js';
 /** @category Run */
@@ -82,10 +94,5 @@ export { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';
  * `enableDevMode` for the full list and usage example.
  */
 export { disableDevMode, enableDevMode, isDevMode } from './lib/devMode.js';
-// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in
-// `footprintjs/zod` entry — keeping zod out of the core load path (it is an
-// optional peer). Import them from 'footprintjs/zod'.
-// A run's record as JSON without the engine's recursion limit (9.26.0): the
-// same bytes JSON.stringify emits, for a deep `next` chain it cannot encode.
 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;AA6BxF,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAoB3C,mCAAmC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAkBvD,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;AAiDjC,+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;AAE5E,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD;AACtD,4EAA4E;AAC5E,6EAA6E;AAC7E,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/** @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// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } 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  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 { 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 { 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.\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 { 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 { stringifySnapshot } from './lib/runner/stringifySnapshot.js';\n"]}

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

@@ -0,0 +1,19 @@
+/**
+ * attempt/anySignal.ts — one signal that aborts when ANY of its inputs does.
+ *
+ * The attempt runner gives each attempt its own signal: the run's signal (cancellation, the deadline) composed
+ * with the attempt's own time cap. `AbortSignal.any` does this natively, but not in every browser this library
+ * runs in (design §3.1), so the composition is ours: small, and leak-free — every listener it adds to an input
+ * is removed the moment it aborts or is disposed, so a long run of attempts leaves nothing on the run's signal.
+ */
+/** A composed signal and the one call that releases its inputs. */
+export interface ComposedSignal {
+    readonly signal: AbortSignal;
+    /** Remove every listener this composition added to its inputs. Idempotent. */
+    dispose(): void;
+}
+/**
+ * Compose `inputs` (undefined entries ignored): the result aborts with the reason of the first input to abort,
+ * or at once with the reason of an input that already has. Call `dispose()` when the attempt ends.
+ */
+export declare function anySignal(inputs: ReadonlyArray<AbortSignal | undefined>): ComposedSignal;

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

@@ -0,0 +1,39 @@
+/**
+ * attempt/anySignal.ts — one signal that aborts when ANY of its inputs does.
+ *
+ * The attempt runner gives each attempt its own signal: the run's signal (cancellation, the deadline) composed
+ * with the attempt's own time cap. `AbortSignal.any` does this natively, but not in every browser this library
+ * runs in (design §3.1), so the composition is ours: small, and leak-free — every listener it adds to an input
+ * is removed the moment it aborts or is disposed, so a long run of attempts leaves nothing on the run's signal.
+ */
+/**
+ * Compose `inputs` (undefined entries ignored): the result aborts with the reason of the first input to abort,
+ * or at once with the reason of an input that already has. Call `dispose()` when the attempt ends.
+ */
+export function anySignal(inputs) {
+    const controller = new AbortController();
+    const signals = inputs.filter((s) => s !== undefined);
+    const already = signals.find((s) => s.aborted);
+    if (already) {
+        controller.abort(already.reason);
+        return { signal: controller.signal, dispose: () => undefined };
+    }
+    let listening = true;
+    const listeners = signals.map((source) => {
+        const onAbort = () => {
+            release();
+            controller.abort(source.reason);
+        };
+        source.addEventListener('abort', onAbort);
+        return { source, onAbort };
+    });
+    function release() {
+        if (!listening)
+            return;
+        listening = false;
+        for (const { source, onAbort } of listeners)
+            source.removeEventListener('abort', onAbort);
+    }
+    return { signal: controller.signal, dispose: release };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,88 @@
+/**
+ * attempt/call.ts — a call made INSIDE a stage attempt: `scope.$call(target, fn, policy?)` (design §3.6, §3.8,
+ * packet P2).
+ *
+ * The same loop as a stage's retry (`runAttempts`, law 1), kind `'call'`, its `target` on every record — and a
+ * record even for a single call (`attempts: 1`): timing and outcome evidence with no retry. Its series is the
+ * call level of foottrace's attempt-id grammar ({@link callSeries}).
+ *
+ * THE LAW — a call lives within the attempt that made it. The host (the stage's scope) hands it that attempt's
+ * signal and its end as the call's deadline, so the call is capped by the time its stage attempt has left, and is
+ * cut when the stage attempt is cut (a time limit, so `'timeout'`; a cancellation, so `'aborted'`); and an `ended`
+ * signal that aborts when the attempt is over however it ended (it returned, threw, or its frame committed), so a
+ * call never outlives it. Following the P1b fence:
+ *   - the record of a call attempt cut BY its stage attempt's own abort lands — the cut is evidence;
+ *   - any other record that arrives once the stage attempt is over is REFUSED: noted by name (`host.refused`), never
+ *     kept, never fired; the call stops (its in-flight attempt is cut, a wait ends) and no further attempt of an
+ *     outside call starts — and the library-made rejection of such an orphan never surfaces as an unhandled one;
+ *   - a call never starts under a signal already aborted, nor past its deadline while that signal is still due (a
+ *     busy event loop fires timers late): no attempt, no record — the host's signal is its ONE deadline source.
+ * What the call's function does after its attempt ended cannot be trapped — it should RETURN its answer, not write
+ * the stage's scope (the scope's own fence still refuses a write from an ended stage attempt).
+ *
+ * A LEAF of the engine (L5): the host is a port, so nothing here names the scope.
+ */
+import type { StructuredErrorInfo } from '../errors/errorInfo.js';
+import type { EffectTarget } from './effect.js';
+import type { AttemptContext, AttemptRecord, ObservedAttempt, RetryPolicy } from './types.js';
+/**
+ * The series of the `ordinal`-th call (1-based) made during attempt `stageAttempt` of the stage execution
+ * `runtimeStageId`: `<runtimeStageId>@<n>.<k>` — so the id of the call's attempt `m` is `<series>@<m>`, foottrace's
+ * `buildAttemptId(runtimeStageId, n, { ordinal: k, attempt: m })` (design §3.4). Written here, in this one place,
+ * until the engine adopts foottrace 1.1.0's codec (P6); the bytes are the grammar's.
+ */
+export declare function callSeries(runtimeStageId: string, stageAttempt: number, ordinal: number): string;
+/** What the attempt that makes a call gives it — the scope implements it. */
+export interface CallHost {
+    /**
+     * The call's series ({@link callSeries}) — asked once, only when the call starts, so a call refused before it
+     * starts takes no ordinal and leaves no gap.
+     */
+    openSeries(): string;
+    /**
+     * The stage attempt's signal: the run's cancellation, the run's deadline and the attempt's own cap. When given, it
+     * is the call's ONE deadline source — it must abort at {@link deadline}, with a time-limit reason
+     * (`deadline.ts · markTimeLimit` / `deadlineReason`); the call arms no timer of its own.
+     */
+    readonly signal?: AbortSignal;
+    /**
+     * When the stage attempt must end, epoch ms — the call's deadline, capping each attempt by the time left. Absent
+     * for an uncapped attempt. Without a {@link signal}, the call arms the one timer that ends it here.
+     */
+    readonly deadline?: number;
+    /** The clock (default `Date.now`). */
+    readonly now?: () => number;
+    /**
+     * Aborts when the attempt that makes the call is over — however it ended — and when its frame commits: the call
+     * stops (its in-flight attempt is cut, a wait ends, no attempt follows) and its records are refused. No call
+     * outlives the attempt that made it.
+     */
+    readonly ended?: AbortSignal;
+    /**
+     * May a record of the call land on the stage now? `cut`: the call attempt was ended BY the stage attempt's own
+     * end, so its record is the evidence of that cut.
+     */
+    admits(cut: boolean): boolean;
+    /** The served form of an attempt's error — the run's redaction rule. */
+    serve(error: unknown): StructuredErrorInfo;
+    /** A record that may land: onto the stage, and the run's `onAttempt`. */
+    report(record: AttemptRecord, structuredError: StructuredErrorInfo | undefined): void;
+    /** A record that may not — the call outlived the attempt that made it. A name is noted; nothing is kept. */
+    refused(): void;
+    /**
+     * The outside system the call touches and its key (P3) — admitted at the call (`effect.ts · callTouches`), the
+     * recorded key served under the run's rule. Every record then carries its `effect`, and a series ended without an answer after an attempt of unknown
+     * effect rejects with `UnknownEffectError`.
+     */
+    readonly effect?: EffectTarget;
+    /** An observed report made through the call's own attempt context (`ended`: that call attempt was over). */
+    observe(report: ObservedAttempt, at: {
+        readonly attempt: number;
+        readonly ended: boolean;
+    }): void;
+}
+/**
+ * Run `fn` as the call `target` under `policy` (already admitted — `policy.ts · admitCallPolicy`) for `host`.
+ * Resolves with the answer, or rejects with the last attempt's own error.
+ */
+export declare function runCall<T>(target: string, fn: (attempt: AttemptContext) => Promise<T> | T, policy: RetryPolicy, host: CallHost): Promise<T>;

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

@@ -0,0 +1,129 @@
+/**
+ * attempt/call.ts — a call made INSIDE a stage attempt: `scope.$call(target, fn, policy?)` (design §3.6, §3.8,
+ * packet P2).
+ *
+ * The same loop as a stage's retry (`runAttempts`, law 1), kind `'call'`, its `target` on every record — and a
+ * record even for a single call (`attempts: 1`): timing and outcome evidence with no retry. Its series is the
+ * call level of foottrace's attempt-id grammar ({@link callSeries}).
+ *
+ * THE LAW — a call lives within the attempt that made it. The host (the stage's scope) hands it that attempt's
+ * signal and its end as the call's deadline, so the call is capped by the time its stage attempt has left, and is
+ * cut when the stage attempt is cut (a time limit, so `'timeout'`; a cancellation, so `'aborted'`); and an `ended`
+ * signal that aborts when the attempt is over however it ended (it returned, threw, or its frame committed), so a
+ * call never outlives it. Following the P1b fence:
+ *   - the record of a call attempt cut BY its stage attempt's own abort lands — the cut is evidence;
+ *   - any other record that arrives once the stage attempt is over is REFUSED: noted by name (`host.refused`), never
+ *     kept, never fired; the call stops (its in-flight attempt is cut, a wait ends) and no further attempt of an
+ *     outside call starts — and the library-made rejection of such an orphan never surfaces as an unhandled one;
+ *   - a call never starts under a signal already aborted, nor past its deadline while that signal is still due (a
+ *     busy event loop fires timers late): no attempt, no record — the host's signal is its ONE deadline source.
+ * What the call's function does after its attempt ended cannot be trapped — it should RETURN its answer, not write
+ * the stage's scope (the scope's own fence still refuses a write from an ended stage attempt).
+ *
+ * A LEAF of the engine (L5): the host is a port, so nothing here names the scope.
+ */
+import { anySignal } from './anySignal.js';
+import { armDeadline } from './deadline.js';
+import { runAttempts } from './runner.js';
+/**
+ * The series of the `ordinal`-th call (1-based) made during attempt `stageAttempt` of the stage execution
+ * `runtimeStageId`: `<runtimeStageId>@<n>.<k>` — so the id of the call's attempt `m` is `<series>@<m>`, foottrace's
+ * `buildAttemptId(runtimeStageId, n, { ordinal: k, attempt: m })` (design §3.4). Written here, in this one place,
+ * until the engine adopts foottrace 1.1.0's codec (P6); the bytes are the grammar's.
+ */
+export function callSeries(runtimeStageId, stageAttempt, ordinal) {
+    return `${runtimeStageId}@${stageAttempt}.${ordinal}`;
+}
+/**
+ * Run `fn` as the call `target` under `policy` (already admitted — `policy.ts · admitCallPolicy`) for `host`.
+ * Resolves with the answer, or rejects with the last attempt's own error.
+ */
+export function runCall(target, fn, policy, host) {
+    const hostSignal = host.signal;
+    const now = host.now ?? Date.now;
+    // Started under an aborted signal, or after the attempt that makes it ended: no attempt, no record.
+    for (const signal of [hostSignal, host.ended])
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+    const stop = new AbortController();
+    // ONE deadline source. A host's signal aborts at the host's deadline (its attempt's cap, or the run's deadline),
+    // so a second timer for the same instant could only race it — and, firing first, end the call with a reason of
+    // its own and fail the stage instead of timing it out. A host with a deadline and no signal gets the one timer.
+    const own = hostSignal === undefined
+        ? armDeadline(undefined, host.deadline, lateCallMessage(target, undefined, 'ran out of time'), now)
+        : undefined;
+    const composed = anySignal([hostSignal, host.ended, own?.signal, stop.signal]);
+    // An orphan — a call still running when the attempt that made it ended — is stopped by the library, so its
+    // rejection must not surface as an unhandled one; whoever awaits it still gets it.
+    let result;
+    const quiet = () => {
+        result?.catch(() => undefined);
+    };
+    host.ended?.addEventListener('abort', quiet, { once: true });
+    const release = () => {
+        host.ended?.removeEventListener('abort', quiet);
+        own?.dispose();
+        composed.dispose();
+    };
+    if (composed.signal.aborted) {
+        release();
+        return Promise.reject(composed.signal.reason);
+    }
+    // Past the deadline while its signal is still due (a busy event loop fires timers late): nothing is sent — the
+    // call ends, with no record, when that signal aborts.
+    if (host.deadline !== undefined && now() >= host.deadline) {
+        result = new Promise((_resolve, reject) => {
+            composed.signal.addEventListener('abort', () => {
+                release();
+                reject(composed.signal.reason);
+            }, { once: true });
+        });
+        return result;
+    }
+    const seriesName = host.openSeries();
+    /** Call attempts ended BY the stage attempt's end — their records are the evidence of the cut. */
+    const cut = new Set();
+    const ended = () => new Error(lateCallMessage(target, seriesName, 'cannot continue'));
+    const series = runAttempts((_attempt, context) => {
+        // The attempt that made this call is over: no further attempt of an outside call starts.
+        if (!host.admits(false)) {
+            const reason = ended();
+            stop.abort(reason);
+            throw reason;
+        }
+        return fn(context);
+    }, policy, {
+        series: seriesName,
+        kind: 'call',
+        target,
+        ...(host.effect !== undefined && { effect: host.effect }),
+        signal: composed.signal,
+        ...(host.deadline !== undefined && { deadline: host.deadline }),
+        now,
+        serve: (error) => host.serve(error),
+        // Synchronous at the abort: the stage attempt's signal aborting is what cut this call attempt.
+        onAbandon: (attempt) => {
+            if (hostSignal?.aborted)
+                cut.add(attempt);
+        },
+        onAttempt: (record, structuredError) => {
+            if (host.admits(cut.has(record.attempt))) {
+                host.report(record, structuredError);
+                return;
+            }
+            host.refused();
+            // Nothing follows a refused record: a wait ends now and the series stops `aborted`.
+            if (!stop.signal.aborted)
+                stop.abort(ended());
+        },
+        observe: (report, at) => host.observe(report, at),
+    });
+    result = series.finally(release);
+    return result;
+}
+/** Why a call stopped or could not go on — its target and series are names; no value is in the message. */
+function lateCallMessage(target, series, what) {
+    return (`[footprint] $call "${target}"${series === undefined ? '' : ` (${series})`} ${what}: the attempt that made this ` +
+        'call has ended — no further attempt of it starts, and nothing it records lands on the stage.');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"call.js","sourceRoot":"","sources":["../../../../src/lib/attempt/call.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/call.ts — a call made INSIDE a stage attempt: `scope.$call(target, fn, policy?)` (design §3.6, §3.8,\n * packet P2).\n *\n * The same loop as a stage's retry (`runAttempts`, law 1), kind `'call'`, its `target` on every record — and a\n * record even for a single call (`attempts: 1`): timing and outcome evidence with no retry. Its series is the\n * call level of foottrace's attempt-id grammar ({@link callSeries}).\n *\n * THE LAW — a call lives within the attempt that made it. The host (the stage's scope) hands it that attempt's\n * signal and its end as the call's deadline, so the call is capped by the time its stage attempt has left, and is\n * cut when the stage attempt is cut (a time limit, so `'timeout'`; a cancellation, so `'aborted'`); and an `ended`\n * signal that aborts when the attempt is over however it ended (it returned, threw, or its frame committed), so a\n * call never outlives it. Following the P1b fence:\n *   - the record of a call attempt cut BY its stage attempt's own abort lands — the cut is evidence;\n *   - any other record that arrives once the stage attempt is over is REFUSED: noted by name (`host.refused`), never\n *     kept, never fired; the call stops (its in-flight attempt is cut, a wait ends) and no further attempt of an\n *     outside call starts — and the library-made rejection of such an orphan never surfaces as an unhandled one;\n *   - a call never starts under a signal already aborted, nor past its deadline while that signal is still due (a\n *     busy event loop fires timers late): no attempt, no record — the host's signal is its ONE deadline source.\n * What the call's function does after its attempt ended cannot be trapped — it should RETURN its answer, not write\n * the stage's scope (the scope's own fence still refuses a write from an ended stage attempt).\n *\n * A LEAF of the engine (L5): the host is a port, so nothing here names the scope.\n */\n\nimport type { StructuredErrorInfo } from '../errors/errorInfo.js';\nimport { anySignal } from './anySignal.js';\nimport { armDeadline } from './deadline.js';\nimport type { EffectTarget } from './effect.js';\nimport { runAttempts } from './runner.js';\nimport type { AttemptContext, AttemptRecord, ObservedAttempt, RetryPolicy } from './types.js';\n\n/**\n * The series of the `ordinal`-th call (1-based) made during attempt `stageAttempt` of the stage execution\n * `runtimeStageId`: `<runtimeStageId>@<n>.<k>` — so the id of the call's attempt `m` is `<series>@<m>`, foottrace's\n * `buildAttemptId(runtimeStageId, n, { ordinal: k, attempt: m })` (design §3.4). Written here, in this one place,\n * until the engine adopts foottrace 1.1.0's codec (P6); the bytes are the grammar's.\n */\nexport function callSeries(runtimeStageId: string, stageAttempt: number, ordinal: number): string {\n  return `${runtimeStageId}@${stageAttempt}.${ordinal}`;\n}\n\n/** What the attempt that makes a call gives it — the scope implements it. */\nexport interface CallHost {\n  /**\n   * The call's series ({@link callSeries}) — asked once, only when the call starts, so a call refused before it\n   * starts takes no ordinal and leaves no gap.\n   */\n  openSeries(): string;\n  /**\n   * The stage attempt's signal: the run's cancellation, the run's deadline and the attempt's own cap. When given, it\n   * is the call's ONE deadline source — it must abort at {@link deadline}, with a time-limit reason\n   * (`deadline.ts · markTimeLimit` / `deadlineReason`); the call arms no timer of its own.\n   */\n  readonly signal?: AbortSignal;\n  /**\n   * When the stage attempt must end, epoch ms — the call's deadline, capping each attempt by the time left. Absent\n   * for an uncapped attempt. Without a {@link signal}, the call arms the one timer that ends it here.\n   */\n  readonly deadline?: number;\n  /** The clock (default `Date.now`). */\n  readonly now?: () => number;\n  /**\n   * Aborts when the attempt that makes the call is over — however it ended — and when its frame commits: the call\n   * stops (its in-flight attempt is cut, a wait ends, no attempt follows) and its records are refused. No call\n   * outlives the attempt that made it.\n   */\n  readonly ended?: AbortSignal;\n  /**\n   * May a record of the call land on the stage now? `cut`: the call attempt was ended BY the stage attempt's own\n   * end, so its record is the evidence of that cut.\n   */\n  admits(cut: boolean): boolean;\n  /** The served form of an attempt's error — the run's redaction rule. */\n  serve(error: unknown): StructuredErrorInfo;\n  /** A record that may land: onto the stage, and the run's `onAttempt`. */\n  report(record: AttemptRecord, structuredError: StructuredErrorInfo | undefined): void;\n  /** A record that may not — the call outlived the attempt that made it. A name is noted; nothing is kept. */\n  refused(): void;\n  /**\n   * The outside system the call touches and its key (P3) — admitted at the call (`effect.ts · callTouches`), the\n   * recorded key served under the run's rule. Every record then carries its `effect`, and a series ended without an answer after an attempt of unknown\n   * effect rejects with `UnknownEffectError`.\n   */\n  readonly effect?: EffectTarget;\n  /** An observed report made through the call's own attempt context (`ended`: that call attempt was over). */\n  observe(report: ObservedAttempt, at: { readonly attempt: number; readonly ended: boolean }): void;\n}\n\n/**\n * Run `fn` as the call `target` under `policy` (already admitted — `policy.ts · admitCallPolicy`) for `host`.\n * Resolves with the answer, or rejects with the last attempt's own error.\n */\nexport function runCall<T>(\n  target: string,\n  fn: (attempt: AttemptContext) => Promise<T> | T,\n  policy: RetryPolicy,\n  host: CallHost,\n): Promise<T> {\n  const hostSignal = host.signal;\n  const now = host.now ?? Date.now;\n  // Started under an aborted signal, or after the attempt that makes it ended: no attempt, no record.\n  for (const signal of [hostSignal, host.ended]) if (signal?.aborted) return Promise.reject(signal.reason);\n  const stop = new AbortController();\n  // ONE deadline source. A host's signal aborts at the host's deadline (its attempt's cap, or the run's deadline),\n  // so a second timer for the same instant could only race it — and, firing first, end the call with a reason of\n  // its own and fail the stage instead of timing it out. A host with a deadline and no signal gets the one timer.\n  const own =\n    hostSignal === undefined\n      ? armDeadline(undefined, host.deadline, lateCallMessage(target, undefined, 'ran out of time'), now)\n      : undefined;\n  const composed = anySignal([hostSignal, host.ended, own?.signal, stop.signal]);\n  // An orphan — a call still running when the attempt that made it ended — is stopped by the library, so its\n  // rejection must not surface as an unhandled one; whoever awaits it still gets it.\n  let result: Promise<T> | undefined;\n  const quiet = () => {\n    result?.catch(() => undefined);\n  };\n  host.ended?.addEventListener('abort', quiet, { once: true });\n  const release = () => {\n    host.ended?.removeEventListener('abort', quiet);\n    own?.dispose();\n    composed.dispose();\n  };\n  if (composed.signal.aborted) {\n    release();\n    return Promise.reject(composed.signal.reason);\n  }\n  // Past the deadline while its signal is still due (a busy event loop fires timers late): nothing is sent — the\n  // call ends, with no record, when that signal aborts.\n  if (host.deadline !== undefined && now() >= host.deadline) {\n    result = new Promise<T>((_resolve, reject) => {\n      composed.signal.addEventListener(\n        'abort',\n        () => {\n          release();\n          reject(composed.signal.reason);\n        },\n        { once: true },\n      );\n    });\n    return result;\n  }\n\n  const seriesName = host.openSeries();\n  /** Call attempts ended BY the stage attempt's end — their records are the evidence of the cut. */\n  const cut = new Set<number>();\n  const ended = () => new Error(lateCallMessage(target, seriesName, 'cannot continue'));\n  const series = runAttempts<T>(\n    (_attempt, context) => {\n      // The attempt that made this call is over: no further attempt of an outside call starts.\n      if (!host.admits(false)) {\n        const reason = ended();\n        stop.abort(reason);\n        throw reason;\n      }\n      return fn(context);\n    },\n    policy,\n    {\n      series: seriesName,\n      kind: 'call',\n      target,\n      ...(host.effect !== undefined && { effect: host.effect }),\n      signal: composed.signal,\n      ...(host.deadline !== undefined && { deadline: host.deadline }),\n      now,\n      serve: (error) => host.serve(error),\n      // Synchronous at the abort: the stage attempt's signal aborting is what cut this call attempt.\n      onAbandon: (attempt) => {\n        if (hostSignal?.aborted) cut.add(attempt);\n      },\n      onAttempt: (record, structuredError) => {\n        if (host.admits(cut.has(record.attempt))) {\n          host.report(record, structuredError);\n          return;\n        }\n        host.refused();\n        // Nothing follows a refused record: a wait ends now and the series stops `aborted`.\n        if (!stop.signal.aborted) stop.abort(ended());\n      },\n      observe: (report, at) => host.observe(report, at),\n    },\n  );\n  result = series.finally(release);\n  return result;\n}\n\n/** Why a call stopped or could not go on — its target and series are names; no value is in the message. */\nfunction lateCallMessage(target: string, series: string | undefined, what: string): string {\n  return (\n    `[footprint] $call \"${target}\"${series === undefined ? '' : ` (${series})`} ${what}: the attempt that made this ` +\n    'call has ended — no further attempt of it starts, and nothing it records lands on the stage.'\n  );\n}\n"]}

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

@@ -0,0 +1,37 @@
+/**
+ * attempt/category.ts — `errorCategory`, the ONE failure classifier (design §3.9).
+ *
+ * Seven fixed values, so every recorder — the narrative, the metric layer, an agent's own — breaks failures down
+ * the same way; a recorder never invents a category of its own. Borrowed from agentfootprint's
+ * `classifyRetryReason` and widened, so its decorators adopt this one rather than keep theirs.
+ *
+ * Category is EVIDENCE, never policy: the default `retryOn` retries every category. A chart that wants "never
+ * retry a permanent failure" says so: `retryOn: (e) => errorCategory(e) !== 'permanent'`.
+ *
+ * Precedence — what the failure LOOKED like wins over what it declares:
+ *   1. the attempt's own timer (outcome `'timeout'`, or our `AttemptTimeoutError`)  → timeout
+ *   2. the run's signal ended it (outcome `'aborted'`)                              → unknown
+ *   3. status 429, or a declared `retryAfterMs` / `retryAfterSeconds`               → rate-limited
+ *   4. status 5xx                                                                   → server
+ *   5. status 401 / 403                                                             → auth
+ *   6. any other 4xx                                                                → permanent
+ *   7. `retryable: false`, or a validation error                                    → permanent
+ *   8. a transport failure (a socket code on the error or its cause, a fetch
+ *      `TypeError`, an `AbortError` / `TimeoutError` that was not the run's)        → network
+ *   9. anything else                                                                → unknown
+ *
+ * A status is a NUMBER (`status` or `statusCode`); a numeric string is not read as one. Total: a value whose
+ * reads throw (a hostile Proxy) is `'unknown'`, never a second throw from an error path.
+ */
+import type { AttemptCategory, AttemptOutcome } from './types.js';
+/**
+ * The category of an attempt's failure. `outcome` is how the attempt ended (default `'failed'`): it decides
+ * `'timeout'` (the attempt's own timer) and `'unknown'` (the run's signal) before the error is read.
+ */
+export declare function errorCategory(error: unknown, outcome?: AttemptOutcome): AttemptCategory;
+/**
+ * @internal Terminal ownership preserves a producer's known category. An
+ * unresolved effect is unknown, never the category of its physical cause.
+ * This does not rewrite historical attempt categories or re-read a known one.
+ */
+export declare function terminalCategory(error: unknown, known?: AttemptCategory): AttemptCategory;