e2e 0.16.0 → 0.18.0

package/dist/cache/context.js

@@ -38,6 +38,18 @@ function flowOf(trace) {
         }),
     });
 }
+/**
+ * Writes the step's full provenance into a kept entry recorded before the
+ * occurrence fields were, leaving every other entry untouched. Its replay
+ * proved which step it belongs to, and `cache.strict` matches only entries
+ * that say so exactly (`rekeyed.ts`).
+ */
+async function completeProvenance(store, keyHash, recordedFor) {
+    const existing = await store.read(keyHash);
+    if (existing.status !== 'hit' || existing.entry.payload.recordedFor?.callIndex !== undefined)
+        return;
+    await store.write(keyHash, { ...existing.entry.payload, recordedFor });
+}
 /**
  * Settles the attempt's staged trace writes. A staged trace is confirmed only
  * when a verification step — a deterministic assertion or an agent judgment
@@ -54,7 +66,7 @@ function flowOf(trace) {
  * for an interrupted attempt: interruption implicates nothing, so it writes
  * nothing and evicts nothing. An entry a step replayed whole is staged too,
  * so the same rule evicts it when nothing confirmed it; when something did,
- * it is left exactly as it was found.
+ * it is left exactly as it was found, but for provenance it lacked.
  */
 export async function flushStagedTraces(context, settlement) {
     const staged = context.staged.splice(0);
@@ -68,7 +80,11 @@ export async function flushStagedTraces(context, settlement) {
                     await context.store.delete?.(entry.keyHash);
                 continue;
             }
-            if (entry.kind === 'keep' || (await holdsSameFlow(context.store, entry.keyHash, entry.trace)))
+            if (entry.kind === 'keep') {
+                await completeProvenance(context.store, entry.keyHash, entry.recordedFor);
+                continue;
+            }
+            if (await holdsSameFlow(context.store, entry.keyHash, entry.trace))
                 continue;
             await context.store.write(entry.keyHash, entry.trace);
         }
@@ -95,23 +111,49 @@ export function createAgentCacheContext(options) {
             writable: mode === 'read-write',
         });
     const project = projectIdentity(options.projectId);
-    const nextCallIndex = createCallIndexer();
+    // One occurrence count per agent: the agent is part of the key, so another
+    // agent's call of the same instruction must not renumber this one's.
+    const indexers = new Map();
+    const nextCallIndex = (agent, signature) => {
+        // Folded like the key folds it (`buildTraceCacheKey`): no context is the empty one.
+        const agentKey = canonicalJson([agent.name, agent.context ?? '']);
+        const indexer = indexers.get(agentKey) ?? createCallIndexer();
+        indexers.set(agentKey, indexer);
+        return indexer(signature);
+    };
     return {
         mode,
         store,
-        identity: { testId: options.testId, targetId: options.target.targetId },
         replayEligible: options.attemptIndex === 0,
-        strict: options.cache.strict === false ? false : { advice: staleAdvice(options.cache, options.cache.strict, options.projectRoot) },
-        claimKeyHash: (kind, instruction, params) => {
+        strict: options.cache.strict === false
+            ? false
+            : {
+                advice: staleAdvice(options.cache, options.cache.strict, options.projectRoot),
+                ...(options.recordings === undefined ? {} : { recordings: options.recordings }),
+            },
+        claimKey: (kind, instruction, params, agent) => {
             const signature = traceCallSignature(kind, instruction, params);
-            return traceCacheKeyHash(buildTraceCacheKey({
+            const callIndex = nextCallIndex(agent, signature);
+            const keyHash = traceCacheKeyHash(buildTraceCacheKey({
                 project,
                 testId: options.testId,
                 target: options.target,
                 signature,
-                callIndex: nextCallIndex(signature),
+                callIndex,
+                agent,
                 policyVersion: REPLAY_POLICY_VERSION,
             }));
+            return {
+                keyHash,
+                step: {
+                    testId: options.testId,
+                    targetId: options.target.targetId,
+                    instructionDigest: signature.instructionDigest,
+                    paramsDigest: signature.paramsDigest,
+                    callIndex,
+                    agent: agent.name,
+                },
+            };
         },
         staged: [],
     };

package/dist/cache/decide.d.ts

@@ -31,7 +31,7 @@ export type TraceReplayDecision = {
  * not open with a navigate carries a start precondition: the app must be on
  * the screen where the recording began, or the recorded actions would run
  * against a different screen than they were proven on. The screen is its
- * route (`routeOf`), not its URL; a route the path leaves undecided is a
- * miss, since nothing recorded at the start is specific enough to settle it.
+ * route (`cache/route.ts`), not its URL: the same origin, path, and query,
+ * whatever the ids in them.
  */
 export declare function decideTraceReplay(entry: TraceEntry, currentPath: string | undefined): TraceReplayDecision;

package/dist/cache/decide.js

@@ -7,7 +7,7 @@
  * decision takes an already-trusted entry and answers only the questions the
  * entry alone cannot: is it whole, and is the app where the recording began?
  */
-import { compareRoutes, routeOf } from './route.js';
+import { sameRoute } from './route.js';
 /**
  * Whether a trace establishes its own starting point by navigating first.
  * Such a trace needs no start-path precondition — and a trace with neither
@@ -21,8 +21,8 @@ export function opensWithNavigate(trace) {
  * not open with a navigate carries a start precondition: the app must be on
  * the screen where the recording began, or the recorded actions would run
  * against a different screen than they were proven on. The screen is its
- * route (`routeOf`), not its URL; a route the path leaves undecided is a
- * miss, since nothing recorded at the start is specific enough to settle it.
+ * route (`cache/route.ts`), not its URL: the same origin, path, and query,
+ * whatever the ids in them.
  */
 export function decideTraceReplay(entry, currentPath) {
     const trace = entry.payload;
@@ -32,7 +32,5 @@ export function decideTraceReplay(entry, currentPath) {
         return { action: 'replay' };
     if (trace.startPath === undefined || currentPath === undefined)
         return { action: 'miss', reason: 'wrong-context' };
-    return compareRoutes(routeOf(trace.startPath), routeOf(currentPath)) === 'same'
-        ? { action: 'replay' }
-        : { action: 'miss', reason: 'wrong-context' };
+    return sameRoute(trace.startPath, currentPath) ? { action: 'replay' } : { action: 'miss', reason: 'wrong-context' };
 }

package/dist/cache/identity.d.ts

@@ -7,10 +7,13 @@
  * contributes only its stable name and purpose, exactly as the executor sees
  * it in the projected params.
  *
- * Executor identity is deliberately absent (OQ10's conservative default):
- * entries are shared across roster members and carry their producer as
- * provenance on the entry, so a future ReplayPolicy can reject foreign traces
- * without a re-key.
+ * The agent a step runs with is part of the key: its configured name, since
+ * two agents of one test (`agent: ['buyer', 'admin']`) act as different
+ * people, and a digest of the context it reads, since a test's
+ * `agentContext` decides what the step does. The context is digested after
+ * redaction, so a registered secret in it contributes its name only. The
+ * executor that produced a trace stays provenance on the entry: the agent's
+ * name already keeps two configured agents apart.
  */
 import type { JsonValue } from '../types.ts';
 import { TRACE_SCHEMA_VERSION } from './trace.ts';
@@ -37,8 +40,18 @@ export interface TraceCacheKey {
     readonly instructionDigest: string;
     readonly paramsDigest: string;
     readonly appIdentity: string;
+    /** Name of the configured agent the step ran with. */
+    readonly agent: string;
+    /** SHA-256 of the agent's redacted context (its `context` then the test's `agentContext`), or of the empty string. */
+    readonly agentContextDigest: string;
     readonly policyVersion: string;
 }
+/** The agent a step runs with, as the key sees it. */
+export interface CacheAgentIdentity {
+    readonly name: string;
+    /** The context the agent reads, already redacted. */
+    readonly context: string | undefined;
+}
 /** Identity of the target/engine/app a trace was recorded against. */
 export interface CacheTargetIdentity {
     readonly targetId: string;
@@ -106,6 +119,7 @@ export declare function buildTraceCacheKey(parts: {
     readonly target: CacheTargetIdentity;
     readonly signature: TraceCallSignature;
     readonly callIndex: number;
+    readonly agent: CacheAgentIdentity;
     readonly policyVersion: string;
 }): TraceCacheKey;
 /** SHA-256/JCS of one key, used as both the entry digest and its file name. */

package/dist/cache/identity.js

@@ -7,10 +7,13 @@
  * contributes only its stable name and purpose, exactly as the executor sees
  * it in the projected params.
  *
- * Executor identity is deliberately absent (OQ10's conservative default):
- * entries are shared across roster members and carry their producer as
- * provenance on the entry, so a future ReplayPolicy can reject foreign traces
- * without a re-key.
+ * The agent a step runs with is part of the key: its configured name, since
+ * two agents of one test (`agent: ['buyer', 'admin']`) act as different
+ * people, and a digest of the context it reads, since a test's
+ * `agentContext` decides what the step does. The context is digested after
+ * redaction, so a registered secret in it contributes its name only. The
+ * executor that produced a trace stays provenance on the entry: the agent's
+ * name already keeps two configured agents apart.
  */
 import { canonicalDigest, sha256Hex } from '../internal/ids.js';
 import { TRACE_SCHEMA_VERSION } from './trace.js';
@@ -99,6 +102,8 @@ export function buildTraceCacheKey(parts) {
         instructionDigest: parts.signature.instructionDigest,
         paramsDigest: parts.signature.paramsDigest,
         appIdentity: parts.target.appIdentity,
+        agent: parts.agent.name,
+        agentContextDigest: sha256Hex(parts.agent.context ?? ''),
         policyVersion: parts.policyVersion,
     };
 }

package/dist/cache/recorder.d.ts

@@ -20,12 +20,15 @@ import { type ActionTrace, type DerivedReason, type TraceProvenance, type TraceT
 export interface TraceRecorderOptions {
     /** The run's secret redactor; applied to every recorded string. */
     readonly redact: (text: string) => string;
+    /** `redact` for a field cut at its observed limit (`SecretLedger.redactCut`). */
+    readonly redactCut: (text: string) => string;
     readonly maxActions?: number;
 }
 export declare class TraceRecorder {
     private readonly actions;
     private truncated;
     private readonly redact;
+    private readonly redactCut;
     private readonly maxActions;
     constructor(options: TraceRecorderOptions);
     private lastActionAt;
@@ -61,8 +64,10 @@ export declare class TraceRecorder {
         readonly summary: string;
         readonly startPath?: string;
         readonly endPath?: string;
-        /** Already projected and capped by `describeAnchors`; recorded as given. */
+        /** Already projected and capped by `describeDelta`; recorded as given. */
         readonly endAnchors?: readonly TraceTargetDescriptor[];
+        /** The other side of the same delta: what was on screen at the start and gone at the end. */
+        readonly goneAnchors?: readonly TraceTargetDescriptor[];
         /** How long the recorded run took to reach its end state, plus margin. */
         readonly endWaitMs?: number;
     }): ActionTrace | undefined;
@@ -84,3 +89,12 @@ export declare class TraceRecorder {
     private verbatim;
     private push;
 }
+/**
+ * Provenance as an entry stores it. Harness identity rather than screen
+ * content, so the redactor here is belt and braces: a title or agent name
+ * that happened to carry a registered secret is masked like any other
+ * recorded string, and provenance is not replay input, so masking it poisons
+ * nothing. A step compares its own provenance in this form to the entries
+ * the store holds.
+ */
+export declare function recordedProvenance(provenance: TraceProvenance, redact: (text: string) => string): TraceProvenance;

package/dist/cache/recorder.js

@@ -24,9 +24,11 @@ export class TraceRecorder {
     actions = [];
     truncated = false;
     redact;
+    redactCut;
     maxActions;
     constructor(options) {
         this.redact = options.redact;
+        this.redactCut = options.redactCut;
         this.maxActions = Math.min(options.maxActions ?? MAX_TRACE_ACTIONS, MAX_TRACE_ACTIONS);
     }
     lastActionAt;
@@ -40,7 +42,7 @@ export class TraceRecorder {
     }
     /** Records one committed grammar action. */
     record(action) {
-        this.push(this.toRecorded(action, describeAction(action, this.redact)));
+        this.push(this.toRecorded(action, describeAction(action, { redact: this.redact, redactCut: this.redactCut })));
         this.lastActionAt = Date.now();
     }
     /**
@@ -69,9 +71,10 @@ export class TraceRecorder {
         if (this.actions.length === 0)
             return undefined;
         const summary = bound(this.redact(conclusion.summary), MAX_TRACE_SUMMARY_CHARS);
-        // Anchors are replay preconditions, so they follow the input rule: a path
-        // the redactor alters carried a secret (a token in a query string) and
-        // the trace is marked non-replayable rather than storing it verbatim.
+        // Locations are replay preconditions, so they follow the input rule: a
+        // path the redactor alters carried a secret (a token in a query string),
+        // and one too long to keep whole cannot be compared, so either marks the
+        // trace non-replayable rather than storing it bent.
         const startPath = this.anchorPath(conclusion.startPath);
         const endPath = this.anchorPath(conclusion.endPath);
         return {
@@ -80,21 +83,16 @@ export class TraceRecorder {
                 name: conclusion.executor.name,
                 ...(conclusion.executor.version === undefined ? {} : { version: conclusion.executor.version }),
             },
-            recordedFor: {
-                // Harness identity rather than screen content, so the redactor here is
-                // belt and braces: a title that happened to carry a registered secret
-                // is masked like any other recorded string, and provenance is not
-                // replay input, so masking it poisons nothing.
-                testId: bound(this.redact(conclusion.recordedFor.testId), MAX_TRACE_DESCRIPTOR_CHARS),
-                targetId: bound(this.redact(conclusion.recordedFor.targetId), MAX_TRACE_DESCRIPTOR_CHARS),
-                instructionDigest: conclusion.recordedFor.instructionDigest,
-            },
+            recordedFor: recordedProvenance(conclusion.recordedFor, this.redact),
             summary: summary.trim() === '' ? 'step passed' : summary,
             ...(startPath === undefined ? {} : { startPath }),
             ...(endPath === undefined ? {} : { endPath }),
             ...(conclusion.endAnchors === undefined || conclusion.endAnchors.length === 0
                 ? {}
                 : { endAnchors: conclusion.endAnchors }),
+            ...(conclusion.goneAnchors === undefined || conclusion.goneAnchors.length === 0
+                ? {}
+                : { goneAnchors: conclusion.goneAnchors }),
             ...(conclusion.endWaitMs === undefined
                 ? {}
                 : { endWaitMs: Math.min(MAX_TRACE_END_WAIT_MS, Math.max(0, Math.round(conclusion.endWaitMs))) }),
@@ -102,12 +100,7 @@ export class TraceRecorder {
         };
     }
     anchorPath(value) {
-        if (value === undefined || value === '')
-            return undefined;
-        const redacted = this.redact(value);
-        if (redacted !== value)
-            this.truncated = true;
-        return bound(redacted, MAX_TRACE_DESCRIPTOR_CHARS);
+        return value === undefined || value === '' ? undefined : this.verbatim(value);
     }
     /**
      * Builds the stored variant for one action. The descriptor and the prose
@@ -117,13 +110,15 @@ export class TraceRecorder {
      * kept whole.
      */
     toRecorded(action, { target, summary, destination }) {
-        // A targeted commit whose node yields no durable descriptor cannot be
-        // re-found; the trace stays honest by poisoning instead of guessing.
+        // A targeted commit whose node yields no descriptor a replay could
+        // re-find it by (none at all, or an unnamed twin with no named row to
+        // tell it apart) cannot replay; the trace stays honest by poisoning
+        // instead of guessing.
         const require = (descriptor) => {
-            if (descriptor !== undefined)
+            if (descriptor !== undefined && isRelocatableDescriptor(descriptor))
                 return descriptor;
             this.truncated = true;
-            return { role: 'unknown' };
+            return descriptor ?? { role: 'unknown' };
         };
         const requireTarget = () => require(target);
         if (isNodeAction(action))
@@ -240,3 +235,21 @@ function sameTarget(a, b) {
         a.position?.index === b.position?.index &&
         a.position?.of === b.position?.of);
 }
+/**
+ * Provenance as an entry stores it. Harness identity rather than screen
+ * content, so the redactor here is belt and braces: a title or agent name
+ * that happened to carry a registered secret is masked like any other
+ * recorded string, and provenance is not replay input, so masking it poisons
+ * nothing. A step compares its own provenance in this form to the entries
+ * the store holds.
+ */
+export function recordedProvenance(provenance, redact) {
+    return {
+        testId: bound(redact(provenance.testId), MAX_TRACE_DESCRIPTOR_CHARS),
+        targetId: bound(redact(provenance.targetId), MAX_TRACE_DESCRIPTOR_CHARS),
+        instructionDigest: provenance.instructionDigest,
+        ...(provenance.paramsDigest === undefined ? {} : { paramsDigest: provenance.paramsDigest }),
+        ...(provenance.callIndex === undefined ? {} : { callIndex: provenance.callIndex }),
+        ...(provenance.agent === undefined ? {} : { agent: bound(redact(provenance.agent), MAX_TRACE_DESCRIPTOR_CHARS) }),
+    };
+}

package/dist/cache/rekeyed.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Recordings stored under a key the runner no longer derives.
+ *
+ * A key names everything that can change replay (`identity.ts`), so a new
+ * replay policy, an engine minor, or an agent's context changing turns every
+ * entry recorded before into a lookup miss, the same `no-entry` as a step
+ * that was never recorded. `cache.strict` lets a never-recorded step run
+ * live, so without this it would let a whole committed cache go quietly
+ * unused. The entries say which step they were recorded for
+ * (`TraceProvenance`), and a step whose own key misses while the store holds
+ * a recording made for exactly that step is stale, not new.
+ *
+ * Only the file store can be listed. The listing is read once per worker
+ * and target, on the first strict miss that asks, and kept: every entry
+ * written since has a key the run derives, so it is a hit rather than a
+ * candidate here.
+ */
+import type { ResolvedCacheConfig } from '../config/resolve.ts';
+import { FileCacheStore } from './store.ts';
+import type { TraceProvenance } from './trace.ts';
+export declare class StoredRecordings {
+    private readonly store;
+    /** Key hashes by `stepKey` of the step each entry was recorded for. */
+    private listing;
+    constructor(store: FileCacheStore);
+    /**
+     * The key hash of an entry recorded for `step` under a key other than
+     * `keyHash`, or undefined when there is none or the store cannot be
+     * listed. `step` is in the form an entry stores it (`recordedProvenance`).
+     * Only an entry that records the whole step counts: one written before the
+     * params, occurrence, and agent were recorded could belong to another call
+     * of the same instruction, and a read-write run that replays it completes
+     * it (`flushStagedTraces`). A truncated entry never replays under any key,
+     * so it is never the reason a step is stale.
+     */
+    underAnotherKey(keyHash: string, step: TraceProvenance): Promise<string | undefined>;
+    /** Every replayable entry that records its whole step, by `stepKey`. */
+    private list;
+}
+/**
+ * The listing `cache.strict` checks a run's misses against, for the file
+ * store only. Undefined when strict is off, the cache is off, or a custom
+ * `cache.store` replaced the file store, which `CacheStore` gives no way to
+ * list.
+ */
+export declare function storedRecordingsFor(cache: ResolvedCacheConfig): StoredRecordings | undefined;

package/dist/cache/rekeyed.js

@@ -0,0 +1,89 @@
+/**
+ * Recordings stored under a key the runner no longer derives.
+ *
+ * A key names everything that can change replay (`identity.ts`), so a new
+ * replay policy, an engine minor, or an agent's context changing turns every
+ * entry recorded before into a lookup miss, the same `no-entry` as a step
+ * that was never recorded. `cache.strict` lets a never-recorded step run
+ * live, so without this it would let a whole committed cache go quietly
+ * unused. The entries say which step they were recorded for
+ * (`TraceProvenance`), and a step whose own key misses while the store holds
+ * a recording made for exactly that step is stale, not new.
+ *
+ * Only the file store can be listed. The listing is read once per worker
+ * and target, on the first strict miss that asks, and kept: every entry
+ * written since has a key the run derives, so it is a hit rather than a
+ * candidate here.
+ */
+import { FileCacheStore, MAX_CACHE_WIRE_BYTES } from './store.js';
+export class StoredRecordings {
+    store;
+    /** Key hashes by `stepKey` of the step each entry was recorded for. */
+    listing;
+    constructor(store) {
+        this.store = store;
+    }
+    /**
+     * The key hash of an entry recorded for `step` under a key other than
+     * `keyHash`, or undefined when there is none or the store cannot be
+     * listed. `step` is in the form an entry stores it (`recordedProvenance`).
+     * Only an entry that records the whole step counts: one written before the
+     * params, occurrence, and agent were recorded could belong to another call
+     * of the same instruction, and a read-write run that replays it completes
+     * it (`flushStagedTraces`). A truncated entry never replays under any key,
+     * so it is never the reason a step is stale.
+     */
+    async underAnotherKey(keyHash, step) {
+        const key = stepKey(step);
+        if (key === undefined)
+            return undefined;
+        let listing;
+        try {
+            this.listing ??= this.list();
+            listing = await this.listing;
+        }
+        catch {
+            return undefined;
+        }
+        for (const candidate of listing.get(key) ?? []) {
+            if (candidate === keyHash)
+                continue;
+            // Listed once: an entry evicted since is no evidence.
+            const read = await this.store.read(candidate).catch(() => undefined);
+            if (read?.status === 'hit')
+                return candidate;
+        }
+        return undefined;
+    }
+    /** Every replayable entry that records its whole step, by `stepKey`. */
+    async list() {
+        const steps = new Map();
+        for (const keyHash of await this.store.keyHashes()) {
+            const read = await this.store.read(keyHash);
+            if (read.status !== 'hit' || read.entry.payload.truncated === true)
+                continue;
+            const key = read.entry.payload.recordedFor === undefined ? undefined : stepKey(read.entry.payload.recordedFor);
+            if (key !== undefined)
+                steps.set(key, [...(steps.get(key) ?? []), keyHash]);
+        }
+        return steps;
+    }
+}
+/**
+ * The listing `cache.strict` checks a run's misses against, for the file
+ * store only. Undefined when strict is off, the cache is off, or a custom
+ * `cache.store` replaced the file store, which `CacheStore` gives no way to
+ * list.
+ */
+export function storedRecordingsFor(cache) {
+    if (cache.strict === false || cache.mode === 'off' || cache.store !== undefined)
+        return undefined;
+    return new StoredRecordings(new FileCacheStore({ directory: cache.dir, maxBytes: MAX_CACHE_WIRE_BYTES, writable: false }));
+}
+/** The whole step as one map key, or undefined when the provenance does not record all of it. */
+function stepKey(step) {
+    const { testId, targetId, instructionDigest, paramsDigest, callIndex, agent } = step;
+    if (paramsDigest === undefined || callIndex === undefined || agent === undefined)
+        return undefined;
+    return JSON.stringify([testId, targetId, instructionDigest, paramsDigest, callIndex, agent]);
+}

package/dist/cache/relocate.d.ts

@@ -14,7 +14,7 @@
  * means — is exported so end anchors (`anchors.ts`) are checked by the same
  * rules and can never drift from relocation.
  */
-import type { SemanticNode } from '../engine/surface.ts';
+import type { RedactedNode } from '../agent/observation.ts';
 import type { TracePosition, TraceTargetDescriptor } from './trace.ts';
 /**
  * Version of the replay/relocation policy, part of every cache key. Bumping
@@ -22,7 +22,7 @@ import type { TracePosition, TraceTargetDescriptor } from './trace.ts';
  * change, because an entry recorded under different rules could relocate to a
  * different node.
  */
-export declare const REPLAY_POLICY_VERSION = "conservative/5";
+export declare const REPLAY_POLICY_VERSION = "conservative/6";
 /**
  * The share of the viewport a scrolled node must have covered when it was
  * addressed (`ScrollAction.spans`) to scroll as the viewport does once it
@@ -45,14 +45,16 @@ export type RelocationResult = {
     readonly candidates: readonly string[];
 };
 export type DescriptorField = keyof TraceTargetDescriptor;
-export interface DescriptorMatchOptions {
-    readonly redact: (text: string) => string;
-}
-/** A node's descriptor projection alongside its per-observation id. */
-export interface DescribedNode {
-    readonly id: string;
-    readonly descriptor: TraceTargetDescriptor;
-}
+/**
+ * Whether a descriptor can identify a node at all. Role or selector alone
+ * cannot: a wrong match acts on the wrong control, so such a descriptor is
+ * not relocatable and, as an anchor, would prove nothing. An anonymous one
+ * is relocatable by its recorded place only when that place means something
+ * on the next screen: it was the one unnamed control of its role, or it sits
+ * in a named container (`within`) that tells it from its twins. A place
+ * counted among twins with no container is an order, and rows that reorder
+ * would hand the action to the wrong one, so such a target hands off.
+ */
 export declare function isRelocatableDescriptor(descriptor: TraceTargetDescriptor): boolean;
 /**
  * The tiers a recorded descriptor is matched in, strictest first:
@@ -70,8 +72,6 @@ export declare function isRelocatableDescriptor(descriptor: TraceTargetDescripto
 export declare function descriptorTiers(descriptor: TraceTargetDescriptor): readonly TraceTargetDescriptor[];
 /** Every listed field the recording captured must be present and equal on the candidate. */
 export declare function fieldsEqual(recorded: TraceTargetDescriptor, candidate: TraceTargetDescriptor, fields: readonly DescriptorField[]): boolean;
-/** Projects every node of an observation the way the recorder described its targets. */
-export declare function describeNodes(nodes: ReadonlyMap<string, SemanticNode>, options: DescriptorMatchOptions): readonly DescribedNode[];
 /**
  * Relocates one descriptor against the nodes of a fresh observation, tier by
  * tier (`descriptorTiers`), each exactly-one-or-diverge. Ambiguity at any
@@ -81,11 +81,11 @@ export declare function describeNodes(nodes: ReadonlyMap<string, SemanticNode>,
  * same twins and noted which one it acted on, so the same count of twins
  * resolves to the same one; any other count diverges as before.
  */
-export declare function relocateDescriptor(descriptor: TraceTargetDescriptor, nodes: ReadonlyMap<string, SemanticNode>, options: DescriptorMatchOptions): RelocationResult;
+export declare function relocateDescriptor(descriptor: TraceTargetDescriptor, nodes: ReadonlyMap<string, RedactedNode>): RelocationResult;
 /**
  * Where `node` stands among the controls its own description matches on the
  * screen it was acted on, or undefined when the description already names it
  * alone. Recorded with the target so a replay can tell one "Set up" button per
  * card apart without an app change; a distinct label makes it unnecessary.
  */
-export declare function describePosition(node: SemanticNode, within: string | undefined, nodes: ReadonlyMap<string, SemanticNode>, options: DescriptorMatchOptions): TracePosition | undefined;
+export declare function describePosition(node: RedactedNode, within: string | undefined, nodes: ReadonlyMap<string, RedactedNode>): TracePosition | undefined;