e2e 0.15.2 → 0.17.0

package/dist/cache/route.js

@@ -4,43 +4,66 @@
  * The replay precondition asks "is the app on the screen this recording
  * began on", and the postcondition "did we land where the recording landed".
  * A URL answers neither directly: it carries the id the app minted for this
- * run's record, the slug of the record the test happened to open, a search
- * term in the query, a tracking parameter, a fragment. All of that changes
- * between two visits to the same screen, and none of it is the screen.
+ * run's record, a cache buster, a session token, a fragment. All of that
+ * changes between two visits to the same screen, and none of it is the
+ * screen.
  *
- * So a location is reduced to its route: the pathname's segments, with every
- * segment that looks minted per record (a uuid, a hex or digit run, a long
- * token mixing letters and digits, text with whitespace) replaced by `:id`;
- * the query and the fragment dropped, except that an app routing in the
- * fragment (`#/companies/1`) routes by that path. A value the call marked
- * with `unique()` needs no rule here: the recording spells it as a
+ * So a location is reduced to its route: the origin it is on, the pathname's
+ * segments, and the query's parameters, with every segment or parameter
+ * value that looks minted per record (a uuid, a hex or digit run, a long
+ * token mixing letters and digits, a prefixed record id, text with
+ * whitespace) replaced by `:id`.
+ * Every other query value is part of the screen: `?mode=unsafe` is not
+ * `?mode=safe`, and `?tab=notes` shows other controls than no tab. The
+ * fragment is dropped, except that an app routing in the fragment
+ * (`#/companies/1`) routes by that path and its query. A value the call
+ * marked with `unique()` needs no rule here: the recording spells it as a
  * placeholder in every spelling a URL gives it, its slug included
  * (`cache/template.ts`), and replay fills in this run's value on both sides.
  *
- * Two routes that still differ in exactly one segment are `undecided`: a slug
- * of a record the runner never saw the value of reads as two literals, and
- * only the screen can say whether they are the same page. At the end of a
- * step the recorded anchors can, because they are the step's own effect. At
- * the start nothing recorded is specific to the screen (the controls a start
- * screen shows are mostly the app's header and sidebar, shared by every
- * screen), so an undecided start is a miss. A device engine reports a screen
- * title in place of a URL, which is already a route and compares as itself.
+ * The origin is relative to the app (`appLocation`): a location on the app's
+ * own origin is kept as its path, so a recording made against one deployment
+ * of the app replays on another that shares its `app.identity`, while a
+ * screen on any other origin keeps its origin and is another route.
+ *
+ * Two routes are the same screen only when they read alike. A literal that
+ * differs, a slug the runner never saw the value of, is another screen at
+ * both ends of a step: nothing recorded can tell a record's slug from a
+ * route word, and a screen that looks alike on another route (a settings
+ * page and a profile page sharing one layout) is exactly where a wrong link
+ * lands. A device engine reports a screen title in place of a URL, which is
+ * already a route and compares as itself.
  */
 const PARAM = ':id';
 /**
  * A segment shaped like a value the app mints per record: a uuid, a hex or
  * digit run, a long token carrying letters and at least two digits (a route
- * word such as `companies-v2` has one), or text with whitespace, which no
- * router puts in a path. A capitalized or dashed word is none of these; two
- * of them differing is left to the screen.
+ * word such as `companies-v2` has one), a prefixed record id (letters, a
+ * dash, then a digit tail of two or more: `PROJ-016`, `INV-2041`; a single
+ * digit as in `page-2` is a route word), or text with whitespace, which no
+ * router puts in a path. Any other capitalized or dashed word is none of
+ * these.
  */
 const MINTED_SEGMENT = [
     /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
     /^[0-9a-f]{8,}$/i,
     /^\d+$/,
     /^(?=(?:[^\d]*\d){2})(?=.*[A-Za-z])[A-Za-z0-9_-]{12,}$/,
+    /^[A-Za-z]+-\d{2,}$/,
     /\s/,
 ];
+/**
+ * A query value is minted on the same rules, with the wider alphabet a
+ * value carries that a path segment cannot: a signed token or a timestamp
+ * (`eyJhbGciOi.x1.y2`, `2026-10-01T10:00:00Z`) has dots, colons, and base64,
+ * and a date (`?from=2026-10-01`, a default an app fills in with today) has
+ * no letter at all.
+ */
+const MINTED_VALUE = [
+    ...MINTED_SEGMENT,
+    /^(?=(?:[^\d]*\d){2})(?=.*[A-Za-z])[\w.~+/=:-]{12,}$/,
+    /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/,
+];
 function decodeSegment(raw) {
     try {
         return decodeURIComponent(raw);
@@ -50,15 +73,30 @@ function decodeSegment(raw) {
     }
 }
 /**
- * The pathname a location routes by, or undefined when the location is not
- * a web address (a device engine's screen title, a browser's own page).
+ * A location as the cache compares it: a URL on the app's own origin as its
+ * path, query, and fragment, so a recording follows the app to another
+ * deployment of it; anything else (another origin, a device screen title)
+ * as it is.
+ */
+export function appLocation(location, appOrigin) {
+    if (appOrigin === undefined || !URL.canParse(location))
+        return location;
+    const url = new URL(location);
+    return url.origin === appOrigin ? `${url.pathname}${url.search}${url.hash}` : location;
+}
+/**
+ * The parts of a location its route is made of, or undefined when the
+ * location is not a web address (a device engine's screen title, a
+ * browser's own page).
  */
-function pathnameOf(location) {
+function locationParts(location) {
+    let origin;
     let rest = location;
     if (URL.canParse(location)) {
         const url = new URL(location);
         if (url.protocol !== 'http:' && url.protocol !== 'https:')
             return undefined;
+        origin = url.origin;
         rest = `${url.pathname}${url.search}${url.hash}`;
     }
     else if (!location.startsWith('/')) {
@@ -66,43 +104,48 @@ function pathnameOf(location) {
     }
     const hashAt = rest.indexOf('#');
     const fragment = hashAt === -1 ? '' : rest.slice(hashAt + 1);
-    const pathname = fragment.startsWith('/') ? fragment : hashAt === -1 ? rest : rest.slice(0, hashAt);
-    return pathname.split('?')[0] ?? '';
+    const [documentPath, documentSearch] = splitOnce(hashAt === -1 ? rest : rest.slice(0, hashAt), '?');
+    if (!fragment.startsWith('/'))
+        return { ...(origin === undefined ? {} : { origin }), pathname: documentPath, search: documentSearch };
+    const [fragmentPath, fragmentSearch] = splitOnce(fragment, '?');
+    return {
+        ...(origin === undefined ? {} : { origin }),
+        pathname: fragmentPath,
+        search: [documentSearch, fragmentSearch].filter((part) => part !== '').join('&'),
+    };
+}
+function splitOnce(text, separator) {
+    const at = text.indexOf(separator);
+    return at === -1 ? [text, ''] : [text.slice(0, at), text.slice(at + 1)];
+}
+/** A query's parameters as route terms, `key=value` with a minted key or value as `:id`, sorted. */
+function queryTerms(search) {
+    const terms = [];
+    for (const [key, value] of new URLSearchParams(search)) {
+        const minted = (text) => text !== '' && MINTED_VALUE.some((pattern) => pattern.test(text));
+        terms.push(`${minted(key) ? PARAM : key}=${minted(value) ? PARAM : value}`);
+    }
+    return terms.toSorted();
 }
 /** The route of a location. */
-export function routeOf(location) {
-    const pathname = pathnameOf(location);
-    if (pathname === undefined)
+function routeOf(location) {
+    const parts = locationParts(location);
+    if (parts === undefined)
         return { kind: 'opaque', location };
-    const segments = pathname
+    const segments = parts.pathname
         .split('/')
         .filter((raw) => raw !== '')
         .map((raw) => {
         const text = decodeSegment(raw);
         return MINTED_SEGMENT.some((pattern) => pattern.test(text)) ? PARAM : text;
     });
-    return { kind: 'url', segments };
+    return { kind: 'url', ...(parts.origin === undefined ? {} : { origin: parts.origin }), segments, query: queryTerms(parts.search) };
 }
-/** A route as one line, for tests and diagnostics: `/companies/:id`, or the opaque location. */
-export function routeKey(route) {
-    return route.kind === 'url' ? `/${route.segments.join('/')}` : route.location;
+/** Whether two locations name the same screen: one origin, and segments and query that read alike. */
+export function sameRoute(recorded, live) {
+    return routeIdentity(routeOf(recorded)) === routeIdentity(routeOf(live));
 }
-/**
- * Whether two routes are the same screen: `same` when they read alike,
- * `undecided` when routes of one depth differ in exactly one segment, which
- * the screen must settle, and `different` otherwise.
- */
-export function compareRoutes(recorded, live) {
-    if (recorded.kind === 'opaque' || live.kind === 'opaque') {
-        return recorded.kind === 'opaque' && live.kind === 'opaque' && recorded.location === live.location ? 'same' : 'different';
-    }
-    if (recorded.segments.length !== live.segments.length)
-        return 'different';
-    let differing = 0;
-    for (const [index, segment] of recorded.segments.entries()) {
-        if (segment !== live.segments[index])
-            differing += 1;
-    }
-    return differing === 0 ? 'same' : differing === 1 ? 'undecided' : 'different';
+/** A route's parts as one comparable string, a slash inside a segment kept inside it. */
+function routeIdentity(route) {
+    return JSON.stringify(route.kind === 'opaque' ? [route.location] : [route.origin ?? null, route.segments, route.query]);
 }
-//# sourceMappingURL=route.js.map

package/dist/cache/store.d.ts

@@ -59,6 +59,12 @@ export declare class FileCacheStore implements CacheStore {
         bytes: number;
     } | undefined>;
     delete(keyHash: string): Promise<void>;
+    /**
+     * The key hashes of the digest-named files in the directory, readable or
+     * not; none when the directory does not exist. Not part of `CacheStore`:
+     * only `cache.strict` lists a store, and only this one.
+     */
+    keyHashes(): Promise<string[]>;
     /**
      * Resolves one entry path. The key hash is the only caller-supplied path
      * component and must be a bare digest, so traversal is impossible by
@@ -66,4 +72,3 @@ export declare class FileCacheStore implements CacheStore {
      */
     private entryPath;
 }
-//# sourceMappingURL=store.d.ts.map

package/dist/cache/store.js

@@ -13,7 +13,7 @@
  * The interface exists so a remote store — the cloud's shared cache — can
  * replace the filesystem without the harness noticing.
  */
-import { mkdir, readFile, stat, unlink } from 'node:fs/promises';
+import { mkdir, readdir, readFile, stat, unlink } from 'node:fs/promises';
 import { join } from 'node:path';
 import { writeFileAtomic } from '../internal/atomic-write.js';
 import { errorMessage } from '../internal/errors.js';
@@ -83,6 +83,26 @@ export class FileCacheStore {
             return;
         await unlink(path).catch(() => undefined);
     }
+    /**
+     * The key hashes of the digest-named files in the directory, readable or
+     * not; none when the directory does not exist. Not part of `CacheStore`:
+     * only `cache.strict` lists a store, and only this one.
+     */
+    async keyHashes() {
+        let names;
+        try {
+            names = await readdir(this.directory);
+        }
+        catch (cause) {
+            if (cause.code === 'ENOENT')
+                return [];
+            throw cause;
+        }
+        return names.flatMap((name) => {
+            const keyHash = name.endsWith('.json') ? name.slice(0, -'.json'.length) : undefined;
+            return keyHash !== undefined && KEY_HASH.test(keyHash) ? [keyHash] : [];
+        });
+    }
     /**
      * Resolves one entry path. The key hash is the only caller-supplied path
      * component and must be a bare digest, so traversal is impossible by
@@ -92,4 +112,3 @@ export class FileCacheStore {
         return KEY_HASH.test(keyHash) ? join(this.directory, `${keyHash}.json`) : undefined;
     }
 }
-//# sourceMappingURL=store.js.map

package/dist/cache/template.d.ts

@@ -81,4 +81,3 @@ export declare function templateTrace(trace: ActionTrace, templates: readonly Pa
  * or undefined when the entry names a parameter this call did not mark.
  */
 export declare function expandTrace(trace: ActionTrace, templates: readonly ParamTemplate[]): ActionTrace | undefined;
-//# sourceMappingURL=template.d.ts.map

package/dist/cache/template.js

@@ -250,4 +250,3 @@ export function expandTrace(trace, templates) {
     const values = new Map(templates.map((template) => [template.pointer, template.value]));
     return mapTraceText(trace, (text) => expandText(text, values));
 }
-//# sourceMappingURL=template.js.map

package/dist/cache/trace.d.ts

@@ -32,26 +32,36 @@ export declare const MAX_TRACE_INPUT_CHARS = 4096;
 /** Caps prose at `maxChars`, marking the cut with an ellipsis. */
 export declare function bound(text: string, maxChars: number): string;
 /**
- * Cap on recorded end anchors. Anchors are the step's own delta — what
- * appeared on screen between the first observation and the passing one — so
- * a same-screen mutation rarely has more than a handful; a step that changes
- * the whole screen keeps the first few in document order.
+ * Cap on recorded anchors, per side of the delta. Anchors are the step's own
+ * delta, what appeared on screen between the first observation and the
+ * passing one and what vanished, so a same-screen mutation rarely has more
+ * than a handful; a step that changes the whole screen keeps the first few,
+ * announcements first (`cache/anchors.ts`).
  */
 export declare const MAX_TRACE_ANCHORS = 8;
 /** Longest a replay waits for the recorded end state to return. */
 export declare const MAX_TRACE_END_WAIT_MS = 120000;
 /**
  * What a trace was recorded for, in the terms a person uses: the test, the
- * target, and the digest of the instruction. None of it is replay input —
- * every one of these fields is already in the key, so a mismatch is a miss
- * before an entry is ever read — and none of it is trusted as such. It exists
- * so a file named after a digest can say which test it belongs to.
+ * target, the digest of the instruction, and, on entries recorded since they
+ * were added, the rest of what names the step within its test. None of it is
+ * replay input — every one of these fields is already in the key, so a
+ * mismatch is a miss before an entry is ever read — and none of it is trusted
+ * as such. It exists so a file named after a digest can say which step it
+ * belongs to, and so `cache.strict` can tell a step whose key changed under
+ * its recording from a step that was never recorded.
  */
 export interface TraceProvenance {
     readonly testId: string;
     readonly targetId: string;
     /** SHA-256 of the normalized instruction (`cache/identity.ts`). */
     readonly instructionDigest: string;
+    /** SHA-256/JCS of the step's params as the key digests them, a placeholder for each `unique()` value. */
+    readonly paramsDigest?: string;
+    /** Zero-based occurrence of the step among its repeats in the attempt. */
+    readonly callIndex?: number;
+    /** Name of the configured agent the step ran with. */
+    readonly agent?: string;
 }
 /**
  * How a recorded action addressed its node, independent of observation ids.
@@ -82,7 +92,23 @@ export interface TraceTargetDescriptor {
      * twin that appeared or vanished still diverges instead of guessing.
      */
     readonly position?: TracePosition;
+    /**
+     * An anchor's states that were on, sorted; anchors only. A switch turned
+     * on is the same control before and after, so its state is what tells
+     * the step's effect from a tap that did nothing.
+     */
+    readonly states?: readonly TraceAnchorState[];
+    /**
+     * An anchor's current input value, redacted and bounded like its text;
+     * anchors only, and never a secure field's, which is never observed. A
+     * field typed into or an option selected is the same control before and
+     * after, so its value is the step's effect.
+     */
+    readonly value?: string;
 }
+/** The node states an anchor records: the ones a step sets on a control it leaves on screen. */
+export declare const TRACE_ANCHOR_STATES: readonly ['checked', 'expanded', 'pressed', 'selected'];
+export type TraceAnchorState = (typeof TRACE_ANCHOR_STATES)[number];
 interface ActionBase {
     /** One-line prose summary — the only view a mid-step hand-off notice shows. */
     readonly summary: string;
@@ -245,7 +271,7 @@ export interface ToolGapAction extends ActionBase {
 export type RecordedAction = NodeAction | TypeAction | TypeSecretAction | PressAction | SelectAction | CheckAction | UploadAction | DragAction | ScrollAction | ScrollUntilAction | NavigateAction | BackAction | PointAction | TypeTextAction | PressKeyAction | DismissKeyboardAction | ToolGapAction;
 export interface ActionTrace {
     readonly actions: readonly RecordedAction[];
-    /** Executor that produced the trace — provenance, never part of the key (OQ10). */
+    /** Executor that produced the trace: provenance, never part of the key, which names the agent instead. */
     readonly executor: {
         readonly name: string;
         readonly version?: string;
@@ -254,12 +280,17 @@ export interface ActionTrace {
     readonly recordedFor?: TraceProvenance;
     /** The recorded run's verdict summary. */
     readonly summary: string;
-    /** Location path when the step began; a precondition unless the trace opens with navigate. */
+    /**
+     * Location when the step began, as the cache compares it (`appLocation`):
+     * a path on the app's own origin, else the whole location. A precondition
+     * unless the trace opens with navigate.
+     */
     readonly startPath?: string;
     /**
-     * Location path when the step passed — the trace's deterministic postcondition.
-     * A full replay self-finalizes only while the live pathname still matches;
-     * a recorded flow whose destination changed hands off instead of passing.
+     * Location when the step passed, spelled like `startPath`: the trace's
+     * deterministic postcondition. A full replay self-finalizes only while
+     * the live route still matches; a recorded flow whose destination changed
+     * hands off instead of passing.
      */
     readonly endPath?: string;
     /**
@@ -271,6 +302,14 @@ export interface ActionTrace {
      * instead of passing on mechanics alone.
      */
     readonly endAnchors?: readonly TraceTargetDescriptor[];
+    /**
+     * Descriptors of nodes that were on screen when the step began and were
+     * gone when it passed: a delete, a dismissed dialog, a cleared draft. A
+     * full replay self-finalizes only while every one of them is gone again,
+     * so a removal that did not happen hands off instead of passing with no
+     * anchor to check.
+     */
+    readonly goneAnchors?: readonly TraceTargetDescriptor[];
     /**
      * How long the recorded run took from its first action to its passing
      * verdict, plus a margin. A replay waits up to this long for the anchors to
@@ -295,7 +334,7 @@ export declare function buildTraceEntry(payload: ActionTrace): TraceEntry;
  */
 export declare function readTraceEntry(document: unknown): TraceEntry | undefined;
 /** Every field of a target descriptor; two descriptors equal on all of them name the same target. */
-export declare const DESCRIPTOR_FIELDS: readonly ['role', 'name', 'text', 'testId', 'placeholder', 'selector', 'inputPurpose', 'within'];
+export declare const DESCRIPTOR_FIELDS: readonly ['role', 'name', 'text', 'testId', 'placeholder', 'selector', 'inputPurpose', 'within', 'value'];
 /** A string rewrite; `undefined` means the text cannot be rewritten and the whole trace is unusable. */
 export type TraceTextMap = (text: string) => string | undefined;
 /**
@@ -308,4 +347,3 @@ export type TraceTextMap = (text: string) => string | undefined;
  */
 export declare function mapTraceText(trace: ActionTrace, map: TraceTextMap): ActionTrace | undefined;
 export {};
-//# sourceMappingURL=trace.d.ts.map

package/dist/cache/trace.js

@@ -34,10 +34,11 @@ export function bound(text, maxChars) {
     return text.length <= maxChars ? text : `${text.slice(0, maxChars - 1)}…`;
 }
 /**
- * Cap on recorded end anchors. Anchors are the step's own delta — what
- * appeared on screen between the first observation and the passing one — so
- * a same-screen mutation rarely has more than a handful; a step that changes
- * the whole screen keeps the first few in document order.
+ * Cap on recorded anchors, per side of the delta. Anchors are the step's own
+ * delta, what appeared on screen between the first observation and the
+ * passing one and what vanished, so a same-screen mutation rarely has more
+ * than a handful; a step that changes the whole screen keeps the first few,
+ * announcements first (`cache/anchors.ts`).
  */
 export const MAX_TRACE_ANCHORS = 8;
 /** Longest a replay waits for the recorded end state to return. */
@@ -66,6 +67,9 @@ function each(items, read) {
 const SHA256_HEX = /^[a-f0-9]{64}$/u;
 /** Most twins a positional recording distinguishes between; beyond it a list is data, not a control set. */
 const MAX_TRACE_POSITION_OF = 1000;
+/** The node states an anchor records: the ones a step sets on a control it leaves on screen. */
+export const TRACE_ANCHOR_STATES = ['checked', 'expanded', 'pressed', 'selected'];
+const isTraceAnchorState = oneOf(TRACE_ANCHOR_STATES);
 /** The verbs that act on one node and carry no input: tap and its variants, hover, scroll into view. */
 const NODE_ACTION_NAMES = ['tap', 'doubleTap', 'longPress', 'secondaryTap', 'hover', 'scrollTo'];
 const isNodeActionName = oneOf(NODE_ACTION_NAMES);
@@ -131,18 +135,13 @@ function readActionTrace(document) {
     const summary = readBoundedText(raw['summary'], MAX_TRACE_SUMMARY_CHARS);
     if (summary === undefined)
         return undefined;
-    const startPath = raw['startPath'];
-    if (startPath !== undefined) {
-        if (typeof startPath !== 'string' || startPath === '' || startPath.length > MAX_TRACE_DESCRIPTOR_CHARS) {
-            return undefined;
-        }
-    }
-    const endPath = raw['endPath'];
-    if (endPath !== undefined) {
-        if (typeof endPath !== 'string' || endPath === '' || endPath.length > MAX_TRACE_DESCRIPTOR_CHARS) {
-            return undefined;
-        }
-    }
+    // A location is a replay precondition, kept whole like a typed value.
+    const startPath = raw['startPath'] === undefined ? undefined : readInputText(raw['startPath']);
+    if (raw['startPath'] !== undefined && startPath === undefined)
+        return undefined;
+    const endPath = raw['endPath'] === undefined ? undefined : readInputText(raw['endPath']);
+    if (raw['endPath'] !== undefined && endPath === undefined)
+        return undefined;
     const truncated = raw['truncated'];
     if (truncated !== undefined && typeof truncated !== 'boolean')
         return undefined;
@@ -151,15 +150,12 @@ function readActionTrace(document) {
         (typeof endWaitMs !== 'number' || !Number.isInteger(endWaitMs) || endWaitMs < 0 || endWaitMs > MAX_TRACE_END_WAIT_MS)) {
         return undefined;
     }
-    const anchorsRaw = raw['endAnchors'];
-    let endAnchors;
-    if (anchorsRaw !== undefined) {
-        if (!Array.isArray(anchorsRaw) || anchorsRaw.length > MAX_TRACE_ANCHORS)
-            return undefined;
-        endAnchors = each(anchorsRaw, readDescriptor);
-        if (endAnchors === undefined)
-            return undefined;
-    }
+    const endAnchors = readAnchors(raw['endAnchors']);
+    if (endAnchors === undefined)
+        return undefined;
+    const goneAnchors = readAnchors(raw['goneAnchors']);
+    if (goneAnchors === undefined)
+        return undefined;
     const actionsRaw = raw['actions'];
     if (!Array.isArray(actionsRaw) || actionsRaw.length === 0 || actionsRaw.length > MAX_TRACE_ACTIONS) {
         return undefined;
@@ -177,11 +173,20 @@ function readActionTrace(document) {
         summary,
         ...(startPath === undefined ? {} : { startPath }),
         ...(endPath === undefined ? {} : { endPath }),
-        ...(endAnchors === undefined || endAnchors.length === 0 ? {} : { endAnchors }),
+        ...(endAnchors.length === 0 ? {} : { endAnchors }),
+        ...(goneAnchors.length === 0 ? {} : { goneAnchors }),
         ...(endWaitMs === undefined ? {} : { endWaitMs }),
         ...(truncated === undefined ? {} : { truncated }),
     };
 }
+/** One side of the recorded delta: absent reads as empty, anything malformed or over the cap as undefined. */
+function readAnchors(document) {
+    if (document === undefined)
+        return [];
+    if (!Array.isArray(document) || document.length > MAX_TRACE_ANCHORS)
+        return undefined;
+    return each(document, readDescriptor);
+}
 function readRecordedAction(document) {
     if (typeof document !== 'object' || document === null || Array.isArray(document)) {
         return undefined;
@@ -370,13 +375,14 @@ export const DESCRIPTOR_FIELDS = [
     'selector',
     'inputPurpose',
     'within',
+    'value',
 ];
 /**
  * The descriptor fields that carry text read off the screen, where a value
  * a test supplied can reappear. `role`, `selector`, and `inputPurpose` are
  * vocabulary, never screen text.
  */
-const DESCRIPTOR_TEXT_FIELDS = ['name', 'text', 'testId', 'placeholder', 'within'];
+const DESCRIPTOR_TEXT_FIELDS = ['name', 'text', 'testId', 'placeholder', 'within', 'value'];
 function mapDescriptorText(descriptor, map) {
     const changes = {};
     for (const field of DESCRIPTOR_TEXT_FIELDS) {
@@ -486,6 +492,9 @@ export function mapTraceText(trace, map) {
     const endAnchors = trace.endAnchors === undefined ? undefined : mapDescriptors(trace.endAnchors, map);
     if (trace.endAnchors !== undefined && endAnchors === undefined)
         return undefined;
+    const goneAnchors = trace.goneAnchors === undefined ? undefined : mapDescriptors(trace.goneAnchors, map);
+    if (trace.goneAnchors !== undefined && goneAnchors === undefined)
+        return undefined;
     return {
         ...trace,
         actions,
@@ -493,6 +502,7 @@ export function mapTraceText(trace, map) {
         ...(startPath === undefined ? {} : { startPath }),
         ...(endPath === undefined ? {} : { endPath }),
         ...(endAnchors === undefined ? {} : { endAnchors }),
+        ...(goneAnchors === undefined ? {} : { goneAnchors }),
     };
 }
 function mapDescriptors(descriptors, map) {
@@ -521,8 +531,23 @@ function readDescriptor(document) {
             return undefined;
         descriptor['position'] = position;
     }
+    if (raw['states'] !== undefined) {
+        const states = readStates(raw['states']);
+        if (states === undefined)
+            return undefined;
+        descriptor['states'] = states;
+    }
     return descriptor;
 }
+/** Known anchor states, each once, in sorted order, as `anchors.ts` writes them; an empty list is never written. */
+function readStates(document) {
+    if (!Array.isArray(document) || document.length === 0)
+        return undefined;
+    const states = each(document, (state) => (isTraceAnchorState(state) ? state : undefined));
+    if (states === undefined)
+        return undefined;
+    return states.every((state, index) => index === 0 || states[index - 1] < state) ? states : undefined;
+}
 /** A well-formed position: two safe integers with the index inside the count. */
 function readPosition(document) {
     if (typeof document !== 'object' || document === null || Array.isArray(document))
@@ -549,7 +574,24 @@ function readProvenance(document) {
         return undefined;
     if (typeof instructionDigest !== 'string' || !SHA256_HEX.test(instructionDigest))
         return undefined;
-    return { testId, targetId, instructionDigest };
+    const paramsDigest = raw['paramsDigest'];
+    if (paramsDigest !== undefined && (typeof paramsDigest !== 'string' || !SHA256_HEX.test(paramsDigest)))
+        return undefined;
+    const callIndex = raw['callIndex'];
+    if (callIndex !== undefined && (typeof callIndex !== 'number' || !Number.isSafeInteger(callIndex) || callIndex < 0)) {
+        return undefined;
+    }
+    const agent = raw['agent'] === undefined ? undefined : readBoundedText(raw['agent'], MAX_TRACE_DESCRIPTOR_CHARS);
+    if (raw['agent'] !== undefined && agent === undefined)
+        return undefined;
+    return {
+        testId,
+        targetId,
+        instructionDigest,
+        ...(paramsDigest === undefined ? {} : { paramsDigest }),
+        ...(callIndex === undefined ? {} : { callIndex }),
+        ...(agent === undefined ? {} : { agent }),
+    };
 }
 function readBoundedText(value, maxChars) {
     if (typeof value !== 'string' || value.trim() === '' || value.length > maxChars) {
@@ -570,4 +612,3 @@ function readInputText(value) {
     }
     return value;
 }
-//# sourceMappingURL=trace.js.map

package/dist/cli/bin.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=bin.d.ts.map

package/dist/cli/bin.js

@@ -9,4 +9,3 @@ if (unsupported !== undefined) {
 }
 const { main } = await import('./index.js');
 await main(process.argv);
-//# sourceMappingURL=bin.js.map

package/dist/cli/cache.d.ts

@@ -22,4 +22,3 @@ export interface CacheOptions {
  * otherwise — an empty or absent cache is a fact, not a failure.
  */
 export declare function cache(command: CacheCommand, options?: CacheOptions): Promise<number>;
-//# sourceMappingURL=cache.d.ts.map

package/dist/cli/cache.js

@@ -246,4 +246,3 @@ function formatBytes(bytes) {
         return `${kib.toFixed(1)} KiB`;
     return `${(kib / 1024).toFixed(1)} MiB`;
 }
-//# sourceMappingURL=cache.js.map

package/dist/cli/docs-url.d.ts

@@ -1,3 +1,2 @@
 /** Root of the published documentation site. */
 export declare const DOCS_URL = "https://e2e.tester.army/docs";
-//# sourceMappingURL=docs-url.d.ts.map

package/dist/cli/docs-url.js

@@ -1,3 +1,2 @@
 /** Root of the published documentation site. */
 export const DOCS_URL = 'https://e2e.tester.army/docs';
-//# sourceMappingURL=docs-url.js.map

package/dist/cli/feedback.d.ts

@@ -46,4 +46,3 @@ export interface FeedbackOptions {
  * so the message names the reference and never claims nothing arrived.
  */
 export declare function feedback(report: FeedbackReport, options: FeedbackOptions): Promise<number>;
-//# sourceMappingURL=feedback.d.ts.map

package/dist/cli/feedback.js

@@ -110,4 +110,3 @@ export async function feedback(report, options) {
     process.stdout.write(`Feedback sent to the e2e team, thank you. Reference: ${event.uuid}\n`);
     return 0;
 }
-//# sourceMappingURL=feedback.js.map

package/dist/cli/guide.d.ts

@@ -1,4 +1,3 @@
 /** `e2e guide`: prints the bundled agent skill for agents and people who do not have it installed. */
 /** Prints the overview or one topic to stdout; an unknown topic exits 2. */
 export declare function guide(topic: string | undefined): number;
-//# sourceMappingURL=guide.d.ts.map

package/dist/cli/guide.js

@@ -13,4 +13,3 @@ export function guide(topic) {
     process.stdout.write(text.endsWith('\n') ? text : `${text}\n`);
     return 0;
 }
-//# sourceMappingURL=guide.js.map