e2e 0.15.2 → 0.17.0

package/dist/agent/step-cache.js

@@ -11,17 +11,17 @@
  * for the route precondition. The initial capture can also serve the executor
  * when replay performed no action.
  */
-import { anchorsPresent, describeAnchors } from '../cache/anchors.js';
+import { deltaEvidenced, deltaHolds, describeDelta } from '../cache/anchors.js';
 import { decideTraceReplay, opensWithNavigate } from '../cache/decide.js';
-import { compareRoutes, routeOf } from '../cache/route.js';
-import { instructionDigest } from '../cache/identity.js';
-import { TraceRecorder } from '../cache/recorder.js';
+import { sameRoute } from '../cache/route.js';
+import { recordedProvenance, TraceRecorder } from '../cache/recorder.js';
 import { expandTrace, templateParams, templatesCollide, templateTrace } from '../cache/template.js';
 import { readTraceEntry } from '../cache/trace.js';
 import { sleep } from '../internal/time.js';
 import { AgentError, isAgentError, isModelUnreachable } from './error.js';
 import { isRuntimeHardStop } from './executor.js';
-import { replayTrace, verifyAnchors, } from './replay.js';
+import { replayTrace, verifyEndState, } from './replay.js';
+import { redactNodesAgain } from './observation.js';
 /** The outcome of a step that threw `cause`. */
 export function failedStepOutcome(cause) {
     if (isModelUnreachable(cause))
@@ -48,9 +48,8 @@ const STALE_REASONS = new Set([
 const END_WAIT_MARGIN_MS = 10_000;
 /**
  * How long a replay waits for a recorded destination path to be the current
- * one. A step that moved records no anchors: the path is its whole
- * postcondition, and the replayed tap that starts the navigation returns
- * before the new document commits. Reading the path once, right after the
+ * one. The replayed tap that starts a navigation returns before the new
+ * document commits. Reading the path once, right after the
  * tap, hands every navigation off as an end-mismatch; polling with the
  * settling backoff lets the destination arrive. Bounded like anchor polling.
  */
@@ -60,8 +59,11 @@ export class StepTraceSession {
     host;
     cache;
     keyHash;
+    /** The claimed key and the step it names, which an entry records as its provenance. */
+    claim;
     recorder;
     options;
+    redaction;
     info;
     prefix;
     startPath;
@@ -85,6 +87,8 @@ export class StepTraceSession {
     replayedWhole = false;
     /** True once a cached entry's actions were run this step, fully or partly. */
     consumedReplay = false;
+    /** True once the store returned an entry for this step, whether or not it replayed. */
+    readEntryHit = false;
     /** True once `cache.strict` failed the step on its recording, which is then kept for review rather than evicted. */
     failedStale = false;
     /** Grammar actions recorded so far when an end-mismatch hand-off happened. */
@@ -92,13 +96,15 @@ export class StepTraceSession {
     constructor(host, options) {
         this.host = host;
         this.options = options;
+        this.redaction = { redact: options.redact, redactCut: options.redactCut };
         this.cache = options.cache;
         // The key digests the params as the recording spells them, a placeholder
         // where each `unique()` value was, so every run's value finds one entry.
-        this.keyHash = options.cache.claimKeyHash('act', options.instruction, templateParams(options.params, options.templates));
+        this.claim = options.cache.claimKey('act', options.instruction, templateParams(options.params, options.templates), options.agent);
+        this.keyHash = this.claim.keyHash;
         if (options.cache.mode === 'read-write') {
             this.recorder = new TraceRecorder({
-                redact: options.redact,
+                ...this.redaction,
                 maxActions: options.maxActions,
             });
         }
@@ -144,6 +150,8 @@ export class StepTraceSession {
             this.info = this.missed(read.reason, 0);
             if (read.unavailable !== true)
                 this.failIfStale();
+            if (read.reason === 'no-entry')
+                await this.failIfRekeyed();
             return undefined;
         }
         // With an entry in hand the step is the cache's from its first moment: the
@@ -151,6 +159,7 @@ export class StepTraceSession {
         // replay finishes stays the cache's through its verdict and the re-stage,
         // so a reporter never shows a model turn that is not coming. Only a replay
         // that cannot finish the step hands it to the model.
+        this.readEntryHit = true;
         this.host.replaying(true);
         const verdict = await this.replayEntry(read.entry);
         if (verdict === undefined) {
@@ -173,6 +182,23 @@ export class StepTraceSession {
         this.failedStale = true;
         throw new AgentError('REPLAY_STALE', `the recording of this step no longer replays (${reason}), and cache.strict hands no step to the agent; ${strict.advice}`);
     }
+    /**
+     * Under `cache.strict`, ends a step whose key found no entry while the
+     * store holds a recording made for the same step under another key: the
+     * runner, the engine, the app, or the agent's context changed since, and
+     * the recording no longer replays as surely as one that diverged. A step
+     * whose instruction or params changed is a new step and still runs live.
+     */
+    async failIfRekeyed() {
+        const { strict } = this.cache;
+        if (strict === false || strict.recordings === undefined)
+            return;
+        const previous = await strict.recordings.underAnotherKey(this.keyHash, recordedProvenance(this.claim.step, this.options.redact));
+        if (previous === undefined)
+            return;
+        this.failedStale = true;
+        throw new AgentError('REPLAY_STALE', `the recording of this step no longer replays: the store holds it under another cache key (${previous}.json), since the runner, the engine, the app, or the agent's context changed after it was recorded, and cache.strict hands no step to the agent; ${strict.advice}`);
+    }
     /**
      * Closes the session once the step has settled. The whole write-side
      * decision lives here, in read-write mode only:
@@ -192,6 +218,10 @@ export class StepTraceSession {
      *   anchor, or end wait, so drift is repaired only once a relocation fails
      *   and the hand-off that follows re-records.
      * - passed otherwise: stage the recorded trace for attempt-end settlement.
+     *   When this pass leaves nothing to stage (it changed nothing a replay
+     *   could check) and an entry was read for the step, evict that entry: it
+     *   did not serve this pass, and nothing recorded will replace it, so
+     *   keeping it would hand every later run off the same way.
      * - failed after consuming a replay: evict. Without this, a diverged replay
      *   whose step then fails stages nothing — and the poisoned entry would
      *   replay its bad prefix on every future first attempt.
@@ -219,10 +249,15 @@ export class StepTraceSession {
                 if (this.repairedAfterEndMismatch(recorder))
                     await this.evict();
                 else if (this.replayedWhole) {
-                    this.cache.staged.push({ kind: 'keep', keyHash: this.keyHash, stepIndex: this.options.stepIndex });
+                    this.cache.staged.push({
+                        kind: 'keep',
+                        keyHash: this.keyHash,
+                        stepIndex: this.options.stepIndex,
+                        recordedFor: recordedProvenance(this.claim.step, this.options.redact),
+                    });
                 }
-                else
-                    await this.stage(recorder, verdictSummary);
+                else if (!(await this.stage(recorder, verdictSummary)) && this.readEntryHit)
+                    await this.evict();
                 return;
         }
     }
@@ -289,10 +324,33 @@ export class StepTraceSession {
             this.info = this.missed(decision.reason, trace.actions.length);
             return undefined;
         }
-        const outcome = await replayTrace(this.host, trace, start?.kind === 'semantic' ? { initial: start } : {});
+        // Every screen the replay looks at, in order, from the start: the end
+        // check measures the recorded delta from the first of them on the route
+        // the replay ends on, so a free action is preceded by a look until one
+        // on the recorded end route has been seen.
+        const screens = start === undefined ? [] : [start];
+        const onEndRoute = (screen) => screen !== undefined && (trace.endPath === undefined || (screen.path !== undefined && sameRoute(screen.path, trace.endPath)));
+        const host = this.host;
+        const watched = {
+            get traceEligible() {
+                return host.traceEligible;
+            },
+            observe: async (mode) => {
+                const screen = await host.observe(mode);
+                screens.push(screen);
+                return screen;
+            },
+            actions: host.actions,
+            signal: host.signal,
+            remainingMs: () => host.remainingMs(),
+        };
+        const outcome = await replayTrace(watched, trace, {
+            ...(start?.kind === 'semantic' ? { initial: start } : {}),
+            looksBeforeFree: () => !onEndRoute(screens.at(-1)),
+        });
         this.consumedReplay = true;
         const stopReason = outcome.completed
-            ? (await this.endStateMatches(trace))
+            ? start?.kind === 'semantic' && (await this.endStateMatches(trace, start, screens))
                 ? undefined
                 : 'end-mismatch'
             : (outcome.stopReason ?? 'action-failed');
@@ -309,57 +367,59 @@ export class StepTraceSession {
     }
     /**
      * The trace's postcondition against the live screen: the recorded end
-     * route (when the live location is known) and every recorded end anchor
-     * present again. A route the path leaves undecided is the recorded screen
-     * only if the anchors are already on it, which then needs no second look.
+     * route when the live location is known, the recorded delta on the
+     * screen (`deltaHolds`), and evidence that the replay produced it rather
+     * than finding it there (`deltaEvidenced`). The evidence is measured from
+     * the first screen the replay saw on the route it ended on (`screens`, in
+     * order): the start for a step that stays on one screen, the page a
+     * recorded navigate opened before the switch on it was tapped. An outcome
+     * already showing there proves nothing, and neither does a recording with
+     * no delta at all.
      */
-    async endStateMatches(trace) {
+    async endStateMatches(trace, start, screens) {
         if (!this.host.traceEligible)
             return false;
         const arrived = await this.endScreen(trace);
         if (arrived === undefined)
             return false;
-        if (arrived.anchorsSeen)
-            return true;
-        return (await verifyAnchors(this.host, trace.endAnchors ?? [], {
-            initial: arrived.screen,
+        // Both captures may predate a secret the replay resolved; read with the
+        // ledger as it is now, an unchanged node is no change.
+        const baseline = baselineScreen(screens, arrived.path);
+        const baselineNodes = baseline === undefined ? undefined : redactNodesAgain(baseline.nodes, this.redaction);
+        if (!deltaEvidenced(trace, baselineNodes, inputTargets(trace)))
+            return false;
+        const beforeNodes = baselineNodes ?? redactNodesAgain(start.nodes, this.redaction);
+        // Every look the wait takes must still be on the recorded end route: a
+        // screen that moved on after the route first matched is another screen.
+        const holds = (screen) => (trace.endPath === undefined || screen.path === undefined || sameRoute(screen.path, trace.endPath)) &&
+            deltaHolds(trace, screen.nodes, beforeNodes);
+        return (await verifyEndState(this.host, holds, {
+            initial: arrived,
             ...(trace.endWaitMs === undefined ? {} : { waitMs: trace.endWaitMs }),
         })) && this.host.traceEligible;
     }
     /**
      * Captures the semantic end state once its route matches the recording,
-     * polling while a navigation the last action started commits. Reports
-     * whether the anchors were what settled the route, so the caller does not
-     * verify them again. A route still undecided when the poll runs out is
-     * handed on with the anchors unseen: the caller's anchor wait, sized by
-     * the recording, is the one that decides it, as for a route that matched.
+     * polling while a navigation the last action started commits. A route
+     * that never matches is another screen, whatever it shows: a link that
+     * now lands on a page sharing the recorded one's layout is exactly the
+     * flow that went wrong.
      */
     async endScreen(trace) {
         const startedMs = Date.now();
-        const recorded = trace.endPath === undefined ? undefined : routeOf(trace.endPath);
-        const anchors = trace.endAnchors ?? [];
+        const recorded = trace.endPath;
         for (let attempt = 0;; attempt += 1) {
             const observation = await probeScreen(this.host, 'raw');
             if (observation?.kind !== 'semantic' || !this.host.traceEligible)
                 return undefined;
-            if (recorded === undefined || observation.path === undefined)
-                return { screen: observation, anchorsSeen: false };
-            const verdict = compareRoutes(recorded, routeOf(observation.path));
-            if (verdict === 'same')
-                return { screen: observation, anchorsSeen: false };
-            // A path the runner cannot recognize as the recorded route is the
-            // recorded screen only if the recorded effect is visibly on it; with
-            // no anchors recorded there is nothing to see, and it is another screen.
-            const undecided = verdict === 'undecided' && anchors.length > 0;
-            if (undecided && anchorsPresent(anchors, observation.nodes, { redact: this.options.redact })) {
-                return { screen: observation, anchorsSeen: true };
-            }
+            if (recorded === undefined || observation.path === undefined || sameRoute(recorded, observation.path))
+                return observation;
             const delay = END_PATH_DELAYS_MS[attempt];
             if (delay === undefined ||
                 Date.now() - startedMs + delay > END_PATH_TIMEOUT_MS ||
                 this.host.remainingMs() <= delay ||
                 this.host.signal.aborted) {
-                return undecided ? { screen: observation, anchorsSeen: false } : undefined;
+                return undefined;
             }
             await sleep(delay, this.host.signal);
         }
@@ -401,32 +461,36 @@ export class StepTraceSession {
      *
      * The end path and a fresh settled observation are the trace's
      * postcondition — the state the step passed in. The delta between the
-     * baseline and the passing observation becomes the end anchors. When the
-     * step moved to another pathname the whole new screen is the delta, and its
-     * first stable anchors back the path check, which matches a created
-     * record's page up to the id the app minted for it. A postcondition that
-     * cannot be captured stages nothing: a trace without its check would
-     * replay on mechanics alone.
+     * baseline and the passing observation becomes the anchors: what appeared
+     * and what vanished. When the step moved to another pathname the whole new
+     * screen is the delta, and its first stable anchors back the path check,
+     * which matches a created record's page up to the id the app minted for
+     * it. A postcondition that cannot be captured stages nothing, and neither
+     * does a step that changed nothing a replay could check, no node and no
+     * route: a trace without its check would replay on mechanics alone.
      */
     async stage(recorder, verdictSummary) {
         if (!this.host.traceEligible || this.startNodes === undefined || recorder.recordedCount === 0)
-            return;
+            return false;
         const observation = await probeScreen(this.host, 'held-still');
         if (!this.host.traceEligible || observation?.kind !== 'semantic')
-            return;
+            return false;
         const { nodes: endNodes, path: endPath } = observation;
-        const endAnchors = describeAnchors(this.startNodes, endNodes, this.options);
+        // The start capture may predate a secret this step resolved; read with
+        // the ledger as it is now, an unchanged node is no delta.
+        const startNodes = redactNodesAgain(this.startNodes, this.redaction);
+        const routeMoved = this.startPath !== undefined && endPath !== undefined && !sameRoute(this.startPath, endPath);
+        const delta = describeDelta(startNodes, endNodes, routeMoved);
+        if (delta.appeared.length === 0 && delta.gone.length === 0 && !routeMoved)
+            return false;
         const trace = recorder.finalize({
             executor: this.options.executor,
-            recordedFor: {
-                testId: this.cache.identity.testId,
-                targetId: this.cache.identity.targetId,
-                instructionDigest: instructionDigest(this.options.instruction),
-            },
+            recordedFor: this.claim.step,
             summary: verdictSummary ?? 'step passed',
             ...(this.startPath === undefined ? {} : { startPath: this.startPath }),
             ...(endPath === undefined ? {} : { endPath }),
-            endAnchors,
+            endAnchors: delta.appeared,
+            goneAnchors: delta.gone,
             // How long the app took to show its end state after the last action,
             // plus room for a slower day: the budget a replay waits for the anchors
             // to return. Measured from the last action, not the step's start: the
@@ -435,12 +499,12 @@ export class StepTraceSession {
             endWaitMs: Date.now() - (recorder.lastActionAtMs ?? this.startedMs) + END_WAIT_MARGIN_MS,
         });
         if (trace === undefined)
-            return;
+            return false;
         // A trace with no start anchor — no recorded path (a surface without a URL)
         // and no opening navigate — could never replay: `wrong-context` forever.
         // Writing it would be pure store traffic, so it is not written at all.
         if (trace.startPath === undefined && !opensWithNavigate(trace))
-            return;
+            return false;
         // Stored with a slot where each `unique()` value appeared, so the next
         // run's values — a fresh timestamped name — replay the same flow. A
         // recording that cannot be templated safely is not written at all; when
@@ -448,12 +512,13 @@ export class StepTraceSession {
         if (templatesCollide(this.options.params, this.options.templates)) {
             if (this.info !== undefined)
                 this.info = { ...this.info, notRecorded: 'param-collision' };
-            return;
+            return false;
         }
         const templated = templateTrace(trace, this.options.templates);
         if (templated === undefined)
-            return;
+            return false;
         this.cache.staged.push({ kind: 'write', keyHash: this.keyHash, trace: templated, stepIndex: this.options.stepIndex });
+        return true;
     }
     /**
      * Awaited so the step does not close — and a later read cannot be served
@@ -476,6 +541,26 @@ export class StepTraceSession {
         };
     }
 }
+/** The controls a trace's input actions set a value or a state on: their changed anchors echo the input. */
+function inputTargets(trace) {
+    return trace.actions.flatMap((action) => ('target' in action && action.target !== undefined ? [action.target] : []));
+}
+/**
+ * The first semantic screen of the replay's last stretch on the route it
+ * ended on (`endPath`), or undefined when its last screen before the end
+ * was on another route, so the last action moved it. A screen or an end
+ * without a location counts as on the route: there is nothing to compare.
+ */
+function baselineScreen(screens, endPath) {
+    let baseline;
+    for (const screen of screens) {
+        if (endPath !== undefined && screen.path !== undefined && !sameRoute(screen.path, endPath))
+            baseline = undefined;
+        else if (screen.kind === 'semantic')
+            baseline ??= screen;
+    }
+    return baseline;
+}
 /**
  * One cache capture, settled as far as `mode` asks, or undefined when the
  * surface cannot be observed right now, which is the executor's business,
@@ -511,4 +596,3 @@ export function recordedVerdictOf(summary) {
     const at = summary.indexOf(RECORDED_VERDICT_SEPARATOR);
     return at === -1 ? summary : summary.slice(at + RECORDED_VERDICT_SEPARATOR.length);
 }
-//# sourceMappingURL=step-cache.js.map

package/dist/agent/tool-loop.d.ts

@@ -80,4 +80,3 @@ export interface PreparedTurn {
  * Its model turns per step are the agent's `maxModelCalls`.
  */
 export declare function createToolLoopExecutor(options: ToolLoopExecutorOptions): StepExecutor;
-//# sourceMappingURL=tool-loop.d.ts.map

package/dist/agent/tool-loop.js

@@ -11,6 +11,7 @@
  * - model-call accounting and a step transcript for `--debug`.
  */
 import { asSdkLanguageModel, loadAiSdk } from './ai-sdk.js';
+import { MODEL_REQUEST_HEADERS } from '../internal/client-identity.js';
 import { ConfigurationError, withHint } from '../internal/errors.js';
 import { failureHint, isAbort, TRANSPORT_RETRIES } from './model/sdk.js';
 import { isContextOverflow } from './model/overflow.js';
@@ -241,6 +242,7 @@ class LoopRun {
             toolChoice: this.toolChoice,
             ...(providerOptions === undefined ? {} : { providerOptions: providerOptions }),
             maxRetries: TRANSPORT_RETRIES,
+            headers: MODEL_REQUEST_HEADERS,
             stopWhen: [
                 () => this.conclusion.concluded() || this.hardStop !== undefined,
                 // Counted across every generate call of the step, so a retry after an
@@ -632,4 +634,3 @@ function safeJson(value) {
         return String(value);
     }
 }
-//# sourceMappingURL=tool-loop.js.map

package/dist/agent/tool-output.d.ts

@@ -28,4 +28,3 @@ export declare function boundToolOutput(text: string, limits?: {
     maxLines: number;
     maxBytes: number;
 }): BoundToolOutput;
-//# sourceMappingURL=tool-output.d.ts.map

package/dist/agent/tool-output.js

@@ -57,4 +57,3 @@ function formatBytes(bytes) {
         return `${String(bytes)} B`;
     return `${(bytes / 1024).toFixed(1)} KB`;
 }
-//# sourceMappingURL=tool-output.js.map

package/dist/agent/tool.d.ts

@@ -35,4 +35,3 @@ export type ToolContext = Pick<StepExecutorContext, 'observe' | 'attachScreensho
 export declare function getToolContext(options: object): ToolContext;
 /** Carries harness capabilities alongside SDK options without replacing the project's SDK context. */
 export declare function withToolContext(options: ToolExecutionOptions<unknown>, context: ToolContext): ToolExecutionOptions<unknown>;
-//# sourceMappingURL=tool.d.ts.map

package/dist/agent/tool.js

@@ -50,4 +50,3 @@ const TOOL_CONTEXT = Symbol.for('e2e.tool-context.v1');
 export function withToolContext(options, context) {
     return Object.assign({}, options, { [TOOL_CONTEXT]: context });
 }
-//# sourceMappingURL=tool.js.map

package/dist/agent/transcript-compaction.d.ts

@@ -35,4 +35,3 @@ export interface CompactScreenshotHistoryOptions {
  * array unchanged when nothing qualifies.
  */
 export declare function compactScreenshotHistory(messages: ModelMessage[], options?: CompactScreenshotHistoryOptions): ModelMessage[];
-//# sourceMappingURL=transcript-compaction.d.ts.map

package/dist/agent/transcript-compaction.js

@@ -183,4 +183,3 @@ function carriesImage(part) {
 function isImage(item) {
     return item.type === 'file' && (item.mediaType ?? '').startsWith('image/');
 }
-//# sourceMappingURL=transcript-compaction.js.map

package/dist/agent/upload-paths.d.ts

@@ -25,4 +25,3 @@ export interface AuthorizedUpload {
  */
 export declare function authorizeUploadPaths(host: UploadPolicyHost, paths: unknown, projectRoot: string): AuthorizedUpload;
 export {};
-//# sourceMappingURL=upload-paths.d.ts.map

package/dist/agent/upload-paths.js

@@ -54,4 +54,3 @@ export function authorizeUploadPaths(host, paths, projectRoot) {
     host.recordPolicy('upload.path', 'allowed');
     return { given: paths, resolved };
 }
-//# sourceMappingURL=upload-paths.js.map

package/dist/agent/usage.d.ts

@@ -45,4 +45,3 @@ export declare const MAX_REASONING_CHARS = 600;
  */
 export declare function reasoningField(text: string | undefined, redact: (text: string) => string): Pick<StepEvent, 'reasoning'>;
 export {};
-//# sourceMappingURL=usage.d.ts.map

package/dist/agent/usage.js

@@ -89,4 +89,3 @@ export function reasoningField(text, redact) {
     const trimmed = text?.trim() ?? '';
     return trimmed === '' ? {} : { reasoning: bound(redact(trimmed), MAX_REASONING_CHARS) };
 }
-//# sourceMappingURL=usage.js.map

package/dist/cache/anchors.d.ts

@@ -1,37 +1,85 @@
 /**
- * End anchors.
+ * Anchors: the step's recorded delta.
  *
  * A recording run does not end when its last action commits; it ends when the
  * executor looks at the screen and judges the step done. The trace used to
  * keep only the actions and drop that look, so a replay could run every
  * recorded action mechanically — a fill that never committed, a save that
  * produced an unnamed record — and self-finalize with nothing checking the
- * effect. Anchors restore the check as data: the descriptors of nodes that
- * were on screen when the step passed and were not there when it began. They
- * are the step's own delta, checked by the relocation vocabulary
- * (`relocate.ts`) with two deliberate differences: every recorded field must
- * be equal, text included, and presence is enough — uniqueness is not asked.
+ * effect. Anchors restore the check as data: the descriptors of nodes the
+ * step made appear (`endAnchors`) and of nodes it made vanish
+ * (`goneAnchors`), each with the states a step sets on a control it leaves
+ * on screen (a switch turned on, a field typed into). They are checked by
+ * the relocation vocabulary (`relocate.ts`) with two deliberate differences:
+ * every recorded field must be equal, text, value, and states included, and
+ * presence is enough, uniqueness is not asked.
+ *
+ * A replay passes on its own only when the delta happened again: everything
+ * that appeared is there, everything that vanished is gone, and at least one
+ * of those changes, or the route, actually moved during the replay
+ * (`deltaEvidenced`), so a status that already read "Submitted" before a
+ * submit that did nothing is no proof. An alert the replay raised that the
+ * recording never saw is an outcome the recording did not have, whatever
+ * else matched (`deltaHolds`).
  */
-import type { SemanticNode } from '../engine/surface.ts';
-import { type DescriptorMatchOptions } from './relocate.ts';
+import type { RedactedNode } from '../agent/observation.ts';
 import { type TraceTargetDescriptor } from './trace.ts';
-export type AnchorOptions = DescriptorMatchOptions;
+/** The two sides of one step's delta, each projected, deduplicated, ordered, and capped. */
+export interface StepDelta {
+    /** On screen when the step passed, not when it began. */
+    readonly appeared: TraceTargetDescriptor[];
+    /** On screen when the step began, not when it passed. */
+    readonly gone: TraceTargetDescriptor[];
+}
+/** The recorded delta a replay checks, as a trace carries it. */
+export interface RecordedDelta {
+    readonly endAnchors?: readonly TraceTargetDescriptor[];
+    readonly goneAnchors?: readonly TraceTargetDescriptor[];
+}
 /**
- * Derives the end anchors of one step: relocatable descriptors present in the
- * passing observation and absent from the starting one, deduplicated, capped.
- * Leaves come first, then containers, each in document order: a container's
- * accessible name is usually the concatenation of its children's, so it
- * repeats what the leaves already say — and on a list-heavy screen those
- * repeats would crowd the one status line that names the effect out of the
- * cap.
+ * Derives one step's delta between its starting observation and its passing
+ * one. Each side is ordered announcements first, then leaves, then
+ * containers, each in document order: a container's accessible name is
+ * usually the concatenation of its children's, so it repeats what the
+ * leaves already say, and on a list-heavy screen those repeats would crowd
+ * the one status line that names the effect out of the cap. `routeMoved`
+ * says the step ended on another route than it began on, whose counts are
+ * that screen's data rather than the step's result (`COUNT_TEXT`).
+ *
+ * A node counts as gone only when no end node matches its anchor the way
+ * `deltaHolds` checks one, on the recorded fields alone: a radio label
+ * "Express" the pick replaced with a status reading "Express" vanished, but
+ * an anchor of that text would still match the status, and the recording
+ * would fail its own check on every replay.
  */
-export declare function describeAnchors(startNodes: ReadonlyMap<string, SemanticNode>, endNodes: ReadonlyMap<string, SemanticNode>, options: AnchorOptions): TraceTargetDescriptor[];
+export declare function describeDelta(startNodes: ReadonlyMap<string, RedactedNode>, endNodes: ReadonlyMap<string, RedactedNode>, routeMoved: boolean): StepDelta;
 /**
- * Whether every anchor is present in a fresh observation: some tier of the
- * anchor (`descriptorTiers` — so a test id that churned per render is
- * forgiven when the remaining fields still identify the node) equals some
- * candidate on every anchor field. Two matching nodes are the effect twice
- * over, not an ambiguity.
+ * Whether the recorded end state holds on a fresh observation: every
+ * appeared anchor present (some tier of it, `descriptorTiers`, so a test id
+ * that churned per render is forgiven when the remaining fields still
+ * identify the node, equal on every anchor field and state), no gone anchor
+ * present, and no alert on screen that was not on `beforeNodes` and is not
+ * one the recording saw appear. Two nodes matching one anchor are the effect
+ * twice over, not an ambiguity.
+ */
+export declare function deltaHolds(delta: RecordedDelta, nodes: ReadonlyMap<string, RedactedNode>, beforeNodes: ReadonlyMap<string, RedactedNode>): boolean;
+/**
+ * Whether the replay itself produced some of the recorded delta, measured
+ * from `baselineNodes`, the first screen the replay saw on the route it
+ * ended on: an anchor that appeared was absent there, or a gone one was
+ * there. Without that, every check `deltaHolds` makes could have held before
+ * the actions that should have produced it: the screen already read the
+ * outcome, and nothing the replay did is proven to have done anything. A
+ * recording with no delta at all is never evidence. Undefined `baselineNodes`
+ * means the replay saw no screen on that route before its last action, so
+ * that action moved the route, which is the evidence.
+ *
+ * A control one of the trace's own actions targeted (`inputTargets`) that
+ * shows on both sides of the delta, a field typed into or a switch flipped,
+ * echoes the input: the replay typed, so the value is there, whatever the
+ * step was for. Such echoes are evidence only when the delta holds nothing
+ * else; otherwise the rest of the delta must have moved, so a subscribe
+ * form typed into on a page that already read "You're subscribed" proves
+ * nothing.
  */
-export declare function anchorsPresent(anchors: readonly TraceTargetDescriptor[], nodes: ReadonlyMap<string, SemanticNode>, options: AnchorOptions): boolean;
-//# sourceMappingURL=anchors.d.ts.map
+export declare function deltaEvidenced(delta: RecordedDelta, baselineNodes: ReadonlyMap<string, RedactedNode> | undefined, inputTargets: readonly TraceTargetDescriptor[]): boolean;