footprintjs 10.1.0 → 10.2.1

package/CLAUDE.md

@@ -83,6 +83,19 @@ loop: Phase 6 sees isLoopRef → ContinuationResolver.resolveTarget (:107): id-m
 end: onRunEnd (throw → onRunFailed; pause → neither) → deferred terminalFlush → getSnapshot() = {sharedState (LIVE view; dev-mode frozen clone), initialState (the fold base), commitLog (detached+frozen; a bundle or base holding what freezing cannot seal — a Date, Map, buffer … — is served as a copy of its open paths, `runner/snapshot.ts · servedSnapshot` → `foottrace · serveRecord`, 9.44.2), executionTree, subflowResults (dual-keyed; `globalContext` = the subflow's LIVE heap, or under `redact: true` its own nested mirror — 9.20.0, `servedSubflowResults`), recorders}.
 
 ## Backtracking
+
+**Native terminal failure (#109):** `errors/terminalFailure.ts` is an L0 leaf owning `TerminalFailureContext` and
+the private `NativeFailureState`. `StageContext` holds one slot; successors and exclusive decider branches share
+it, parallel children and subflows isolate it. A private per-frame identity is stamped before any recorder event;
+failure capture never reads the mutable event traversal context. Native attempts provide the exact final category through an internal
+callback whose private category is fixed before serving/observers; ordinary stage-error paths classify before
+commit observers. `commitStageWrites` captures the exact escaping commit error even during error/pause handling,
+without changing that path's existing diagnostics or events. Only the explicitly selected
+escaping child/subflow rejection transfers ownership. `onRunFailed.failure` and `executor.getFailureContext()` serve
+a frozen category plus optional native run/runtime-stage identity, never payload or raw exceptions. Unknown setup,
+cancellation, retention, checkpoint or sink failures borrow no stage. Each leg resets after the re-entrancy guard;
+settlement seals the slot and releases private raw identity. No record/history traversal or stored schema change.
+
 Seven mechanisms, no state rollback anywhere: **M1** TransactionBuffer staging + net-change commit — commit-on-error by design, explicitly NOT rollback (TransactionBuffer.ts:13-18; error path commits then rethrows). **M2** Pause/Resume checkpointing — the only resume-from-prior-point; TWO raise shapes, ONE checkpoint: `addPausableFunction` (resume runs `resumeFn`) and `interrupt(scope, payload)` (resume RE-RUNS THE STAGE FUNCTION FROM ITS TOP — stages are atomic; the answer returns out of the `interrupt()` call via a WeakMap keyed by the scope), discriminated by `checkpoint.pausedBy`; checkpoint is one detached structuredClone; resume rebuilds the cursor from pausedStageId+subflowPath and re-enters ONCE (9.28.0, `ResumeEntry`): the paused stage's stand-in (its own node, fn swapped — so a dispatcher that interrupted still dispatches) is only where the resumed traversal STARTS — never in a node map — and each subflow on the path takes its capture + entry point on its FIRST entry (a 2+-deep pause re-enters each outer subflow AT the next mount; no pre-mount stage re-runs); every level's entry carries its DISPATCHER's continuation, read from the chart (a branch/fork-child mount hands back to its parent's `next`/join at the parent's level); parallel siblings that paused together wait in `checkpoint.pendingPauses` and are asked in turn, the join after the last; the rest of the run walks the REAL chart (a loop back to the paused stage reaches it and it pauses again; later entries run the inputMapper). Not rebuilt (pinned in test/lib/pause/resume-known-limitations.test.ts): lazy-subflow / parallelForEach-branch pauses (refused), a parallel-branch STAGE's namespace on resume, fan-out error containment for the resumed child. **M3** commit-log replay (EventLog.materialise, commitValueAt — required under delta mode). **M4** loopTo re-entry — forward execution over accumulated state, bounded by maxIterations + dynamicNextHops. **M5** causalChain backward slicing (read-only analysis; honesty flags for untracked reads; `edgeAttribution: 'per-write'` refines edges via `TraceEntry.readKeys` when the writeProvenance dial recorded them — worklist, subset-of-ceiling safe). **M6 (query layer)** foottrace's slice/ — variable-first triage: sliceForKey + append-fold element provenance + the ONLY safe serializations (sliceToJSON/formatSlice — never JSON.stringify a slice root). **M7 (read-time cursor)** foottrace's time-travel/ — `timeTravel(snapshot)` walks stops over the finished log with `stateAt()` folding M3's replay at each one (base = `RuntimeSnapshot.initialState`, which now travels with the log); it is a READER, never a second live cursor, and `drill(mount)` opens a separate cursor over a subflow's own isolated log. 9.18.0: `timeTravel([paused, resumed])` chains a cross-executor M2 resume into ONE axis — the resumed leg's `initialState` (= the state at the pause) restarts the fold, commit indices stay run-local (`Stop.sourceIdx` names the leg), and the chain is refused unless the never-reset execution counter is monotonic across legs. Deep dive + step tables: [.claude/rules/backtracking.md](.claude/rules/backtracking.md).
 
 ## Invariants (assumed, not stated)
@@ -135,3 +148,8 @@ idempotent across sibling hooks, exact run IDs isolate shared recorders, and a r
 A shared recorder's auto-clear preserves already-emitted rows for active/paused ownership; completed projections
 reset normally. Keep omission accounting while active ownership exists, never rebuild an apparently complete empty
 run header after deleting its attempts. All retained row/identity maps remain bounded.
+
+
+## Stage attention (C2)
+
+`memory/StageAttention` owns attention bookkeeping; `StageContext` holds one helper and delegates at retained attempt/summary/error boundaries. Import shared `Attention` from Foottrace root without a FootPrint re-export. Use the official `buildAttemptId`/`parseAttemptId` codec, preserving owning execution and call identity; no `attempts:N` alias. Reset on a new execution and preserve across retries. Snapshot export only copies bounded marks (32 marks, 16 refs each), never scans attempts or classifies arbitrary diagnostic values. Missing proof stays `not-collected`; observed SDK suggestions are not actual retry decisions, and physical helper stops are not logical exhaustion. The engine must not inspect attached recorders or infer their quality. Quality rows remain recorder-owned and may be adapted at read time. No implicit outlier detector or new crash-safe attention format. Guide: `docs/guides/attention.md`; runnable example: `examples/runtime-features/attention/01-stage-attention.ts`.

package/dist/esm/index.d.ts

@@ -48,6 +48,8 @@ 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
  *

package/dist/esm/index.js

@@ -95,4 +95,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":"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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// ============================================================================\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"]}
+//# 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/category.d.ts

@@ -20,8 +20,10 @@
  *      `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.
+ * A status is a NUMBER (`status` or `statusCode`); a numeric string is not read as one. Metadata uses only
+ * own/inherited data within 32 prototype objects; a caller accessor shadows farther data without executing.
+ * The captured platform DOMException name getter is the sole accessor exception and brand-checks its receiver.
+ * Inspection failures (a hostile Proxy) are `'unknown'`, never a second throw from an error path.
  */
 import type { AttemptCategory, AttemptOutcome } from './types.js';
 /**
@@ -29,3 +31,9 @@ import type { AttemptCategory, AttemptOutcome } from './types.js';
  * `'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;

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

@@ -20,11 +20,14 @@
  *      `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.
+ * A status is a NUMBER (`status` or `statusCode`); a numeric string is not read as one. Metadata uses only
+ * own/inherited data within 32 prototype objects; a caller accessor shadows farther data without executing.
+ * The captured platform DOMException name getter is the sole accessor exception and brand-checks its receiver.
+ * Inspection failures (a hostile Proxy) are `'unknown'`, never a second throw from an error path.
  */
 import { InputValidationError } from '../schema/errors.js';
-import { AttemptTimeoutError } from './errors.js';
+import { errorField } from './errorField.js';
+import { AttemptTimeoutError, UnknownEffectError } from './errors.js';
 /** Socket-level codes a transport failure carries (Node's `errno` names). */
 const NETWORK_CODES = new Set([
     'ECONNRESET',
@@ -56,6 +59,30 @@ export function errorCategory(error, outcome = 'failed') {
         return 'unknown';
     }
 }
+/**
+ * @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 function terminalCategory(error, known) {
+    try {
+        if (error instanceof UnknownEffectError)
+            return 'unknown';
+        // CJS and ESM have distinct constructors. A declared own DATA name may
+        // only reduce certainty to unknown; never execute an error's name getter
+        // or promote its physical cause to a known outcome across module copies.
+        if (error !== null && (typeof error === 'object' || typeof error === 'function')) {
+            const name = Object.getOwnPropertyDescriptor(error, 'name');
+            if (name && Object.prototype.hasOwnProperty.call(name, 'value') && name.value === 'UnknownEffectError') {
+                return 'unknown';
+            }
+        }
+    }
+    catch {
+        return known ?? 'unknown';
+    }
+    return known ?? errorCategory(error);
+}
 function categoryOf(error) {
     if (error instanceof AttemptTimeoutError)
         return 'timeout';
@@ -63,7 +90,7 @@ function categoryOf(error) {
         return 'unknown';
     const fields = error;
     const status = numberField(fields, 'status') ?? numberField(fields, 'statusCode');
-    const declaresRetryAfter = isWait(fields.retryAfterMs) || isWait(fields.retryAfterSeconds);
+    const declaresRetryAfter = isWait(errorField(fields, 'retryAfterMs')) || isWait(errorField(fields, 'retryAfterSeconds'));
     if (status === 429 || declaresRetryAfter)
         return 'rate-limited';
     if (status !== undefined && status >= 500 && status <= 599)
@@ -72,11 +99,12 @@ function categoryOf(error) {
         return 'auth';
     if (status !== undefined && status >= 400 && status <= 499)
         return 'permanent';
-    if (fields.retryable === false)
+    if (errorField(fields, 'retryable') === false)
         return 'permanent';
     if (error instanceof InputValidationError)
         return 'permanent';
-    const name = typeof fields.name === 'string' ? fields.name : undefined;
+    const declaredName = errorField(fields, 'name');
+    const name = typeof declaredName === 'string' ? declaredName : undefined;
     if (name !== undefined && VALIDATION_NAMES.has(name))
         return 'permanent';
     if (status === undefined && isTransportFailure(fields, name))
@@ -84,24 +112,27 @@ function categoryOf(error) {
     return 'unknown';
 }
 function isTransportFailure(fields, name) {
-    if (hasNetworkCode(fields.code))
+    if (hasNetworkCode(errorField(fields, 'code')))
         return true;
-    const cause = fields.cause;
-    if (cause !== null && typeof cause === 'object' && hasNetworkCode(cause.code)) {
+    const cause = errorField(fields, 'cause');
+    if (cause !== null && typeof cause === 'object' && hasNetworkCode(errorField(cause, 'code'))) {
         return true;
     }
     if (name !== undefined && TRANSPORT_ABORT_NAMES.has(name))
         return true;
-    return fields instanceof TypeError && typeof fields.message === 'string' && FETCH_FAILURE.test(fields.message);
+    if (!(fields instanceof TypeError))
+        return false;
+    const message = errorField(fields, 'message');
+    return typeof message === 'string' && FETCH_FAILURE.test(message);
 }
 function hasNetworkCode(code) {
     return typeof code === 'string' && NETWORK_CODES.has(code);
 }
 function numberField(fields, key) {
-    const value = fields[key];
+    const value = errorField(fields, key);
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 }
 function isWait(value) {
     return typeof value === 'number' && Number.isFinite(value) && value >= 0;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category.js","sourceRoot":"","sources":["../../../../src/lib/attempt/category.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/category.ts — `errorCategory`, the ONE failure classifier (design §3.9).\n *\n * Seven fixed values, so every recorder — the narrative, the metric layer, an agent's own — breaks failures down\n * the same way; a recorder never invents a category of its own. Borrowed from agentfootprint's\n * `classifyRetryReason` and widened, so its decorators adopt this one rather than keep theirs.\n *\n * Category is EVIDENCE, never policy: the default `retryOn` retries every category. A chart that wants \"never\n * retry a permanent failure\" says so: `retryOn: (e) => errorCategory(e) !== 'permanent'`.\n *\n * Precedence — what the failure LOOKED like wins over what it declares:\n *   1. the attempt's own timer (outcome `'timeout'`, or our `AttemptTimeoutError`)  → timeout\n *   2. the run's signal ended it (outcome `'aborted'`)                              → unknown\n *   3. status 429, or a declared `retryAfterMs` / `retryAfterSeconds`               → rate-limited\n *   4. status 5xx                                                                   → server\n *   5. status 401 / 403                                                             → auth\n *   6. any other 4xx                                                                → permanent\n *   7. `retryable: false`, or a validation error                                    → permanent\n *   8. a transport failure (a socket code on the error or its cause, a fetch\n *      `TypeError`, an `AbortError` / `TimeoutError` that was not the run's)        → network\n *   9. anything else                                                                → unknown\n *\n * A status is a NUMBER (`status` or `statusCode`); a numeric string is not read as one. Total: a value whose\n * reads throw (a hostile Proxy) is `'unknown'`, never a second throw from an error path.\n */\n\nimport { InputValidationError } from '../schema/errors.js';\nimport { AttemptTimeoutError } from './errors.js';\nimport type { AttemptCategory, AttemptOutcome } from './types.js';\n\n/** Socket-level codes a transport failure carries (Node's `errno` names). */\nconst NETWORK_CODES: ReadonlySet<string> = new Set([\n  'ECONNRESET',\n  'ECONNREFUSED',\n  'ENOTFOUND',\n  'ETIMEDOUT',\n  'EAI_AGAIN',\n  'EPIPE',\n]);\n\n/** The messages runtimes give a `fetch` that never reached the server (Node, Chromium, Firefox, Safari). */\nconst FETCH_FAILURE = /^(fetch failed|failed to fetch|networkerror when attempting to fetch resource\\.?|load failed)$/i;\n\n/** Error names that say a validation failed — retrying the same input cannot succeed. */\nconst VALIDATION_NAMES: ReadonlySet<string> = new Set(['ValidationError', 'ZodError', 'InputValidationError']);\n\n/** Error names of an abort or a timeout that some OTHER signal raised (the run's own ends as outcome `'aborted'`). */\nconst TRANSPORT_ABORT_NAMES: ReadonlySet<string> = new Set(['AbortError', 'TimeoutError']);\n\n/**\n * The category of an attempt's failure. `outcome` is how the attempt ended (default `'failed'`): it decides\n * `'timeout'` (the attempt's own timer) and `'unknown'` (the run's signal) before the error is read.\n */\nexport function errorCategory(error: unknown, outcome: AttemptOutcome = 'failed'): AttemptCategory {\n  if (outcome === 'timeout') return 'timeout';\n  if (outcome === 'aborted') return 'unknown';\n  try {\n    return categoryOf(error);\n  } catch {\n    return 'unknown';\n  }\n}\n\nfunction categoryOf(error: unknown): AttemptCategory {\n  if (error instanceof AttemptTimeoutError) return 'timeout';\n  if (error === null || (typeof error !== 'object' && typeof error !== 'function')) return 'unknown';\n  const fields = error as Record<string, unknown>;\n\n  const status = numberField(fields, 'status') ?? numberField(fields, 'statusCode');\n  const declaresRetryAfter = isWait(fields.retryAfterMs) || isWait(fields.retryAfterSeconds);\n  if (status === 429 || declaresRetryAfter) return 'rate-limited';\n  if (status !== undefined && status >= 500 && status <= 599) return 'server';\n  if (status === 401 || status === 403) return 'auth';\n  if (status !== undefined && status >= 400 && status <= 499) return 'permanent';\n\n  if (fields.retryable === false) return 'permanent';\n  if (error instanceof InputValidationError) return 'permanent';\n  const name = typeof fields.name === 'string' ? fields.name : undefined;\n  if (name !== undefined && VALIDATION_NAMES.has(name)) return 'permanent';\n\n  if (status === undefined && isTransportFailure(fields, name)) return 'network';\n  return 'unknown';\n}\n\nfunction isTransportFailure(fields: Record<string, unknown>, name: string | undefined): boolean {\n  if (hasNetworkCode(fields.code)) return true;\n  const cause = fields.cause;\n  if (cause !== null && typeof cause === 'object' && hasNetworkCode((cause as Record<string, unknown>).code)) {\n    return true;\n  }\n  if (name !== undefined && TRANSPORT_ABORT_NAMES.has(name)) return true;\n  return fields instanceof TypeError && typeof fields.message === 'string' && FETCH_FAILURE.test(fields.message);\n}\n\nfunction hasNetworkCode(code: unknown): boolean {\n  return typeof code === 'string' && NETWORK_CODES.has(code);\n}\n\nfunction numberField(fields: Record<string, unknown>, key: 'status' | 'statusCode'): number | undefined {\n  const value = fields[key];\n  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;\n}\n\nfunction isWait(value: unknown): boolean {\n  return typeof value === 'number' && Number.isFinite(value) && value >= 0;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category.js","sourceRoot":"","sources":["../../../../src/lib/attempt/category.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/category.ts — `errorCategory`, the ONE failure classifier (design §3.9).\n *\n * Seven fixed values, so every recorder — the narrative, the metric layer, an agent's own — breaks failures down\n * the same way; a recorder never invents a category of its own. Borrowed from agentfootprint's\n * `classifyRetryReason` and widened, so its decorators adopt this one rather than keep theirs.\n *\n * Category is EVIDENCE, never policy: the default `retryOn` retries every category. A chart that wants \"never\n * retry a permanent failure\" says so: `retryOn: (e) => errorCategory(e) !== 'permanent'`.\n *\n * Precedence — what the failure LOOKED like wins over what it declares:\n *   1. the attempt's own timer (outcome `'timeout'`, or our `AttemptTimeoutError`)  → timeout\n *   2. the run's signal ended it (outcome `'aborted'`)                              → unknown\n *   3. status 429, or a declared `retryAfterMs` / `retryAfterSeconds`               → rate-limited\n *   4. status 5xx                                                                   → server\n *   5. status 401 / 403                                                             → auth\n *   6. any other 4xx                                                                → permanent\n *   7. `retryable: false`, or a validation error                                    → permanent\n *   8. a transport failure (a socket code on the error or its cause, a fetch\n *      `TypeError`, an `AbortError` / `TimeoutError` that was not the run's)        → network\n *   9. anything else                                                                → unknown\n *\n * A status is a NUMBER (`status` or `statusCode`); a numeric string is not read as one. Metadata uses only\n * own/inherited data within 32 prototype objects; a caller accessor shadows farther data without executing.\n * The captured platform DOMException name getter is the sole accessor exception and brand-checks its receiver.\n * Inspection failures (a hostile Proxy) are `'unknown'`, never a second throw from an error path.\n */\n\nimport { InputValidationError } from '../schema/errors.js';\nimport { errorField } from './errorField.js';\nimport { AttemptTimeoutError, UnknownEffectError } from './errors.js';\nimport type { AttemptCategory, AttemptOutcome } from './types.js';\n\n/** Socket-level codes a transport failure carries (Node's `errno` names). */\nconst NETWORK_CODES: ReadonlySet<string> = new Set([\n  'ECONNRESET',\n  'ECONNREFUSED',\n  'ENOTFOUND',\n  'ETIMEDOUT',\n  'EAI_AGAIN',\n  'EPIPE',\n]);\n\n/** The messages runtimes give a `fetch` that never reached the server (Node, Chromium, Firefox, Safari). */\nconst FETCH_FAILURE = /^(fetch failed|failed to fetch|networkerror when attempting to fetch resource\\.?|load failed)$/i;\n\n/** Error names that say a validation failed — retrying the same input cannot succeed. */\nconst VALIDATION_NAMES: ReadonlySet<string> = new Set(['ValidationError', 'ZodError', 'InputValidationError']);\n\n/** Error names of an abort or a timeout that some OTHER signal raised (the run's own ends as outcome `'aborted'`). */\nconst TRANSPORT_ABORT_NAMES: ReadonlySet<string> = new Set(['AbortError', 'TimeoutError']);\n\n/**\n * The category of an attempt's failure. `outcome` is how the attempt ended (default `'failed'`): it decides\n * `'timeout'` (the attempt's own timer) and `'unknown'` (the run's signal) before the error is read.\n */\nexport function errorCategory(error: unknown, outcome: AttemptOutcome = 'failed'): AttemptCategory {\n  if (outcome === 'timeout') return 'timeout';\n  if (outcome === 'aborted') return 'unknown';\n  try {\n    return categoryOf(error);\n  } catch {\n    return 'unknown';\n  }\n}\n\n/**\n * @internal Terminal ownership preserves a producer's known category. An\n * unresolved effect is unknown, never the category of its physical cause.\n * This does not rewrite historical attempt categories or re-read a known one.\n */\nexport function terminalCategory(error: unknown, known?: AttemptCategory): AttemptCategory {\n  try {\n    if (error instanceof UnknownEffectError) return 'unknown';\n    // CJS and ESM have distinct constructors. A declared own DATA name may\n    // only reduce certainty to unknown; never execute an error's name getter\n    // or promote its physical cause to a known outcome across module copies.\n    if (error !== null && (typeof error === 'object' || typeof error === 'function')) {\n      const name = Object.getOwnPropertyDescriptor(error, 'name');\n      if (name && Object.prototype.hasOwnProperty.call(name, 'value') && name.value === 'UnknownEffectError') {\n        return 'unknown';\n      }\n    }\n  } catch {\n    return known ?? 'unknown';\n  }\n  return known ?? errorCategory(error);\n}\n\nfunction categoryOf(error: unknown): AttemptCategory {\n  if (error instanceof AttemptTimeoutError) return 'timeout';\n  if (error === null || (typeof error !== 'object' && typeof error !== 'function')) return 'unknown';\n  const fields = error as Record<string, unknown>;\n\n  const status = numberField(fields, 'status') ?? numberField(fields, 'statusCode');\n  const declaresRetryAfter =\n    isWait(errorField(fields, 'retryAfterMs')) || isWait(errorField(fields, 'retryAfterSeconds'));\n  if (status === 429 || declaresRetryAfter) return 'rate-limited';\n  if (status !== undefined && status >= 500 && status <= 599) return 'server';\n  if (status === 401 || status === 403) return 'auth';\n  if (status !== undefined && status >= 400 && status <= 499) return 'permanent';\n\n  if (errorField(fields, 'retryable') === false) return 'permanent';\n  if (error instanceof InputValidationError) return 'permanent';\n  const declaredName = errorField(fields, 'name');\n  const name = typeof declaredName === 'string' ? declaredName : undefined;\n  if (name !== undefined && VALIDATION_NAMES.has(name)) return 'permanent';\n\n  if (status === undefined && isTransportFailure(fields, name)) return 'network';\n  return 'unknown';\n}\n\nfunction isTransportFailure(fields: Record<string, unknown>, name: string | undefined): boolean {\n  if (hasNetworkCode(errorField(fields, 'code'))) return true;\n  const cause = errorField(fields, 'cause');\n  if (cause !== null && typeof cause === 'object' && hasNetworkCode(errorField(cause, 'code'))) {\n    return true;\n  }\n  if (name !== undefined && TRANSPORT_ABORT_NAMES.has(name)) return true;\n  if (!(fields instanceof TypeError)) return false;\n  const message = errorField(fields, 'message');\n  return typeof message === 'string' && FETCH_FAILURE.test(message);\n}\n\nfunction hasNetworkCode(code: unknown): boolean {\n  return typeof code === 'string' && NETWORK_CODES.has(code);\n}\n\nfunction numberField(fields: Record<string, unknown>, key: 'status' | 'statusCode'): number | undefined {\n  const value = errorField(fields, key);\n  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;\n}\n\nfunction isWait(value: unknown): boolean {\n  return typeof value === 'number' && Number.isFinite(value) && value >= 0;\n}\n"]}

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

@@ -0,0 +1,2 @@
+/** Caller accessors shadow farther data. Only the captured platform name getter may run. */
+export declare function errorField(value: unknown, key: string): unknown;

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

@@ -0,0 +1,32 @@
+/** A finite inheritance allowance for ordinary Error subclasses and metadata. */
+const MAX_ERROR_FIELD_DEPTH = 32;
+// Capture the platform intrinsic once; never call a later caller replacement.
+const DOM_EXCEPTION_PROTOTYPE = typeof DOMException === 'function' ? DOMException.prototype : undefined;
+const DOM_EXCEPTION_NAME = DOM_EXCEPTION_PROTOTYPE
+    ? Object.getOwnPropertyDescriptor(DOM_EXCEPTION_PROTOTYPE, 'name')?.get
+    : undefined;
+const APPLY_INTRINSIC = Reflect.apply;
+/** Caller accessors shadow farther data. Only the captured platform name getter may run. */
+export function errorField(value, key) {
+    if (value === null || (typeof value !== 'object' && typeof value !== 'function'))
+        return undefined;
+    let current = value;
+    for (let depth = 0; current !== null && depth < MAX_ERROR_FIELD_DEPTH; depth++) {
+        const property = Object.getOwnPropertyDescriptor(current, key);
+        if (property) {
+            if (Object.prototype.hasOwnProperty.call(property, 'value'))
+                return property.value;
+            if (key === 'name' &&
+                current === DOM_EXCEPTION_PROTOTYPE &&
+                DOM_EXCEPTION_NAME &&
+                property.get === DOM_EXCEPTION_NAME) {
+                // The intrinsic brand-checks its receiver, refusing forged prototypes and proxies.
+                return APPLY_INTRINSIC(DOM_EXCEPTION_NAME, value, []);
+            }
+            return undefined;
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -63,7 +63,7 @@
  */
 import type { StructuredErrorInfo } from '../errors/errorInfo.js';
 import type { EffectTarget } from './effect.js';
-import type { AttemptContext, AttemptKind, AttemptRecord, AttemptSummary, ObservedAttempt, RetryPolicy } from './types.js';
+import type { AttemptCategory, AttemptContext, AttemptKind, AttemptRecord, AttemptSummary, ObservedAttempt, RetryPolicy } from './types.js';
 /** What a series reports, and the engine's between-attempt step. Every member is optional. */
 export interface AttemptRunOptions {
     /** The series every record names — for a stage attempt, its execution's `runtimeStageId`. */
@@ -95,6 +95,8 @@ export interface AttemptRunOptions {
     readonly onRetry?: (attempt: number, of: number, delayMs: number, structuredError: StructuredErrorInfo) => void;
     /** The series ended: called once, before the last `onAttempt` (or after a wait the run's signal cut). */
     readonly onEnd?: (summary: AttemptSummary) => void;
+    /** @internal Native owner only: the exact escaping value and category, before its stage serves the error. */
+    readonly onFailure?: (error: unknown, category: AttemptCategory) => void;
     /** `retryOn` threw — the attempt is treated as declined; the engine logs the throw here. */
     readonly onRetryOnThrew?: (thrown: unknown) => void;
     /**