footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/filter/evaluator.js

@@ -0,0 +1,135 @@
+/**
+ * filter/evaluator -- Prisma-style filter evaluator for decision rules.
+ *
+ * Pure function. Takes a WhereFilter, a value getter, and a redaction checker.
+ * Evaluates each condition, records the result, returns matched/conditions.
+ *
+ * All keys in the filter are ANDed (all must match for the rule to match).
+ * Decoupled from ScopeFacade — receives callbacks, not scope.
+ *
+ * A LEAF module of its own (P2, 10.1): `decide()` (decide/) and the attempt rule table (attempt/decision.ts) share
+ * this one law, and neither may reach the other's dependencies through it. In decide/ it made `attempt/` reach
+ * `scope/` (decide.ts imports the scope runtime), so a `scope → attempt` edge — `scope.$call` — closed a module
+ * cycle.
+ */
+import { summarizeValue } from '../capture/summarize.js';
+import { isDevMode } from '../devMode.js';
+import { SCOPE_PLACEHOLDER } from '../memory/redaction.js';
+const OPERATOR_HANDLERS = {
+    eq: (a, t) => a === t,
+    ne: (a, t) => a !== t,
+    gt: (a, t) => a > t,
+    gte: (a, t) => a >= t,
+    lt: (a, t) => a < t,
+    lte: (a, t) => a <= t,
+    in: (a, t) => {
+        if (!Array.isArray(t))
+            return false;
+        if (t.length > MAX_IN_ARRAY_SIZE) {
+            throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);
+        }
+        return t.includes(a);
+    },
+    notIn: (a, t) => {
+        if (!Array.isArray(t))
+            return true; // not in a non-array = vacuously true
+        if (t.length > MAX_IN_ARRAY_SIZE) {
+            throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);
+        }
+        return !t.includes(a);
+    },
+};
+// -- Security: prototype pollution denylist ----------------------------------
+const DENIED_KEYS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+    'toString',
+    'valueOf',
+    'hasOwnProperty',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    '__defineGetter__',
+    '__defineSetter__',
+    '__lookupGetter__',
+    '__lookupSetter__',
+]);
+// -- Constants ---------------------------------------------------------------
+const MAX_IN_ARRAY_SIZE = 1000;
+const MAX_VALUE_LEN = 80;
+// -- Evaluator ---------------------------------------------------------------
+/**
+ * Evaluates a Prisma-style filter against scope values.
+ *
+ * ## Empty filter → NO match (anti-vacuous-truth — inverts Prisma/SQL)
+ *
+ * A filter with no evaluable conditions (`{}`, or only denied/non-object
+ * keys) returns `matched: false`. This deliberately INVERTS the Prisma/SQL
+ * intuition where `where: {}` matches everything: in a decision rule, a rule
+ * that asserts nothing should never win a branch — "all zero conditions
+ * passed" is vacuous truth, and silently routing on it would fabricate
+ * decision evidence. Want a catch-all? Use the explicit `defaultBranch`
+ * argument of `decide()` instead of an empty `when`.
+ *
+ * ## Unknown operators → condition fails (+ dev-mode warning)
+ *
+ * An operator outside the supported set (`eq, ne, gt, gte, lt, lte, in,
+ * notIn`) records a failed condition — the rule can never spuriously match
+ * through a typo (`gte` misspelled `gle`). With dev mode enabled
+ * (`enableDevMode()`), a console warning names the unknown operator and key.
+ *
+ * @param getValueFn - Reads a value from scope by key (raw, for comparison)
+ * @param isRedactedFn - Checks if a key is redacted (for evidence display)
+ * @param filter - The WhereFilter to evaluate
+ * @returns { matched, conditions } — matched = all conditions passed
+ */
+export function evaluateFilter(getValueFn, isRedactedFn, filter) {
+    const conditions = [];
+    let allMatched = true;
+    for (const [key, ops] of Object.entries(filter)) {
+        // Security: denied keys cause rule to fail (consistent with unknown operator behavior)
+        if (DENIED_KEYS.has(key)) {
+            allMatched = false;
+            continue;
+        }
+        if (!ops || typeof ops !== 'object')
+            continue;
+        const actual = getValueFn(key);
+        const redacted = isRedactedFn(key);
+        const displayValue = redacted ? SCOPE_PLACEHOLDER : summarizeValue(actual, MAX_VALUE_LEN);
+        // Evaluate each operator in the FilterOps for this key
+        for (const [op, threshold] of Object.entries(ops)) {
+            const handler = OPERATOR_HANDLERS[op];
+            if (!handler) {
+                // Unknown operator: treat as failed condition so rule doesn't spuriously match
+                if (isDevMode()) {
+                    // eslint-disable-next-line no-console
+                    console.warn(`[footprint] decide()/select() filter: unknown operator "${op}" on key "${key}" — ` +
+                        `condition never matches (valid operators: ${Object.keys(OPERATOR_HANDLERS).join(', ')})`);
+                }
+                conditions.push({ key, op, threshold, actualSummary: displayValue, result: false, redacted });
+                allMatched = false;
+                continue;
+            }
+            const result = handler(actual, threshold);
+            conditions.push({
+                key,
+                op,
+                threshold,
+                actualSummary: displayValue,
+                result,
+                redacted,
+            });
+            if (!result)
+                allMatched = false;
+        }
+    }
+    // Empty filter (no evaluable conditions) should NOT match — prevents vacuous
+    // truth. NOTE: this deliberately inverts Prisma/SQL `where: {}` ("match
+    // everything") — see the function JSDoc. Catch-alls belong in decide()'s
+    // explicit defaultBranch, not in an empty rule.
+    if (conditions.length === 0)
+        return { matched: false, conditions };
+    return { matched: allMatched, conditions };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../../src/lib/filter/evaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * filter/evaluator -- Prisma-style filter evaluator for decision rules.\n *\n * Pure function. Takes a WhereFilter, a value getter, and a redaction checker.\n * Evaluates each condition, records the result, returns matched/conditions.\n *\n * All keys in the filter are ANDed (all must match for the rule to match).\n * Decoupled from ScopeFacade — receives callbacks, not scope.\n *\n * A LEAF module of its own (P2, 10.1): `decide()` (decide/) and the attempt rule table (attempt/decision.ts) share\n * this one law, and neither may reach the other's dependencies through it. In decide/ it made `attempt/` reach\n * `scope/` (decide.ts imports the scope runtime), so a `scope → attempt` edge — `scope.$call` — closed a module\n * cycle.\n */\n\nimport { summarizeValue } from '../capture/summarize.js';\nimport type { FilterCondition, WhereFilter } from '../decide/types.js';\nimport { isDevMode } from '../devMode.js';\nimport { SCOPE_PLACEHOLDER } from '../memory/redaction.js';\n\n// -- Operator dispatch table -------------------------------------------------\n\ntype OperatorFn = (actual: unknown, threshold: unknown) => boolean;\n\nconst OPERATOR_HANDLERS: Record<string, OperatorFn> = {\n  eq: (a, t) => a === t,\n  ne: (a, t) => a !== t,\n  gt: (a, t) => (a as number) > (t as number),\n  gte: (a, t) => (a as number) >= (t as number),\n  lt: (a, t) => (a as number) < (t as number),\n  lte: (a, t) => (a as number) <= (t as number),\n  in: (a, t) => {\n    if (!Array.isArray(t)) return false;\n    if (t.length > MAX_IN_ARRAY_SIZE) {\n      throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);\n    }\n    return t.includes(a);\n  },\n  notIn: (a, t) => {\n    if (!Array.isArray(t)) return true; // not in a non-array = vacuously true\n    if (t.length > MAX_IN_ARRAY_SIZE) {\n      throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);\n    }\n    return !t.includes(a);\n  },\n};\n\n// -- Security: prototype pollution denylist ----------------------------------\n\nconst DENIED_KEYS = new Set([\n  '__proto__',\n  'constructor',\n  'prototype',\n  'toString',\n  'valueOf',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  '__defineGetter__',\n  '__defineSetter__',\n  '__lookupGetter__',\n  '__lookupSetter__',\n]);\n\n// -- Constants ---------------------------------------------------------------\n\nconst MAX_IN_ARRAY_SIZE = 1000;\nconst MAX_VALUE_LEN = 80;\n\n// -- Evaluator ---------------------------------------------------------------\n\n/**\n * Evaluates a Prisma-style filter against scope values.\n *\n * ## Empty filter → NO match (anti-vacuous-truth — inverts Prisma/SQL)\n *\n * A filter with no evaluable conditions (`{}`, or only denied/non-object\n * keys) returns `matched: false`. This deliberately INVERTS the Prisma/SQL\n * intuition where `where: {}` matches everything: in a decision rule, a rule\n * that asserts nothing should never win a branch — \"all zero conditions\n * passed\" is vacuous truth, and silently routing on it would fabricate\n * decision evidence. Want a catch-all? Use the explicit `defaultBranch`\n * argument of `decide()` instead of an empty `when`.\n *\n * ## Unknown operators → condition fails (+ dev-mode warning)\n *\n * An operator outside the supported set (`eq, ne, gt, gte, lt, lte, in,\n * notIn`) records a failed condition — the rule can never spuriously match\n * through a typo (`gte` misspelled `gle`). With dev mode enabled\n * (`enableDevMode()`), a console warning names the unknown operator and key.\n *\n * @param getValueFn - Reads a value from scope by key (raw, for comparison)\n * @param isRedactedFn - Checks if a key is redacted (for evidence display)\n * @param filter - The WhereFilter to evaluate\n * @returns { matched, conditions } — matched = all conditions passed\n */\nexport function evaluateFilter<T extends object>(\n  getValueFn: (key: string) => unknown,\n  isRedactedFn: (key: string) => boolean,\n  filter: WhereFilter<T>,\n): { matched: boolean; conditions: FilterCondition[] } {\n  const conditions: FilterCondition[] = [];\n  let allMatched = true;\n\n  for (const [key, ops] of Object.entries(filter)) {\n    // Security: denied keys cause rule to fail (consistent with unknown operator behavior)\n    if (DENIED_KEYS.has(key)) {\n      allMatched = false;\n      continue;\n    }\n    if (!ops || typeof ops !== 'object') continue;\n\n    const actual = getValueFn(key);\n    const redacted = isRedactedFn(key);\n    const displayValue = redacted ? SCOPE_PLACEHOLDER : summarizeValue(actual, MAX_VALUE_LEN);\n\n    // Evaluate each operator in the FilterOps for this key\n    for (const [op, threshold] of Object.entries(ops as Record<string, unknown>)) {\n      const handler = OPERATOR_HANDLERS[op];\n      if (!handler) {\n        // Unknown operator: treat as failed condition so rule doesn't spuriously match\n        if (isDevMode()) {\n          // eslint-disable-next-line no-console\n          console.warn(\n            `[footprint] decide()/select() filter: unknown operator \"${op}\" on key \"${key}\" — ` +\n              `condition never matches (valid operators: ${Object.keys(OPERATOR_HANDLERS).join(', ')})`,\n          );\n        }\n        conditions.push({ key, op, threshold, actualSummary: displayValue, result: false, redacted });\n        allMatched = false;\n        continue;\n      }\n\n      const result = handler(actual, threshold);\n      conditions.push({\n        key,\n        op,\n        threshold,\n        actualSummary: displayValue,\n        result,\n        redacted,\n      });\n\n      if (!result) allMatched = false;\n    }\n  }\n\n  // Empty filter (no evaluable conditions) should NOT match — prevents vacuous\n  // truth. NOTE: this deliberately inverts Prisma/SQL `where: {}` (\"match\n  // everything\") — see the function JSDoc. Catch-alls belong in decide()'s\n  // explicit defaultBranch, not in an empty rule.\n  if (conditions.length === 0) return { matched: false, conditions };\n\n  return { matched: allMatched, conditions };\n}\n"]}

package/dist/esm/lib/ids/idempotencyKey.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ids/idempotencyKey.ts — the ONE format rule for an idempotency key (design §3.3, packet P3). A leaf: the attempt
+ * law (`attempt/effect.ts · admitIdempotencyKey`, a key a stage's rule or a `$call` gives) and the checkpoint decoder
+ * (`pause/record.ts`, a key a paused execution carries to its resume) both ask it, so a key a stored checkpoint
+ * smuggles in is held to the same rule as one the code made.
+ *
+ * 1–255 printable ASCII characters (`\x21`–`\x7e`), no space: a key travels in a request header
+ * (`Idempotency-Key`), so a CR/LF could forge one, and 255 is Stripe's limit, inside every header limit. The
+ * problem names the rule, never the value.
+ */
+/** The longest idempotency key. */
+export declare const MAX_IDEMPOTENCY_KEY_LENGTH = 255;
+/** Why `value` is not an idempotency key, or `undefined` when it is one. */
+export declare function idempotencyKeyProblem(value: unknown): string | undefined;

package/dist/esm/lib/ids/idempotencyKey.js

@@ -0,0 +1,24 @@
+/**
+ * ids/idempotencyKey.ts — the ONE format rule for an idempotency key (design §3.3, packet P3). A leaf: the attempt
+ * law (`attempt/effect.ts · admitIdempotencyKey`, a key a stage's rule or a `$call` gives) and the checkpoint decoder
+ * (`pause/record.ts`, a key a paused execution carries to its resume) both ask it, so a key a stored checkpoint
+ * smuggles in is held to the same rule as one the code made.
+ *
+ * 1–255 printable ASCII characters (`\x21`–`\x7e`), no space: a key travels in a request header
+ * (`Idempotency-Key`), so a CR/LF could forge one, and 255 is Stripe's limit, inside every header limit. The
+ * problem names the rule, never the value.
+ */
+/** The longest idempotency key. */
+export const MAX_IDEMPOTENCY_KEY_LENGTH = 255;
+const KEY_CHARACTERS = /^[\x21-\x7e]+$/;
+/** Why `value` is not an idempotency key, or `undefined` when it is one. */
+export function idempotencyKeyProblem(value) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > MAX_IDEMPOTENCY_KEY_LENGTH) {
+        return `must be a string of 1–${MAX_IDEMPOTENCY_KEY_LENGTH} characters`;
+    }
+    if (!KEY_CHARACTERS.test(value)) {
+        return 'must be printable ASCII with no space or control character — it travels in a request header';
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/memory/StageContext.d.ts

@@ -13,12 +13,28 @@
  */
 import type { CommitPhase, EmitSourcePosition, UntrackedSource } from 'foottrace';
 import type { EventLog, SharedMemory } from 'foottrace/write';
+import type { AttemptContext, AttemptRecord, AttemptSummary, LateWrite } from '../attempt/types.js';
+import type { StructuredErrorInfo } from '../errors/errorInfo.js';
+import { type TerminalFailureContext, NativeFailureState } from '../errors/terminalFailure.js';
 import { type DiagnosticChannel, DiagnosticCollector } from './DiagnosticCollector.js';
 import type { FlowControlType, StageSnapshot } from './frameTypes.js';
 import type { RedactionVerdict } from './redaction.js';
 import { RedactionRule } from './redaction.js';
 import type { RunPolicy } from './runPolicy.js';
+/**
+ * How many call and observed attempt records one stage execution keeps (P2) — a stage that calls in a loop must
+ * not grow the execution tree without bound. The rest are counted (`StageSnapshot.attemptsDropped`) and still
+ * fired on `onAttempt`. A stage's OWN attempt records are never displaced: its policy's ceiling bounds them.
+ */
+export declare const MAX_CALL_RECORDS = 1000;
 export declare class StageContext {
+    #private;
+    /** @internal Ownership of an escaping failure. Shared only by sequential frames, never serialized. */
+    failureState: NativeFailureState;
+    /** @internal The native frame stamp, independent of mutable recorder event context. */
+    get failureIdentity(): NonNullable<TerminalFailureContext['stage']> | undefined;
+    /** @internal Stamped before observers; never inherited by another frame or persisted. */
+    bindFailureIdentity(runId: string, runtimeStageId: string): void;
     /**
      * The record half of this frame (`RecordFrame.ts`, L3, C3): the heap and,
      * when the run keeps them, the redacted mirror and the log; the address;
@@ -138,6 +154,41 @@ export declare class StageContext {
      * stages that never touch an untracked path pay nothing.
      */
     private _untrackedSources?;
+    /**
+     * The attempts of this frame's execution (10.1) — its own under the attempt runner, appended as each attempt ends
+     * (`FlowchartTraverser · executeStage`), and those of the calls it made (P2, {@link reportCallAttempt}) — read
+     * by {@link snapshotSelf}. Append-only
+     * evidence like `debug`: NOT cleared by {@link discardStaged} (the earlier attempts are the point) and never
+     * part of a commit bundle. Lazily allocated: a stage without a policy pays nothing.
+     */
+    private _attempts?;
+    /** The attempt series at a glance, stamped once when it ends. */
+    private _attemptSummary?;
+    /** Facts collected for this execution only; retry discards deliberately keep them. */
+    private _attention?;
+    /**
+     * The attempt now running (P1b) — set by `StageRunner` before the scope is built, so the facade can hand it out
+     * (`scope.$attempt()`) and fence its own attempt. Absent for a stage the attempt runner does not run.
+     */
+    private _attempt?;
+    /** The run's signal, for the attempt a stage outside the runner reports (attempt 1 of 1). */
+    private _runSignal?;
+    /** Every attempt up to this number has ENDED without an answer — its scope is fenced (0 = none). */
+    private _endedThrough;
+    /** Writes an attempt tried after it ended — dropped at the scope, kept here as names. Lazily allocated. */
+    private _lateWrites?;
+    /**
+     * Where a call's attempt records are reported (P2) — the engine's `onAttempt` for this stage execution, set by
+     * `FlowchartTraverser · executeStage` with the stage's own traversal context (and its correlation).
+     */
+    private _attemptReporter?;
+    /** Calls made so far, per stage attempt — the `k` of a call's series. Lazily allocated. */
+    private _callOrdinals?;
+    /** Per stage attempt, the signal its calls stop by (`callsEndedSignal`). Lazily allocated. */
+    private _callsEnded?;
+    /** Call and observed records kept on the frame, and those past {@link MAX_CALL_RECORDS}. */
+    private _callRecords;
+    private _attemptsDropped;
     /** Observer called after commit() — used by ScopeFacade to fire ScopeRecorder.onCommit. */
     private _commitObserver?;
     constructor(runId: string, name: string, stageId: string, sharedMemory: SharedMemory, branchId?: string, eventLog?: EventLog, isDecider?: boolean);
@@ -404,6 +455,8 @@ export declare class StageContext {
      *   reads them post-run for the execution-tree snapshot.
      */
     commit(phase?: CommitPhase): void;
+    /** Whether this frame has committed — a call's record arriving after it is late (P2, `ScopeFacade · call`). */
+    get committed(): boolean;
     /**
      * Throw away everything this stage has STAGED, without committing any of it.
      *
@@ -429,14 +482,81 @@ export declare class StageContext {
      *                    holds bare references — dropping it un-clones nothing);
      *  - `_untrackedSources` — the D2 honesty markers, released with the rest.
      *
-     * What is deliberately KEPT: `debug` (logs, metrics, errors, flow messages).
-     * Diagnostics are the append-only record of what every attempt did, and the
-     * retry feature's whole point is that the earlier attempts stay visible.
+     * What is deliberately KEPT: `debug` (logs, metrics, errors, flow messages)
+     * and the attempt records (10.1). Both are the append-only record of what
+     * every attempt did, and the retry feature's whole point is that the earlier
+     * attempts stay visible.
      *
      * No commit is recorded and no observer fires — a discarded attempt is not a
      * cursor stop, because from shared state's point of view it never happened.
      */
     discardStaged(): void;
+    /** Append one attempt's record — the attempt runner calls this as each attempt ends. */
+    recordAttempt(record: AttemptRecord): void;
+    /** Stamp the series' summary — once, when the runner ends the series. */
+    endAttempts(summary: AttemptSummary): void;
+    /** Reset only at the node's execution stamp, never between attempts. */
+    beginAttention(): void;
+    /** Delegate the explicit retained-error fact; attention owns validation of its proof. */
+    markStageFailure(): void;
+    /**
+     * The crash-safe record (10.1, P6): an attempt that ended is noted in the run's sink AT ONCE, beside this frame's
+     * log — so a process killed before the stage commits (mid-retry) still leaves every attempt that ended. The
+     * record is the one the tree keeps: frozen, `structuredClone`-safe, its error the SERVED form (no `raw`), so the
+     * note needs no second redaction pass. Without a sink the log does nothing (`EventLog · note`).
+     */
+    private noteAttempt;
+    /** The attempts of this execution so far, in order — its own and its calls'; `undefined` when there are none. */
+    get attempts(): readonly AttemptRecord[] | undefined;
+    /** The ended series' summary; `undefined` while it runs and without a policy. */
+    get attemptSummary(): AttemptSummary | undefined;
+    /** The attempt about to run (and the run's signal) — `StageRunner` sets both before it builds the scope. */
+    useAttempt(attempt: AttemptContext | undefined, runSignal: AbortSignal | undefined): void;
+    /** The attempt now running; `undefined` for a stage the attempt runner does not run. */
+    get attempt(): AttemptContext | undefined;
+    /** The run's signal, as `StageRunner` last saw it. */
+    get runSignal(): AbortSignal | undefined;
+    /**
+     * Attempt `attempt` ended without an answer: from now on its scope is fenced — a write, an emit or a read
+     * through it is refused (`ScopeFacade`). The runner calls this the moment the attempt's signal aborts.
+     */
+    endAttempt(attempt: number): void;
+    /** Whether attempt `attempt` has ended — its scope may no longer touch the stage. */
+    hasAttemptEnded(attempt: number): boolean;
+    /** Record a write an ended attempt tried — a name, never the value. Append-only evidence like the attempts. */
+    recordLateWrite(write: LateWrite): void;
+    /** This execution's own idempotency key may be made of a selected value (or was carried by a checkpoint). */
+    private _effectKeyTainted;
+    /** A touching `$call` with NO key started in this execution — the stage may not be re-run by a resume. */
+    private _keylessEffect;
+    /**
+     * Start an execution's side-effect bookkeeping (`FlowchartTraverser · executeStage`, before attempt 1) — reset,
+     * because a frame can be re-used by a later execution. `keyTainted`: the stage's own key may be made of a selected
+     * value, so a key a `$call` passes on (`$attempt().idempotencyKey`) is served the same way.
+     */
+    beginEffects(keyTainted: boolean): void;
+    get effectKeyTainted(): boolean;
+    /** A keyless touching `$call` started: an `interrupt()` after it would re-send it on resume (`StageRunner`). */
+    markKeylessEffect(): void;
+    get hasKeylessEffect(): boolean;
+    /** Where this execution's call records are reported — the engine sets it before the stage runs. */
+    useAttemptReporter(report: ((record: AttemptRecord, structuredError: StructuredErrorInfo | undefined) => void) | undefined): void;
+    /**
+     * The signal the calls of stage attempt `stageAttempt` run under besides its own (P2): aborted when that attempt is
+     * over — however it ended — and when the frame commits, so no call outlives the attempt that made it (no
+     * background retry, no wait, no listener left on the run's signal). Already aborted after the commit.
+     */
+    callsEndedSignal(stageAttempt: number): AbortSignal;
+    /** End the calls of `stageAttempt` (every attempt's when `undefined`) — `reason` when the attempt's signal gave one. */
+    private endCalls;
+    /** The next call's ordinal within stage attempt `stageAttempt`, 1-based (`attempt/call.ts · callSeries`). */
+    nextCallOrdinal(stageAttempt: number): number;
+    /**
+     * A call's (or an observed) attempt record: kept beside the stage's own attempts — the first
+     * {@link MAX_CALL_RECORDS}, the rest counted — and reported to the run's `onAttempt` either way. Like the stage's
+     * records, NOT cleared by {@link discardStaged}: a failed attempt's calls are evidence too.
+     */
+    reportCallAttempt(record: AttemptRecord, structuredError: StructuredErrorInfo | undefined): void;
     /**
      * Create (or return) this context's linked successor.
      *