@jini-ai/agentic 0.4.1 → 0.4.3

package/dist/capability.js

@@ -0,0 +1,79 @@
+/**
+ * @module capability
+ *
+ * The vocabulary every agent-drivable surface shares: what an outside caller may ask a
+ * frontend to do, described as pure data with no transport, DOM, or framework attached.
+ *
+ * One noun, deliberately: **capability**. The chat pane's first draft used `tool` in its
+ * type names and `capability` in its ids, which forked the vocabulary across four files.
+ * `tool` stays reserved for the engine's own `ToolRegistry`/`ToolExecutor` nouns; anything
+ * an outside caller asks a *frontend* to do is a capability. Transports may of course
+ * present capabilities as MCP tools — that is a projection, not a rename.
+ */
+/**
+ * Looks a capability up by id.
+ *
+ * @param capabilities - The manifest to search.
+ * @param id - Capability id to resolve.
+ * @returns The definition, or `undefined` when the id is not in the manifest.
+ */
+export function findCapability(capabilities, id) {
+    return capabilities.find((capability) => capability.id === id);
+}
+/**
+ * Checks caller input against a capability's declared schema.
+ *
+ * Manifests advertise `additionalProperties: false` and a `required` list, but nothing was
+ * enforcing either — handlers read the fields they knew about and ignored the rest, so a
+ * misnamed argument silently became a missing one. This closes that for any surface that calls
+ * it. Intentionally a shallow check, not a JSON Schema engine: these schemas are flat by
+ * construction, and a real validator is a dependency this package will not take.
+ *
+ * @param capability - The capability being invoked.
+ * @param input - Raw caller-supplied arguments.
+ * @returns An error message, or `null` when the input is acceptable.
+ */
+export function findCapabilityInputError(capability, input) {
+    const { properties, required, additionalProperties } = capability.inputSchema;
+    for (const name of required ?? []) {
+        if (input[name] === undefined)
+            return `"${name}" is required`;
+    }
+    if (additionalProperties === false) {
+        // `key in properties` walks the whole prototype chain, so a key that happens to be inherited
+        // from Object.prototype (`__proto__`, `constructor`, `toString`, `valueOf`, …) reads as
+        // "known" regardless of whether the schema actually lists it — `'constructor' in {}` is
+        // true even on an empty object. `JSON.parse('{"__proto__":...}')` creates a real own data
+        // property (not the accessor), so this was a live way for such a key to escape the
+        // "unknown argument" refusal entirely. hasOwnProperty ignores the prototype chain, so only
+        // keys the schema actually declares count as known.
+        const unknown = Object.keys(input)
+            .filter((key) => !Object.prototype.hasOwnProperty.call(properties, key));
+        if (unknown.length > 0) {
+            return `unknown ${unknown.length === 1 ? 'argument' : 'arguments'}: ${unknown.sort().join(', ')}`;
+        }
+    }
+    for (const [name, schema] of Object.entries(properties)) {
+        const value = input[name];
+        if (value === undefined)
+            continue;
+        const actual = Array.isArray(value) ? 'array' : typeof value;
+        if (actual !== schema.type)
+            return `"${name}" must be a ${schema.type}, received ${actual}`;
+        if (schema.enum !== undefined && !schema.enum.includes(value)) {
+            return `"${name}" must be one of: ${schema.enum.join(', ')}`;
+        }
+    }
+    return null;
+}
+/**
+ * The capabilities a caller may use given what is currently connected.
+ *
+ * @param capabilities - The full manifest.
+ * @param hasSession - Whether a live frontend session is attached.
+ * @returns Only the capabilities that can actually be satisfied right now.
+ */
+export function availableCapabilities(capabilities, hasSession) {
+    return hasSession ? capabilities : capabilities.filter((c) => c.surface === 'server');
+}
+//# sourceMappingURL=capability.js.map

package/dist/core/a2ui/index.d.ts

@@ -1,10 +1,6 @@
-/**
- * @module @jini-ai/a2ui
- *
- * A2UI ("Agent-to-UI") v1.0 wire types + a minimal client-side interpreter — see each module's
- * own doc for detail, and `archived provenance ledger` for provenance, verified-against-primary-source notes,
- * and the honest gap list against full v1.0 spec parity.
- */
+/** @module @jini-ai/a2ui
+ * A2UI v1.0 wire types and a minimal client interpreter. Each module documents its supported
+ * contract and gaps; these exports do not imply full v1.0 interpreter parity. */
 export * from './common-types.js';
 export * from './agent-to-renderer.js';
 export * from './renderer-to-agent.js';
@@ -13,4 +9,5 @@ export * from './json-pointer.js';
 export * from './resolve.js';
 export * from './tree.js';
 export * from './interpreter.js';
+export * from './surface-properties.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/a2ui/index.js

@@ -1,10 +1,6 @@
-/**
- * @module @jini-ai/a2ui
- *
- * A2UI ("Agent-to-UI") v1.0 wire types + a minimal client-side interpreter — see each module's
- * own doc for detail, and `archived provenance ledger` for provenance, verified-against-primary-source notes,
- * and the honest gap list against full v1.0 spec parity.
- */
+/** @module @jini-ai/a2ui
+ * A2UI v1.0 wire types and a minimal client interpreter. Each module documents its supported
+ * contract and gaps; these exports do not imply full v1.0 interpreter parity. */
 export * from './common-types.js';
 export * from './agent-to-renderer.js';
 export * from './renderer-to-agent.js';
@@ -13,4 +9,5 @@ export * from './json-pointer.js';
 export * from './resolve.js';
 export * from './tree.js';
 export * from './interpreter.js';
+export * from './surface-properties.js';
 //# sourceMappingURL=index.js.map

package/dist/core/a2ui/interpreter.d.ts

@@ -4,7 +4,7 @@ import { WireComponentSchema } from './agent-to-renderer.js';
 import type { RendererToAgentMessage } from './renderer-to-agent.js';
 import { type Catalog } from './catalog.js';
 import { resolveDynamicValue } from './resolve.js';
-import { type DynamicValue, type LocalFunctionAction } from './common-types.js';
+import type { DynamicValue, LocalFunctionAction } from './common-types.js';
 export interface ComponentInstance {
     readonly id: string;
     readonly component: string;

package/dist/core/a2ui/interpreter.js

@@ -46,7 +46,6 @@ import { buildActionMessage, buildFunctionResponseMessage, buildGenericErrorMess
 import { setAtPointer } from './json-pointer.js';
 import { isComponentAllowed } from './catalog.js';
 import { resolveDynamicValue } from './resolve.js';
-import {} from './common-types.js';
 /**
  * Best-effort `surfaceId` extraction from a raw envelope's message-type-keyed body, without
  * assuming the envelope is well-formed. Used only to attribute a parse failure to a surface when

package/dist/core/a2ui/surface-properties.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @module surface-properties
+ *
+ * Reading facts about a surface off the raw wire messages, without an interpreter.
+ *
+ * Why a display-only marker: a host's chat pane treats a surface that arrives while its tool call is
+ * still open as a question the person must answer ("Waiting for your answer above"). That is right
+ * for a form or a choice, and wrong for a chart a tool draws and then holds its call open only to
+ * hear whether the browser refused it (host demo V3, 2026-10-05). The tool that emits the surface is
+ * the only party that knows which it is, so it says so on `createSurface.surfaceProperties`, which
+ * the v1.0 schema already accepts as an open record; renderers ignore the key.
+ */
+/** `createSurface.surfaceProperties` key: `true` means the surface shows something and asks nothing. */
+export declare const A2UI_DISPLAY_ONLY_PROPERTY = "displayOnly";
+/**
+ * The `surfaceId` a surface-scoped message (create/update components/update data/delete) names, or
+ * `undefined` for any other message or a malformed value. Never throws.
+ *
+ * @complexity O(1).
+ */
+export declare function a2uiSurfaceIdOf({ message }: {
+    message: unknown;
+}): string | undefined;
+/**
+ * The `surfaceId` of a `createSurface` that declares {@link A2UI_DISPLAY_ONLY_PROPERTY} `true`, else
+ * `undefined`. Only `createSurface` carries surface properties, so a caller folding a stream records
+ * the id here and matches later messages with {@link a2uiSurfaceIdOf}.
+ *
+ * @complexity O(1).
+ */
+export declare function displayOnlySurfaceIdOf({ message }: {
+    message: unknown;
+}): string | undefined;
+//# sourceMappingURL=surface-properties.d.ts.map

package/dist/core/a2ui/surface-properties.js

@@ -0,0 +1,49 @@
+/**
+ * @module surface-properties
+ *
+ * Reading facts about a surface off the raw wire messages, without an interpreter.
+ *
+ * Why a display-only marker: a host's chat pane treats a surface that arrives while its tool call is
+ * still open as a question the person must answer ("Waiting for your answer above"). That is right
+ * for a form or a choice, and wrong for a chart a tool draws and then holds its call open only to
+ * hear whether the browser refused it (host demo V3, 2026-10-05). The tool that emits the surface is
+ * the only party that knows which it is, so it says so on `createSurface.surfaceProperties`, which
+ * the v1.0 schema already accepts as an open record; renderers ignore the key.
+ */
+/** `createSurface.surfaceProperties` key: `true` means the surface shows something and asks nothing. */
+export const A2UI_DISPLAY_ONLY_PROPERTY = 'displayOnly';
+const SURFACE_SCOPED_KEYS = ['createSurface', 'updateComponents', 'updateDataModel', 'deleteSurface'];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * The `surfaceId` a surface-scoped message (create/update components/update data/delete) names, or
+ * `undefined` for any other message or a malformed value. Never throws.
+ *
+ * @complexity O(1).
+ */
+export function a2uiSurfaceIdOf({ message }) {
+    if (!isRecord(message))
+        return undefined;
+    for (const key of SURFACE_SCOPED_KEYS) {
+        const body = message[key];
+        if (isRecord(body) && typeof body.surfaceId === 'string')
+            return body.surfaceId;
+    }
+    return undefined;
+}
+/**
+ * The `surfaceId` of a `createSurface` that declares {@link A2UI_DISPLAY_ONLY_PROPERTY} `true`, else
+ * `undefined`. Only `createSurface` carries surface properties, so a caller folding a stream records
+ * the id here and matches later messages with {@link a2uiSurfaceIdOf}.
+ *
+ * @complexity O(1).
+ */
+export function displayOnlySurfaceIdOf({ message }) {
+    const body = isRecord(message) ? message.createSurface : undefined;
+    if (!isRecord(body) || typeof body.surfaceId !== 'string')
+        return undefined;
+    const properties = body.surfaceProperties;
+    return isRecord(properties) && properties[A2UI_DISPLAY_ONLY_PROPERTY] === true ? body.surfaceId : undefined;
+}
+//# sourceMappingURL=surface-properties.js.map

package/dist/core/dom/index.d.ts

@@ -3,15 +3,10 @@
  *
  * The one `PageDriver` (see `@jini-ai/agentic`'s `page-driver.ts`) that reads and writes a real DOM
  * subtree. Split into its own entry point, compiled under its own `DOM`-lib `tsconfig.dom.json`,
- * so the rest of this package can stay provably DOM-free — see archived provenance ledger's "The DOM split".
- *
- * `@jini-ai/chat-react` is this package's one in-repo consumer today.
+ * so the rest of this package stays DOM-free.
  */
 export { createDomPageDriver, currentAgentPage, type DomPageDriverRequired, type DomPageDriverOptions, type DomPageDriverPage, } from './dom-page-driver.js';
-/**
- * WebMCP feature detection — moved 2026-07-26 from `@jini-ai/ui`'s `agent-tools/model-context.ts`
- * (plan §8 step 6). See `model-context.ts`'s module doc for why it lives here rather than
- * alongside `../webmcp.ts`'s DOM-free projection.
- */
+/** Browser WebMCP feature detection. See model-context.ts for why it lives here rather than
+ * beside the DOM-free webmcp.ts projection. */
 export { getAgentModelContext, type AgentModelContextLike, type ModelContextHostPort, type AgentModelContextRegisterToolOptions, type AgentModelContextToolRegistration, } from './model-context.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/dom/index.js

@@ -3,15 +3,10 @@
  *
  * The one `PageDriver` (see `@jini-ai/agentic`'s `page-driver.ts`) that reads and writes a real DOM
  * subtree. Split into its own entry point, compiled under its own `DOM`-lib `tsconfig.dom.json`,
- * so the rest of this package can stay provably DOM-free — see archived provenance ledger's "The DOM split".
- *
- * `@jini-ai/chat-react` is this package's one in-repo consumer today.
+ * so the rest of this package stays DOM-free.
  */
 export { createDomPageDriver, currentAgentPage, } from './dom-page-driver.js';
-/**
- * WebMCP feature detection — moved 2026-07-26 from `@jini-ai/ui`'s `agent-tools/model-context.ts`
- * (plan §8 step 6). See `model-context.ts`'s module doc for why it lives here rather than
- * alongside `../webmcp.ts`'s DOM-free projection.
- */
+/** Browser WebMCP feature detection. See model-context.ts for why it lives here rather than
+ * beside the DOM-free webmcp.ts projection. */
 export { getAgentModelContext, } from './model-context.js';
 //# sourceMappingURL=index.js.map

package/dist/core/gen-ui/index.d.ts

@@ -5,10 +5,8 @@
  * `state_update`, `ui.surface_requested`, `ui.surface_responded`, `run.lifecycle`) and the encoder
  * that produces them from a `RunProtocolEvent` stream.
  *
- * **This is not AG-UI**, despite what this directory was called until 2026-07-27. The real
- * Agent-User Interaction Protocol uses a 33-member `SCREAMING_SNAKE` event enum and shares zero
- * event names with these six; `../ag-ui.ts` is the genuine AG-UI projection and lives at `src/`
- * root, apart from this. See `archived provenance ledger` for how the two came to be confused.
+ * GenUI and AG-UI are distinct contracts: AG-UI uses SCREAMING_SNAKE event names, while these six
+ * belong to Jini's run-stream protocol. ../ag-ui.ts owns the AG-UI projection.
  *
  * Nothing here opens a connection or touches a browser global. Transport (SSE, WebSocket) belongs
  * to a host — `@jini-ai/http-kit`'s run-stream route is the shipped consumer.

package/dist/core/gen-ui/index.js

@@ -5,10 +5,8 @@
  * `state_update`, `ui.surface_requested`, `ui.surface_responded`, `run.lifecycle`) and the encoder
  * that produces them from a `RunProtocolEvent` stream.
  *
- * **This is not AG-UI**, despite what this directory was called until 2026-07-27. The real
- * Agent-User Interaction Protocol uses a 33-member `SCREAMING_SNAKE` event enum and shares zero
- * event names with these six; `../ag-ui.ts` is the genuine AG-UI projection and lives at `src/`
- * root, apart from this. See `archived provenance ledger` for how the two came to be confused.
+ * GenUI and AG-UI are distinct contracts: AG-UI uses SCREAMING_SNAKE event names, while these six
+ * belong to Jini's run-stream protocol. ../ag-ui.ts owns the AG-UI projection.
  *
  * Nothing here opens a connection or touches a browser global. Transport (SSE, WebSocket) belongs
  * to a host — `@jini-ai/http-kit`'s run-stream route is the shipped consumer.

package/dist/core/index.d.ts

@@ -14,8 +14,7 @@
  * same-document in a real site like a CMS, `postMessage` when a host embeds an untrusted
  * preview in a sandboxed frame. The verbs are identical either way. Also not here: any product's
  * OWN capabilities (`@jini-ai/chat-core`'s `chat.*` verbs stay in chat-core, which depends on this
- * package for the vocabulary rather than the other way around) — see this package's
- * archived provenance ledger for why the split is real rather than a wholesale relocation.
+ * package for the vocabulary rather than the other way around).
  */
 export { findCapability, findCapabilityInputError, availableCapabilities, type CapabilityDef, type CapabilityInputSchema, type CapabilityRisk, type CapabilitySurface, } from './capability.js';
 export type { PageDriver, FindElementsFilter, PageSummary } from './page-driver.js';
@@ -42,34 +41,9 @@ export { toWebMcpTool, toWebMcpTools, isValidWebMcpToolName, WebMcpConfirmationR
  * AG-UI's published `EventType` enum.
  */
 export { toAgUiTool, toAgUiTools, createAgUiToolResult, AG_UI_TOOL_CALL_EVENTS, type AgUiTool, type AgUiToolResultMessage, } from './ag-ui.js';
-/**
- * Jini's **own** run-stream surface protocol, from `./gen-ui/` — six event kinds and the encoder
- * that produces them (folded in 2026-07-26 from the standalone `@jini-ai/agui` package, plan §3a).
- *
- * Renamed from `./agui/` on 2026-07-27, because this is NOT AG-UI. The real Agent-User Interaction
- * Protocol (https://github.com/ag-ui-protocol/ag-ui) carries a 33-member `SCREAMING_SNAKE` event
- * enum — `RUN_STARTED`, `TEXT_MESSAGE_CONTENT`, `STATE_DELTA`, `STEP_STARTED`, `REASONING_*` — and
- * shares **zero** event names with the six dotted-lowercase kinds in `./gen-ui/events.ts`, which
- * are a de-branded port of one product's internal run-event adapter. Carrying the AG-UI name on
- * them asserted a conformance that does not exist.
- *
- * `./ag-ui.ts` above was wrongly folded in with them on 2026-07-26 and moved back out on the 27th:
- * it is the one file here that really does speak AG-UI, so merging it with these six was the exact
- * inversion of the truth.
- *
- * The exported symbols were renamed `Agui`/`AGUI` → `GenUi` on 2026-07-29, finishing what the
- * directory move started: with genuine AG-UI (`./ag-ui.ts`, exported just above as `toAgUiTool`
- * and friends) living in the same barrel, two unrelated protocols were reading as one.
- *
- * `@jini-ai/http-kit` used to mount this encoder behind a route still named `/api/runs/:runId/
- * agui-stream` — left un-renamed at the time on the assumption it was a wire contract an
- * already-deployed client might be calling. A 2026-08-18 audit found zero callers of that route
- * anywhere (no client in this repo or any consuming product ever requested it, and `@jini-ai/http-kit` has never
- * actually been published to npm, so no external integrator could depend on it either); the route,
- * its registrar, and its tests were removed outright rather than renamed. This `gen-ui/` module
- * itself was untouched — it is `@jini-ai/agentic`'s own public export and its removal is a separate
- * decision.
- */
+/** Jini's gen-ui protocol has six dotted-lowercase event kinds, distinct from genuine AG-UI's
+ * SCREAMING_SNAKE event vocabulary exported above. Keep the names separate: claiming AG-UI
+ * conformance for this internal projection would misrepresent its public contract. */
 export { createGenUiEncoder, type GenUiEncodeContext, type GenUiEncoder, type GenUiAgentMessageEvent, type GenUiEvent, type GenUiEventBase, type GenUiEventKind, type GenUiRunLifecycleEvent, type GenUiStateUpdateEvent, type GenUiSurfaceRequestedEvent, type GenUiSurfaceRespondedEvent, type GenUiToolCallEvent, } from './gen-ui/index.js';
 export { MCP_UI_VIEW_METHODS, MCP_UI_HOST_NOTIFICATIONS, MCP_UI_VIEW_NOTIFICATIONS, MCP_UI_HOST_REQUESTS, MCP_UI_SANDBOX_NOTE, JINI_PAGE_ACTION_METHOD, JSON_RPC_ERROR_CODES, isJsonRpcMessage, isJsonRpcRequest, createJsonRpcRequest, createJsonRpcNotification, createJsonRpcResult, createJsonRpcError, createPageActionRequest, type JsonRpcMessage, type JsonRpcRequest, type JsonRpcNotification, type JsonRpcResponse, type JsonRpcError, } from './mcp-ui-apps.js';
 export { defaultAgenticMessages } from "./messages.js";

package/dist/core/index.js

@@ -14,8 +14,7 @@
  * same-document in a real site like a CMS, `postMessage` when a host embeds an untrusted
  * preview in a sandboxed frame. The verbs are identical either way. Also not here: any product's
  * OWN capabilities (`@jini-ai/chat-core`'s `chat.*` verbs stay in chat-core, which depends on this
- * package for the vocabulary rather than the other way around) — see this package's
- * archived provenance ledger for why the split is real rather than a wholesale relocation.
+ * package for the vocabulary rather than the other way around).
  */
 export { findCapability, findCapabilityInputError, availableCapabilities, } from './capability.js';
 export { executePageCapability, projectElementState, DEFAULT_HIGHLIGHT_MS, MAX_HIGHLIGHT_MS, MAX_STATEFUL_ELEMENTS, } from './page-executor.js';
@@ -41,34 +40,9 @@ export { toWebMcpTool, toWebMcpTools, isValidWebMcpToolName, WebMcpConfirmationR
  * AG-UI's published `EventType` enum.
  */
 export { toAgUiTool, toAgUiTools, createAgUiToolResult, AG_UI_TOOL_CALL_EVENTS, } from './ag-ui.js';
-/**
- * Jini's **own** run-stream surface protocol, from `./gen-ui/` — six event kinds and the encoder
- * that produces them (folded in 2026-07-26 from the standalone `@jini-ai/agui` package, plan §3a).
- *
- * Renamed from `./agui/` on 2026-07-27, because this is NOT AG-UI. The real Agent-User Interaction
- * Protocol (https://github.com/ag-ui-protocol/ag-ui) carries a 33-member `SCREAMING_SNAKE` event
- * enum — `RUN_STARTED`, `TEXT_MESSAGE_CONTENT`, `STATE_DELTA`, `STEP_STARTED`, `REASONING_*` — and
- * shares **zero** event names with the six dotted-lowercase kinds in `./gen-ui/events.ts`, which
- * are a de-branded port of one product's internal run-event adapter. Carrying the AG-UI name on
- * them asserted a conformance that does not exist.
- *
- * `./ag-ui.ts` above was wrongly folded in with them on 2026-07-26 and moved back out on the 27th:
- * it is the one file here that really does speak AG-UI, so merging it with these six was the exact
- * inversion of the truth.
- *
- * The exported symbols were renamed `Agui`/`AGUI` → `GenUi` on 2026-07-29, finishing what the
- * directory move started: with genuine AG-UI (`./ag-ui.ts`, exported just above as `toAgUiTool`
- * and friends) living in the same barrel, two unrelated protocols were reading as one.
- *
- * `@jini-ai/http-kit` used to mount this encoder behind a route still named `/api/runs/:runId/
- * agui-stream` — left un-renamed at the time on the assumption it was a wire contract an
- * already-deployed client might be calling. A 2026-08-18 audit found zero callers of that route
- * anywhere (no client in this repo or any consuming product ever requested it, and `@jini-ai/http-kit` has never
- * actually been published to npm, so no external integrator could depend on it either); the route,
- * its registrar, and its tests were removed outright rather than renamed. This `gen-ui/` module
- * itself was untouched — it is `@jini-ai/agentic`'s own public export and its removal is a separate
- * decision.
- */
+/** Jini's gen-ui protocol has six dotted-lowercase event kinds, distinct from genuine AG-UI's
+ * SCREAMING_SNAKE event vocabulary exported above. Keep the names separate: claiming AG-UI
+ * conformance for this internal projection would misrepresent its public contract. */
 export { createGenUiEncoder, } from './gen-ui/index.js';
 export { MCP_UI_VIEW_METHODS, MCP_UI_HOST_NOTIFICATIONS, MCP_UI_VIEW_NOTIFICATIONS, MCP_UI_HOST_REQUESTS, MCP_UI_SANDBOX_NOTE, JINI_PAGE_ACTION_METHOD, JSON_RPC_ERROR_CODES, isJsonRpcMessage, isJsonRpcRequest, createJsonRpcRequest, createJsonRpcNotification, createJsonRpcResult, createJsonRpcError, createPageActionRequest, } from './mcp-ui-apps.js';
 export { defaultAgenticMessages } from "./messages.js";

package/dist/dom/dom-page-driver.d.ts

@@ -0,0 +1,36 @@
+import type { PageDriver } from '../page-driver.js';
+/** One page a host allows navigation to: its human label, and how to actually get there. */
+export interface DomPageDriverPage {
+    /** Shown to a caller by `page.find_elements`/`page.navigate`'s refusal message — see
+     *  `PageSummary.label` for why this exists at all. */
+    readonly label: string;
+    readonly navigate: () => void;
+}
+export interface DomPageDriverOptions {
+    /** The subtree to expose. Never pass `document`. */
+    readonly root: ParentNode & {
+        querySelector: Element['querySelector'];
+    };
+    /** Page ids this driver may navigate to, each with its label and how to get there. */
+    readonly pages: Readonly<Record<string, DomPageDriverPage>>;
+    /**
+     * The id of the page currently shown, reported on every element.
+     *
+     * Omit it in a single-page app that swaps views: the driver then reads `data-agent-page` from
+     * the live DOM on every call, so navigating actually changes what elements report. A value
+     * captured here is fixed for the driver's whole lifetime, which is right only for a surface that
+     * never changes view — and silently wrong for one that does, since the driver outlives any one
+     * view (it is bound to the connection, not the render).
+     */
+    readonly currentPage?: string | undefined;
+}
+/**
+ * Builds a driver over `root`.
+ *
+ * @param options - The subtree, the navigable pages, and the current page id.
+ * @returns A driver ready to hand to `executePageCapability`.
+ */
+export declare function createDomPageDriver(options: DomPageDriverOptions): PageDriver;
+/** Reads the current page's `data-agent-page`, for hosts that tag the body. */
+export declare function currentAgentPage(root: ParentNode): string | undefined;
+//# sourceMappingURL=dom-page-driver.d.ts.map