e2e 0.16.0 → 0.17.0

package/dist/.build.json

@@ -1 +1 @@
-{"version":"0.16.0"}
+{"version":"0.17.0"}

package/dist/agent/act.js

@@ -29,6 +29,7 @@ import { projectPriorSteps, serializeLedger } from './ledger.js';
 import { instantiateLanguageModel } from './model/sdk.js';
 import { ObservationFeed } from './observation-feed.js';
 import { recordPolicyEvent } from './phases.js';
+import { appLocation } from '../cache/route.js';
 import { OperationQueue } from './operation-queue.js';
 import { StepAccounting } from './step-accounting.js';
 import { failedStepOutcome, StepTraceSession } from './step-cache.js';
@@ -199,7 +200,10 @@ class ActDispatch {
                         name: agent.executor.name,
                         ...(agent.executor.version === undefined ? {} : { version: agent.executor.version }),
                     },
+                    // Redacted already (`dispatchAgentStep`): the key digests the context the executor reads.
+                    agent: { name: agent.name, context: agent.agentContext },
                     redact: runtime.redact,
+                    redactCut: runtime.redactCut,
                     maxActions: this.accounting.maxActions,
                     stepIndex,
                 });
@@ -421,11 +425,10 @@ class ActDispatch {
         const feed = this.feed;
         return {
             get traceEligible() { return feed.traceEligible; },
-            observe: async (mode) => screenOf(await this.feed.probe(mode)),
+            observe: async (mode) => screenOf(await this.feed.probe(mode), this.runtime.app.base?.origin),
             actions: this.dispatcher.actions,
             signal: this.accounting.signal,
             remainingMs: () => this.accounting.remainingMs(),
-            redact: this.runtime.redact,
             replaying: (active) => {
                 this.runtime.steps.replaying(active);
                 this.accounting.replaying(active);
@@ -474,10 +477,10 @@ class ActDispatch {
     }
 }
 /** The replay engine's view of a capture: the nodes, and the viewport a recorded point is checked against. */
-function screenOf(observation) {
+function screenOf(observation, appOrigin) {
     const metadata = {
         viewport: { width: observation.viewport.width, height: observation.viewport.height },
-        ...(observation.path === undefined ? {} : { path: observation.path }),
+        ...(observation.location === undefined ? {} : { path: appLocation(observation.location, appOrigin) }),
     };
     return observation.kind === 'semantic'
         ? { ...metadata, kind: 'semantic', nodes: observation.nodes }

package/dist/agent/action-dispatcher.js

@@ -487,10 +487,10 @@ export class ActionDispatcher {
     }
     async runActionNow(name, body) {
         this.accounting.reserveAction();
-        const redact = this.runtime.redact;
+        const redaction = { redact: this.runtime.redact, redactCut: this.runtime.redactCut };
         let action;
         try {
-            action = await instrumentPhase(this.runtime, { api: this.accounting.api, kind: 'engine', phase: 'agent.action', name }, body, (committed) => ({ detail: describeAction(committed, redact).summary }));
+            action = await instrumentPhase(this.runtime, { api: this.accounting.api, kind: 'engine', phase: 'agent.action', name }, body, (committed) => ({ detail: describeAction(committed, redaction).summary }));
         }
         catch (cause) {
             this.accounting.checkpoint(cause);
@@ -579,9 +579,8 @@ export class ActionDispatcher {
      * number picks the same one.
      */
     placementOf({ node, observation }) {
-        const redact = this.runtime.redact;
-        const within = containerKey(node.ref.id, observation.nodes, observation.parents, redact);
-        const position = describePosition(node, within, observation.nodes, { redact });
+        const within = containerKey(node.ref.id, observation.nodes, observation.parents);
+        const position = describePosition(node, within, observation.nodes);
         return {
             ...(within === undefined ? {} : { within }),
             ...(position === undefined ? {} : { position }),

package/dist/agent/actions.d.ts

@@ -8,51 +8,52 @@
  * the same descriptor projection. One owner for all three, so a recorded
  * summary, a live event line, and a relocation candidate can never drift.
  */
-import type { SemanticNode, ViewportPoint, ViewportSize } from '../engine/surface.ts';
+import type { ViewportPoint, ViewportSize } from '../engine/surface.ts';
+import { type NodeRedaction, type RedactedNode } from './observation.ts';
 import { type NodeActionName, type PointActionName, type TraceTargetDescriptor, type TracePosition } from '../cache/trace.ts';
 import type { ScrollDirection } from '../types.ts';
 /** One committed grammar action, addressed by the node it actually ran against. */
 export type RecordableAction = ({
     readonly name: NodeActionName;
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
 } & Placement) | ({
     readonly name: 'type';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly value: string;
 } & Placement) | ({
     readonly name: 'typeSecret';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly secret: string;
 } & Placement) | ({
     readonly name: 'press';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly key: string;
 } & Placement) | ({
     readonly name: 'select';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly value: string;
 } & Placement) | ({
     readonly name: 'check';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly checked: boolean;
 } & Placement)
 /** Project-relative paths as the executor gave them; replay authorizes them again. */
  | ({
     readonly name: 'upload';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly paths: readonly string[];
 } & Placement)
 /** The dragged node with its placement, and where it was dropped, with its own. */
  | ({
     readonly name: 'drag';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly destination: {
-        readonly node: SemanticNode;
+        readonly node: RedactedNode;
     } & Placement;
 } & Placement) | ({
     readonly name: 'scroll';
     readonly direction: ScrollDirection;
-    readonly node?: SemanticNode;
+    readonly node?: RedactedNode;
     /** The share of the viewport the node covered when scrolled, 0 to 1 (`ScrollAction.spans`). */
     readonly spans?: number;
 } & Placement)
@@ -61,7 +62,7 @@ export type RecordableAction = ({
     readonly name: 'scrollUntil';
     readonly text: string;
     readonly direction: ScrollDirection;
-    readonly node?: SemanticNode;
+    readonly node?: RedactedNode;
     readonly spans?: number;
     /** How many pages it took; in the summary, never in the trace, since a replay pages for itself. */
     readonly screens: number;
@@ -92,7 +93,7 @@ export type RecordableAction = ({
     readonly name: PointActionName;
     readonly point: ViewportPoint;
     readonly viewport: ViewportSize;
-    readonly under?: SemanticNode;
+    readonly under?: RedactedNode;
 };
 /** Where the node sat when it was acted on: its container's key and its place among identical twins. */
 export interface Placement {
@@ -100,14 +101,17 @@ export interface Placement {
     readonly position?: TracePosition;
 }
 /**
- * The key of the nearest named container a node sits in — the first text of
- * its row or list item — when that key says more than the node's own name.
- * Ten rows each with a "Delete" button are ten identical descriptors; "Delete
- * in the row that starts with Budget draft" is one.
+ * The key of the nearest named container a node sits in, the first text of
+ * its row or list item or else the container's own label, when that key says
+ * more than the node's own name. Ten rows each with a "Delete" button are ten
+ * identical descriptors; "Delete in the row that starts with Budget draft" is
+ * one. A row whose only text is its own (`<li>Alpha <button><svg/></li>`)
+ * is keyed by it. Only the nearest container counts: the list around a row
+ * with no text names every row alike, so its key would tell no twin apart.
  */
-export declare function containerKey(id: string, nodes: ReadonlyMap<string, SemanticNode>, parents: ReadonlyMap<string, string>, redact: (text: string) => string): string | undefined;
+export declare function containerKey(id: string, nodes: ReadonlyMap<string, RedactedNode>, parents: ReadonlyMap<string, string>): string | undefined;
 /** Parent id of every non-root node, derived from the tree the node map indexes. */
-export declare function parentsOf(nodes: ReadonlyMap<string, SemanticNode>): ReadonlyMap<string, string>;
+export declare function parentsOf(nodes: ReadonlyMap<string, RedactedNode>): ReadonlyMap<string, string>;
 /** How one committed action reads back: where it acted, and what it did. */
 export interface DescribedAction {
     /**
@@ -124,13 +128,18 @@ export interface DescribedAction {
     /** Where a drag was dropped, described like its target; only a drag has one. */
     readonly destination?: TraceTargetDescriptor;
 }
-/** Describes one committed action for recording and for the live event. */
-export declare function describeAction(action: RecordableAction, redact: (text: string) => string): DescribedAction;
+/**
+ * Describes one committed action for recording and for the live event. Its
+ * nodes pass the ledger again as it is now: a secret resolved after the
+ * capture (inside the action itself) masks what the capture still shows.
+ */
+export declare function describeAction(action: RecordableAction, redaction: NodeRedaction): DescribedAction;
 /**
  * Builds the durable descriptor for one resolved node: the semantic fields
  * replay re-finds it by, plus the engine's structural selector hint (kept as
  * provenance for tuned policies; the conservative relocator ignores it).
  * Values a secure node holds are never part of it — descriptors carry how a
- * node is named, not what it contains.
+ * node is named, not what it contains. The node was redacted with its
+ * observation (`redactNode`), each field in the one-line form read here too.
  */
-export declare function describeTarget(node: SemanticNode, redact: (text: string) => string): TraceTargetDescriptor | undefined;
+export declare function describeTarget(node: RedactedNode): TraceTargetDescriptor | undefined;

package/dist/agent/actions.js

@@ -8,32 +8,33 @@
  * the same descriptor projection. One owner for all three, so a recorded
  * summary, a live event line, and a relocation candidate can never drift.
  */
+import { redactNode } from './observation.js';
 import { bound, isNodeAction, MAX_TRACE_DESCRIPTOR_CHARS, MAX_TRACE_SUMMARY_CHARS, } from '../cache/trace.js';
 import { sanitizeText } from '../internal/errors.js';
-import { normalizeText } from '../internal/text.js';
+import { collapseText } from '../internal/text.js';
 /** Roles whose first text names the thing a control belongs to: a row's key, a list item's title. */
 const CONTAINER_ROLES = new Set(['row', 'listitem', 'article', 'group', 'region', 'dialog', 'tabpanel']);
 /** Longest container key kept. */
 const MAX_WITHIN_CHARS = 80;
 /**
- * The key of the nearest named container a node sits in — the first text of
- * its row or list item — when that key says more than the node's own name.
- * Ten rows each with a "Delete" button are ten identical descriptors; "Delete
- * in the row that starts with Budget draft" is one.
+ * The key of the nearest named container a node sits in, the first text of
+ * its row or list item or else the container's own label, when that key says
+ * more than the node's own name. Ten rows each with a "Delete" button are ten
+ * identical descriptors; "Delete in the row that starts with Budget draft" is
+ * one. A row whose only text is its own (`<li>Alpha <button><svg/></li>`)
+ * is keyed by it. Only the nearest container counts: the list around a row
+ * with no text names every row alike, so its key would tell no twin apart.
  */
-export function containerKey(id, nodes, parents, redact) {
+export function containerKey(id, nodes, parents) {
     const node = nodes.get(id);
     const own = node === undefined ? '' : squash(node.name ?? node.text ?? '');
     let cursor = parents.get(id);
     while (cursor !== undefined) {
         const container = nodes.get(cursor);
         if (container !== undefined && CONTAINER_ROLES.has(container.role ?? '')) {
-            const key = firstLeafText(container);
-            if (key !== undefined) {
-                const clean = bound(redact(sanitizeText(key)).replace(/\s+/g, ' ').trim(), MAX_WITHIN_CHARS);
-                return clean === '' || squash(clean) === own ? undefined : clean;
-            }
-            return undefined;
+            const key = firstLeafText(container) ?? ownLabel(container);
+            const clean = key === undefined ? '' : bound(collapseText(key), MAX_WITHIN_CHARS);
+            return clean === '' || squash(clean) === own ? undefined : clean;
         }
         cursor = parents.get(cursor);
     }
@@ -60,6 +61,11 @@ function firstLeafText(node) {
     }
     return undefined;
 }
+/** A container's own name or text, when it has one. */
+function ownLabel(node) {
+    const label = (node.name ?? node.text ?? '').trim();
+    return label === '' ? undefined : label;
+}
 function squash(text) {
     return text.replace(/\s+/g, ' ').trim().toLowerCase();
 }
@@ -74,16 +80,20 @@ const NODE_ACTION_PROSE = {
 };
 /** How each point verb reads: `tap the point (x, y)`, `hover over the point (x, y)`. */
 const POINT_ACTION_PROSE = { tapAt: 'tap', hoverAt: 'hover over' };
-/** Describes one committed action for recording and for the live event. */
-export function describeAction(action, redact) {
+/**
+ * Describes one committed action for recording and for the live event. Its
+ * nodes pass the ledger again as it is now: a secret resolved after the
+ * capture (inside the action itself) masks what the capture still shows.
+ */
+export function describeAction(action, redaction) {
     const target = 'node' in action
-        ? describePlaced(action.node, action, redact)
+        ? describePlaced(action.node, action, redaction)
         : 'point' in action
-            ? describePlaced(action.under, {}, redact)
+            ? describePlaced(action.under, {}, redaction)
             : undefined;
-    const destination = action.name === 'drag' ? describePlaced(action.destination.node, action.destination, redact) : undefined;
+    const destination = action.name === 'drag' ? describePlaced(action.destination.node, action.destination, redaction) : undefined;
     const where = describeForSummary(target);
-    const safe = (value) => quote(redact(sanitizeText(value)));
+    const safe = (value) => quote(redaction.redact(sanitizeText(value)));
     const prose = (() => {
         if (isNodeAction(action))
             return NODE_ACTION_PROSE[action.name](where);
@@ -134,13 +144,16 @@ export function describeAction(action, redact) {
     };
 }
 /** A node's durable descriptor with the placement it was acted on in; undefined for no node or nothing durable. */
-function describePlaced(node, placement, redact) {
-    const described = node === undefined ? undefined : describeTarget(node, redact);
+function describePlaced(node, placement, redaction) {
+    if (node === undefined)
+        return undefined;
+    const { children: _children, ...fields } = node;
+    const described = describeTarget(redactNode(fields, redaction));
     if (described === undefined)
         return undefined;
     return {
         ...described,
-        ...(placement.within === undefined ? {} : { within: bound(placement.within, MAX_WITHIN_CHARS) }),
+        ...(placement.within === undefined ? {} : { within: bound(redaction.redact(placement.within), MAX_WITHIN_CHARS) }),
         ...(placement.position === undefined ? {} : { position: placement.position }),
     };
 }
@@ -149,13 +162,14 @@ function describePlaced(node, placement, redact) {
  * replay re-finds it by, plus the engine's structural selector hint (kept as
  * provenance for tuned policies; the conservative relocator ignores it).
  * Values a secure node holds are never part of it — descriptors carry how a
- * node is named, not what it contains.
+ * node is named, not what it contains. The node was redacted with its
+ * observation (`redactNode`), each field in the one-line form read here too.
  */
-export function describeTarget(node, redact) {
+export function describeTarget(node) {
     const field = (value) => {
         if (value === undefined)
             return undefined;
-        const collapsed = normalizeText(redact(sanitizeText(value)));
+        const collapsed = collapseText(value);
         return collapsed === '' ? undefined : bound(collapsed, MAX_TRACE_DESCRIPTOR_CHARS);
     };
     const role = field(node.role);

package/dist/agent/model/sdk.js

@@ -9,6 +9,7 @@
 import { withHint } from '../../internal/errors.js';
 import { missingModelError } from '../../config/agent.js';
 import { aiSdk, asSdkLanguageModel, loadAiSdk } from '../ai-sdk.js';
+import { MODEL_REQUEST_HEADERS } from '../../internal/client-identity.js';
 import { packageVersion } from '../../internal/package-version.js';
 import { AgentError } from '../error.js';
 import { isContextOverflow } from './overflow.js';
@@ -75,6 +76,7 @@ export function createModelAdapter(model, agentName = 'default') {
                 maxOutputTokens: call.maxOutputTokens,
                 ...(providerOptions === undefined ? {} : { providerOptions: providerOptions }),
                 maxRetries: TRANSPORT_RETRIES,
+                headers: MODEL_REQUEST_HEADERS,
                 abortSignal: call.signal,
                 timeout: call.timeoutMs,
             };

package/dist/agent/observation-feed.d.ts

@@ -7,24 +7,23 @@
  * executor's redacted view of a capture. Nothing else in the step observes
  * the engine; the dispatcher and the pixel tier ask the feed.
  */
-import type { SemanticNode } from '../engine/surface.ts';
 import type { StepAgentDetails } from '../run/steps.ts';
 import { AgentError } from './error.ts';
 import type { ExecutorObservation, ExecutorObserveOptions, ExecutorTarget } from './executor.ts';
 import type { AgentContext } from './invocation.ts';
-import { type AgentObservation, type SemanticAgentObservation } from './observation.ts';
+import { type AgentObservation, type RedactedNode, type SemanticAgentObservation } from './observation.ts';
 import type { OperationQueue } from './operation-queue.ts';
 import { type SettleMode } from './settle-policy.ts';
 import type { StepAccounting } from './step-accounting.ts';
 /** A target resolved to a node of the observation it was found in. */
 export interface Resolved {
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly observation: SemanticAgentObservation;
 }
 /** What a target names on the newest screen: the id as the screen lists it, the node or nothing, and the screen looked at. */
 export interface Lookup {
     readonly id: string;
-    readonly node: SemanticNode | undefined;
+    readonly node: RedactedNode | undefined;
     readonly observation: SemanticAgentObservation;
 }
 export interface ObservationFeedOptions {
@@ -116,8 +115,8 @@ export declare class ObservationFeed {
      * through the queued observe: this runs inside a queued action body, and a
      * queued observation would wait on its own caller.
      */
-    relocate(stale: SemanticNode): Promise<{
-        node: SemanticNode;
+    relocate(stale: RedactedNode): Promise<{
+        node: RedactedNode;
         observation: SemanticAgentObservation;
     } | undefined>;
     /**

package/dist/agent/observation-feed.js

@@ -132,7 +132,7 @@ export class ObservationFeed {
             ...metadata,
             text: observation.text,
             truncated: observation.truncated,
-            ...(options.tree === true ? { tree: projectTree(observation.tree, this.runtime.redact, this.runtime.app.base?.origin) } : {}),
+            ...(options.tree === true ? { tree: projectTree(observation.tree, this.runtime.app.base?.origin) } : {}),
             ...pixels,
         };
     }
@@ -197,8 +197,7 @@ export class ObservationFeed {
      * queued observation would wait on its own caller.
      */
     async relocate(stale) {
-        const options = { redact: this.runtime.redact };
-        const descriptor = describeTarget(stale, options.redact);
+        const descriptor = describeTarget(stale);
         if (descriptor === undefined)
             return undefined;
         this.accounting.checkpoint();
@@ -206,7 +205,7 @@ export class ObservationFeed {
         this.publish(observation);
         if (observation.kind === 'pixels')
             return undefined;
-        const relocated = relocateDescriptor(descriptor, observation.nodes, options);
+        const relocated = relocateDescriptor(descriptor, observation.nodes);
         if (relocated.kind !== 'found')
             return undefined;
         const node = observation.nodes.get(relocated.id);
@@ -376,11 +375,10 @@ export class ObservationFeed {
         const earlier = this.lastSeen(id)?.node;
         if (earlier === undefined)
             return undefined;
-        const options = { redact: this.runtime.redact };
-        const descriptor = describeTarget(earlier, options.redact);
+        const descriptor = describeTarget(earlier);
         if (descriptor === undefined)
             return undefined;
-        const relocated = relocateDescriptor(descriptor, latest.nodes, options);
+        const relocated = relocateDescriptor(descriptor, latest.nodes);
         return relocated.kind === 'found' ? latest.nodes.get(relocated.id) : undefined;
     }
 }

package/dist/agent/observation.d.ts

@@ -1,14 +1,15 @@
 /** Observation capture, redaction, and model serialization. */
 import type { Observation, SemanticNode, ViewportSize } from '../engine/surface.ts';
+import type { SecretLedger } from '../internal/redact.ts';
 import type { VisionDegradation } from '../run/steps.ts';
 import type { ExecutorNode, ExecutorObservation, ExecutorPixels } from './executor.ts';
 /** Why pixels the caller asked for are not part of this observation. */
 type PixelsWithheld = 'MASKING_UNPROVEN';
 export type AgentObservation = AgentObservationMetadata & ({
     readonly kind: 'semantic';
-    readonly nodes: ReadonlyMap<string, SemanticNode>;
+    readonly nodes: ReadonlyMap<string, RedactedNode>;
     readonly parents: ReadonlyMap<string, string>;
-    readonly tree: SemanticNode;
+    readonly tree: RedactedNode;
     readonly truncated: boolean;
     readonly pixels?: ExecutorPixels | undefined;
     readonly pixelsWithheld?: PixelsWithheld | undefined;
@@ -37,10 +38,11 @@ interface AgentObservationMetadata {
  *
  * Pixels whose masking the engine cannot prove (fewer masked regions than
  * secure nodes) are withheld before they reach a model or disk; the semantic
- * tree never carries secure values. Registered secret values are additionally
- * replaced by their stable secret name, and so is the leading part of one a
- * field the engine cut at its limit ends with. A field holding one keeps no
- * selection, as a secure field keeps none.
+ * tree never carries secure values. Every string of every node is redacted
+ * once, here (`redactNode`): registered secret values are replaced by their
+ * stable secret name, and so is the leading part of one a field the engine
+ * cut at its limit ends with. A field holding one keeps no selection, as a
+ * secure field keeps none.
  */
 export declare function prepareObservation(observation: Observation, options: {
     redact: (text: string) => string;
@@ -52,6 +54,34 @@ export declare function prepareObservation(observation: Observation, options: {
     /** The app base URL's origin: link targets on it render as paths, which navigation resolves against it. */
     appOrigin?: string | undefined;
 }): AgentObservation;
+/** What redacts a node: whole values, and the leading part of one a cut field ends with. */
+export type NodeRedaction = Pick<SecretLedger, 'redact' | 'redactCut'>;
+declare const REDACTED: unique symbol;
+/**
+ * A semantic node every string of which has passed the attempt's secret
+ * ledger (`redactNode`). Model-facing text and executor trees render only
+ * from this shape, so a node no redaction touched cannot reach them.
+ */
+export interface RedactedNode extends Omit<SemanticNode, 'children'> {
+    readonly [REDACTED]: true;
+    readonly children?: readonly RedactedNode[];
+}
+/**
+ * The node and its subtree with every secret taken out of every field
+ * (`NODE_FIELDS`), before any consumer reads it: the model's text, the
+ * executor's tree, cache descriptors and anchors, failure evidence.
+ */
+export declare function redactNode(node: SemanticNode, redaction: NodeRedaction): RedactedNode;
+/**
+ * An earlier capture's nodes redacted again through the ledger as it is now,
+ * each on its own fields, then linked to its redacted-again children, so the
+ * tree keeps its shape (which nodes are leaves) without a subtree redacted
+ * once per ancestor. A secret a provider resolved after the capture masks
+ * text the capture still shows, so the two captures read alike wherever the
+ * screen did not change. Redacting redacted text changes nothing else: a
+ * marker is never read again.
+ */
+export declare function redactNodesAgain(nodes: ReadonlyMap<string, RedactedNode>, redaction: NodeRedaction): ReadonlyMap<string, RedactedNode>;
 /** Phase metrics describe a node count only when the capture actually read nodes. */
 export declare function observationDetail(observation: AgentObservation): {
     count?: number;
@@ -82,21 +112,20 @@ export declare const INTERACTIVE_ROLES: ReadonlySet<string>;
  */
 export declare function interactiveNodeCount(observation: Pick<ExecutorObservation, 'text'>): number;
 /**
- * Projects the raw tree onto the executor-facing node shape: the same
- * redaction the text serialization applies, field by field, and no value or
- * selection at all for a secure node, and a link target bounded as a line
+ * Projects a redacted tree onto the executor-facing node shape, the fields
+ * the text serialization renders, with a link target bounded as a line
  * bounds it: a target on `appOrigin` keeps that origin and loses no more of
  * its path than the line does. Selectors stay behind — they are relocation
  * material for the trace cache, not something a brain reasons about.
  */
-export declare function projectTree(node: SemanticNode, redact: (text: string) => string, appOrigin?: string): ExecutorNode;
+export declare function projectTree(node: RedactedNode, appOrigin?: string): ExecutorNode;
 /**
  * Renders one node as `#id role "name" text="..." value="..." selection="..." [states]`. Role-less text
  * holders omit the role token entirely: on a large screen they are half the
  * lines, and the model needs their text, not a filler word. A link target on
  * `appOrigin`, the app base URL's, renders as its path.
  */
-export declare function formatNode(node: SemanticNode, depth: number, redact: (text: string) => string, appOrigin?: string): string;
+export declare function formatNode(node: RedactedNode, depth: number, appOrigin?: string): string;
 /**
  * What the screen looks like, independent of which observation looked at it.
  *