@jini-ai/agentic 0.4.0 → 0.4.2

package/dist/page-driver.d.ts

@@ -1,120 +0,0 @@
-/**
- * @module page-driver
- *
- * The seam between "what the agent asked for" and "the actual page".
- *
- * Every method here speaks in handles and plain data — no elements, no nodes, no DOM types at
- * all. That is load-bearing rather than stylistic: this package compiles with `lib: ["ES2023"]`
- * and holds no browser globals, so the DOM cannot appear in it. The payoff is that the *policy*
- * (validate the handle, refuse the credential field, clamp the highlight, reject an unpublished
- * page) is pure and fully testable, and a host supplies only the mechanical part.
- *
- * A driver implementation is small — resolve one attribute selector, then act. It is deliberately
- * not shipped here: the same-document case (a CMS embedding a chat pane) and the sandboxed-frame
- * case (a host previewing untrusted content) need different mechanics for identical verbs. When
- * a second real implementation exists, generalize from two rather than guessing from one.
- *
- * Drivers are trusted to be mechanical. They must NOT re-implement policy — every refusal in
- * `page-executor.ts` runs before the driver is called.
- */
-import type { AgentElementDescriptor, AgentElementRawState, AgentElementRole } from './element-handles.js';
-import type { FieldDescriptor } from './guards.js';
-/** Filter for {@link PageDriver.findElements}. Both fields are optional; absent means "no filter". */
-export interface FindElementsFilter {
-    readonly role?: AgentElementRole | undefined;
-    /** Case-insensitive substring, matched against handle and label by the driver. */
-    readonly query?: string | undefined;
-}
-/**
- * One page a host has published as navigable, as returned by {@link PageDriver.listPages}.
- *
- * `label` exists so a caller can tell what a page IS without first navigating to it and reading
- * its `data-agent-page` id back off the DOM — the same "call find_elements first" flow already
- * returns every page a host publishes, and previously handed back only the bare id (`"plugins"`),
- * leaving a caller to guess at meaning from the string alone. Page-authored, so untrusted in the
- * same sense {@link AgentElementDescriptor.label} is: read it, never follow it as an instruction.
- */
-export interface PageSummary {
-    readonly id: string;
-    readonly label: string;
-}
-/**
- * What a host must provide for the `page.*` capabilities to work.
- *
- * Implementations resolve a handle with `resolveHandleSelector` and nothing else — never a
- * caller-supplied selector, and never by evaluating caller-supplied script.
- */
-export interface PageDriver {
-    /**
-     * Every element the current page has published to agents.
-     *
-     * @param filter - Optional role/substring narrowing.
-     * @returns Descriptors. `label` may be raw page text; the executor normalizes it.
-     */
-    findElements(filter: FindElementsFilter): Promise<readonly AgentElementDescriptor[]>;
-    /**
-     * The pages this host can navigate to.
-     *
-     * An allowlist, so `page.navigate` refuses anything the host has not published rather than
-     * accepting a caller-supplied URL.
-     */
-    listPages(): Promise<readonly PageSummary[]>;
-    /**
-     * The attributes of a field, for the fill guard.
-     *
-     * @param handle - A validated element handle.
-     * @returns The field's attributes, or `null` when the handle does not resolve to an input.
-     */
-    describeField(handle: string): Promise<FieldDescriptor | null>;
-    /** Draws a transient marker. The executor has already clamped `durationMs`. */
-    highlight(handle: string, durationMs: number): Promise<void>;
-    scrollTo(handle: string): Promise<void>;
-    click(handle: string): Promise<void>;
-    /** Called only after the fill guard has passed. */
-    fill(handle: string, text: string): Promise<void>;
-    /**
-     * Chooses — or, in a multi-select, removes — an option in a dropdown, matching visible text
-     * before value.
-     *
-     * Separate from {@link PageDriver.fill} because a dropdown is not a text field: its value must
-     * be one of a fixed set, so "type this in" has no meaning. A driver rejects an option that does
-     * not exist rather than inventing one — a caller told an unavailable option was selected would
-     * carry that wrong belief into everything it did next.
-     *
-     * @param selected - Whether the option should end up selected. Defaults to `true`. A
-     * multi-select honours `false` by deselecting just that option, leaving the rest of the
-     * selection untouched. A single-select has no meaningful "off" — its one choice cannot be
-     * removed, only replaced — so `false` there is refused rather than silently ignored or
-     * clearing the control.
-     * @throws When the handle is not a dropdown, when no option matches, or when `selected: false`
-     * is requested on a single-select.
-     */
-    selectOption(handle: string, option: string, selected?: boolean): Promise<void>;
-    /** Called only after `page` has been checked against {@link PageDriver.listPages}. */
-    navigate(page: string): Promise<void>;
-    /**
-     * What the element currently is: its live text, a field's contents, checked/disabled/visible.
-     *
-     * Optional, and honestly so. A driver over a surface that cannot be read back — a fire-and-forget
-     * native host, a write-only bridge — should omit it rather than fabricate a state, and the
-     * executor then reports observation as unavailable instead of implying an empty page.
-     *
-     * @param handle - A validated element handle.
-     * @returns The raw state, or `null` when the handle no longer resolves — which is itself an
-     * observation (a click that removed its own target), not an error.
-     */
-    describeState?(handle: string): Promise<AgentElementRawState | null>;
-    /**
-     * Resolves once the surface has finished reacting to the write that just happened.
-     *
-     * Without this, reading state back immediately after an action reads the DOM *before* the
-     * framework has re-rendered, and every write reports "nothing changed" — the precise failure
-     * this observation channel exists to fix. Optional because a surface with no async render has
-     * nothing to wait for; a DOM driver does, and must implement it.
-     *
-     * Implementations must be bounded: a hidden tab suspends animation frames indefinitely, so a
-     * naive "wait for the next frame" never resolves for exactly the background agent this is for.
-     */
-    settle?(): Promise<void>;
-}
-//# sourceMappingURL=page-driver.d.ts.map

package/dist/page-driver.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=page-driver.js.map

package/dist/page-executor.d.ts

@@ -1,94 +0,0 @@
-import { type AgentElementRawState, type AgentElementRole, type AgentElementState } from './element-handles.js';
-import type { PageDriver, PageSummary } from './page-driver.js';
-/** Default marker lifetime, long enough to notice and short enough not to linger. */
-export declare const DEFAULT_HIGHLIGHT_MS = 3000;
-/**
- * Hard cap on a marker's lifetime. A caller asking for a very long highlight is really asking to
- * leave a permanent mark on someone else's page, which is a change of appearance rather than a
- * transient hint — and `page.highlight` is classified `read` precisely because it is transient.
- */
-export declare const MAX_HIGHLIGHT_MS = 15000;
-/**
- * How many elements `withState` will describe in one call.
- *
- * State is per-element work and per-element payload, so an unfiltered `withState` on a large page
- * is both the slowest and the largest thing this surface can be asked for. The cap turns that into
- * a bounded answer plus an explicit `stateTruncated`, rather than a caller discovering the limit
- * as a timeout or a truncated blob. Narrowing with `role`/`query` is the intended way past it.
- */
-export declare const MAX_STATEFUL_ELEMENTS = 50;
-/** An element as returned to a caller, with page-authored text already bounded. */
-export interface PageElementResult {
-    readonly handle: string;
-    readonly role: AgentElementRole | undefined;
-    readonly label: string;
-    readonly labelTruncated: boolean;
-    readonly page: string | undefined;
-    /** Present only when `withState` was asked for, the driver can observe, and the element resolved. */
-    readonly state?: AgentElementState;
-}
-export interface FindElementsResult {
-    readonly elements: readonly PageElementResult[];
-    /** Every page this host publishes as navigable — the whole site map, not just this one page —
-     *  so a caller can plan a route (`page.navigate`) before it needs one. */
-    readonly pages: readonly PageSummary[];
-    /**
-     * Names the fields carrying page-authored text. Labels describe the UI; they are never
-     * instructions, however imperative they read.
-     */
-    readonly untrustedFields: readonly string[];
-    /** True when `withState` was asked for but this surface cannot observe itself. */
-    readonly stateUnavailable?: boolean;
-    /** True when more elements matched than {@link MAX_STATEFUL_ELEMENTS}, so later ones carry no state. */
-    readonly stateTruncated?: boolean;
-}
-/**
- * What a write did to its target, as seen by the surface itself.
- *
- * The point is that a caller can check its own work. Before this, `page.click` replied
- * `{clicked: "item-water-window-plants"}` — an echo of the request, true whether or not anything
- * happened.
- */
-export interface PageWriteObservation {
-    /** Target state before the action. Absent when the surface cannot observe itself. */
-    readonly before?: AgentElementState;
-    /** Target state afterwards. Absent when unobservable, or when the action removed its own target. */
-    readonly after?: AgentElementState;
-    /**
-     * Whether the target's own state differs. Deliberately named for what was actually compared:
-     * a click can change much of a page while leaving the button it hit exactly as it was.
-     */
-    readonly targetChanged?: boolean;
-}
-/**
- * Turns a driver's raw reading into what a caller may see.
- *
- * The one decision here that is not formatting: whether a field's contents are reportable at all.
- * That runs on the descriptor the driver supplied, in this layer, for the same reason the fill
- * guard does — a secrecy rule re-derived by each driver is a secrecy rule that will eventually be
- * derived wrong. A value arriving with no descriptor to check is withheld rather than trusted.
- */
-export declare function projectElementState(raw: AgentElementRawState): AgentElementState;
-/**
- * What page is showing and how much it publishes, at one moment — the before/after pair
- * `page.navigate` reports. Not {@link PageSummary} (`page-driver.js`): that names one entry in the
- * SITE-WIDE list of pages a host publishes; this is a single reading of the CURRENT page, taken
- * twice around one navigation.
- */
-export interface PageActivitySnapshot {
-    readonly page: string | undefined;
-    readonly elementCount: number;
-}
-/**
- * Runs one `page.*` capability.
- *
- * @param driver - The host's page driver.
- * @param capabilityId - A `page.*` id from {@link PAGE_CAPABILITIES}.
- * @param input - Raw caller arguments, validated here against the declared schema.
- * @returns The capability's result.
- * @throws If the id is unknown, the input fails validation, a handle is malformed, the target is
- * a field no automated caller may fill, or the page is not published. Refusals are errors on
- * purpose: a caller must be told why, not handed a silent no-op it will retry forever.
- */
-export declare function executePageCapability(driver: PageDriver, capabilityId: string, input: Record<string, unknown>): Promise<unknown>;
-//# sourceMappingURL=page-executor.d.ts.map

package/dist/page-executor.js

@@ -1,320 +0,0 @@
-/**
- * @module page-executor
- *
- * The six `page.*` verbs, as policy over a {@link PageDriver}.
- *
- * Every refusal happens here, before the driver is called: schema validation, handle validation,
- * the field guard, the page allowlist, highlight clamping. A driver is mechanical and is trusted
- * to be — which means a second driver (same-document, sandboxed frame, a future native host)
- * inherits identical behavior for free rather than re-deriving it and getting one case wrong.
- *
- * Nothing here touches the DOM. That is what makes the interesting half testable without a
- * browser: "does it refuse to type into a password box" is a unit test, not an integration test.
- */
-import { findCapabilityInputError, } from './capability.js';
-import { AGENT_ELEMENT_ROLES, isValidElementHandle, } from './element-handles.js';
-import { describeFieldReadRefusal, describeFieldRefusal, findFieldFillRefusal, findFieldReadRefusal, normalizeAgentLabel, } from './guards.js';
-import { PAGE_CAPABILITIES } from './page-capabilities.js';
-/** Default marker lifetime, long enough to notice and short enough not to linger. */
-export const DEFAULT_HIGHLIGHT_MS = 3_000;
-/**
- * Hard cap on a marker's lifetime. A caller asking for a very long highlight is really asking to
- * leave a permanent mark on someone else's page, which is a change of appearance rather than a
- * transient hint — and `page.highlight` is classified `read` precisely because it is transient.
- */
-export const MAX_HIGHLIGHT_MS = 15_000;
-/**
- * How many elements `withState` will describe in one call.
- *
- * State is per-element work and per-element payload, so an unfiltered `withState` on a large page
- * is both the slowest and the largest thing this surface can be asked for. The cap turns that into
- * a bounded answer plus an explicit `stateTruncated`, rather than a caller discovering the limit
- * as a timeout or a truncated blob. Narrowing with `role`/`query` is the intended way past it.
- */
-export const MAX_STATEFUL_ELEMENTS = 50;
-function requireHandle(input, key) {
-    const value = input[key];
-    if (typeof value !== 'string' || !isValidElementHandle(value)) {
-        throw new Error(`"${key}" must be a published element handle from page.find_elements — `
-            + 'lowercase words joined by single hyphens, never a CSS selector');
-    }
-    return value;
-}
-function clampHighlightDuration(value) {
-    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
-        return DEFAULT_HIGHLIGHT_MS;
-    return Math.min(value, MAX_HIGHLIGHT_MS);
-}
-function isAgentElementRole(value) {
-    return typeof value === 'string' && AGENT_ELEMENT_ROLES.includes(value);
-}
-/**
- * Turns a driver's raw reading into what a caller may see.
- *
- * The one decision here that is not formatting: whether a field's contents are reportable at all.
- * That runs on the descriptor the driver supplied, in this layer, for the same reason the fill
- * guard does — a secrecy rule re-derived by each driver is a secrecy rule that will eventually be
- * derived wrong. A value arriving with no descriptor to check is withheld rather than trusted.
- */
-export function projectElementState(raw) {
-    const text = normalizeAgentLabel(raw.text);
-    // Computed once, up front, so `checked` is gated by the exact same refusal as `value` below
-    // rather than being copied through unconditionally. A checkbox/radio's `checked` is a second
-    // secrecy channel, not a formatting detail: for a field like `health_disclosure_password`,
-    // *which* option is ticked is itself the secret, even though it is a boolean and `value` was
-    // already withheld. `text` is deliberately NOT gated here, on purpose, even for a refused
-    // field: for a checkbox/radio, `text` is the option's own visible label (e.g. "I am HIV
-    // positive") — page-authored content the page already renders openly to anyone who looks at
-    // it, exactly like a `<select>`'s `options` below. The secret is which option is checked, not
-    // what the option is called; withholding the label too would blind a caller to the page's own
-    // ontology for no reduction in what actually leaks.
-    const refusal = raw.field !== undefined ? findFieldReadRefusal(raw.field) : null;
-    // The one element whose `text` is NOT page-authored chrome: an editable region, whose contents
-    // are the user's data and whose driver has no `value` to report them as. It is gated by exactly
-    // the rules `value` is gated by below, including the "arrived with nothing to check it against"
-    // one — an unverifiable secret is withheld, not trusted.
-    const withheldText = raw.textIsValue !== true
-        ? undefined
-        : raw.field === undefined
-            ? 'this element reported contents without the attributes needed to check them for secrets'
-            : refusal !== null ? describeFieldReadRefusal(refusal) : undefined;
-    const base = {
-        text: withheldText === undefined ? text.text : '',
-        textTruncated: withheldText === undefined ? text.truncated : false,
-        ...(withheldText !== undefined ? { textWithheld: withheldText } : {}),
-        ...(raw.checked !== undefined && refusal === null ? { checked: raw.checked } : {}),
-        ...(raw.disabled !== undefined ? { disabled: raw.disabled } : {}),
-        ...(raw.visible !== undefined ? { visible: raw.visible } : {}),
-        // Bounded like every other page-authored string, but never withheld: the options a dropdown
-        // offers are part of the UI's shape, not the user's data.
-        ...(raw.options !== undefined
-            ? { options: raw.options.map((option) => normalizeAgentLabel(option).text) }
-            : {}),
-    };
-    if (raw.value === undefined)
-        return base;
-    if (raw.field === undefined) {
-        return {
-            ...base,
-            valueWithheld: 'this element reported a value without the attributes needed to check it for secrets',
-        };
-    }
-    if (refusal !== null)
-        return { ...base, valueWithheld: describeFieldReadRefusal(refusal) };
-    const value = normalizeAgentLabel(raw.value);
-    return { ...base, value: value.text, valueTruncated: value.truncated };
-}
-/**
- * Whether two readings of the same element are indistinguishable to a caller.
- *
- * Compares only what the caller can actually see: a withheld value is compared as "withheld",
- * so a secret that changed reads as unchanged. That is the honest answer — a change no caller may
- * observe is not one this can report — and is why the field it feeds is named `targetChanged`.
- */
-function sameElementState(a, b) {
-    return a.text === b.text
-        // Compared for the same reason `valueWithheld` is: without it, an editable region whose
-        // contents are withheld reads as `text: ''` before and after, and a write into it would
-        // report `targetChanged: false` — an answer that says "nothing happened" rather than the
-        // honest "no caller may observe whether it did".
-        && a.textWithheld === b.textWithheld
-        && a.value === b.value
-        && a.valueWithheld === b.valueWithheld
-        && a.checked === b.checked
-        && a.disabled === b.disabled
-        && a.visible === b.visible;
-}
-/**
- * Reads one element's state, or `undefined` when there is nothing to read.
- *
- * Two different absences collapse here on purpose: a driver that cannot observe at all, and an
- * element that no longer resolves. A caller distinguishes them from context — `before` present
- * with `after` absent means the action removed its own target; both absent means the surface does
- * not report state.
- */
-async function observeElement(driver, handle) {
-    if (driver.describeState === undefined || !isValidElementHandle(handle))
-        return undefined;
-    const raw = await driver.describeState(handle);
-    return raw === null ? undefined : projectElementState(raw);
-}
-/** Runs a write between two readings of its target, waiting for the surface to settle in between. */
-async function observeWrite(driver, handle, write) {
-    const before = await observeElement(driver, handle);
-    await write();
-    if (driver.settle !== undefined)
-        await driver.settle();
-    const after = await observeElement(driver, handle);
-    return {
-        ...(before !== undefined ? { before } : {}),
-        ...(after !== undefined ? { after } : {}),
-        ...(before !== undefined && after !== undefined
-            ? { targetChanged: !sameElementState(before, after) }
-            : {}),
-    };
-}
-/**
- * Reads the showing page from the elements themselves, which is where a driver reports it. A
- * surface that publishes nothing has no page id to report, and says so rather than guessing.
- */
-async function summarizePage(driver) {
-    const elements = await driver.findElements({});
-    return {
-        page: elements.find((element) => element.page !== undefined)?.page,
-        elementCount: elements.length,
-    };
-}
-/**
- * Runs one `page.*` capability.
- *
- * @param driver - The host's page driver.
- * @param capabilityId - A `page.*` id from {@link PAGE_CAPABILITIES}.
- * @param input - Raw caller arguments, validated here against the declared schema.
- * @returns The capability's result.
- * @throws If the id is unknown, the input fails validation, a handle is malformed, the target is
- * a field no automated caller may fill, or the page is not published. Refusals are errors on
- * purpose: a caller must be told why, not handed a silent no-op it will retry forever.
- */
-export async function executePageCapability(driver, capabilityId, input) {
-    const capability = PAGE_CAPABILITIES.find((entry) => entry.id === capabilityId);
-    if (capability === undefined)
-        throw new Error(`unknown page capability: ${capabilityId}`);
-    const inputError = findCapabilityInputError(capability, input);
-    if (inputError !== null) {
-        // The schema rides along with the refusal rather than making a caller spend a second
-        // round trip on describe_tool to learn what it already tried to guess — ai-control-plane.md
-        // §29.4's "schema-on-error" requirement, empirically forced by a real run: page.fill was
-        // called with `handle` instead of the argument's old name, `element`, twice before the caller
-        // gave up and looked the schema up separately. One JSON-Schema object, embedded once, turned
-        // that into a same-turn self-correction for every page.* verb this gate guards, not just the
-        // one that got measured — self-correction is why that mismatch was survivable at all, given
-        // every verb here needs a handle from `page.find_elements`, whose own response has always
-        // called this same value `handle` (`AgentElementDescriptor.handle`). The argument itself was
-        // later renamed from `element` to `handle` to match, closing the gap this comment describes
-        // rather than merely papering over it turn by turn.
-        throw new Error(`${capabilityId}: ${inputError}. Expected input: ${JSON.stringify(capability.inputSchema)}`);
-    }
-    switch (capabilityId) {
-        case 'page.find_elements': {
-            const role = input['role'];
-            // The schema's enum check has already run; this narrows the type for the driver.
-            const filter = {
-                ...(isAgentElementRole(role) ? { role } : {}),
-                ...(typeof input['query'] === 'string' ? { query: input['query'] } : {}),
-            };
-            const [found, rawPages] = await Promise.all([driver.findElements(filter), driver.listPages()]);
-            const withState = input['withState'] === true;
-            const observing = withState && driver.describeState !== undefined;
-            const elements = await Promise.all(found.map(async (element, index) => {
-                const label = normalizeAgentLabel(element.label);
-                const base = {
-                    handle: element.handle,
-                    role: element.role,
-                    label: label.text,
-                    labelTruncated: label.truncated,
-                    page: element.page,
-                };
-                if (!observing || index >= MAX_STATEFUL_ELEMENTS)
-                    return base;
-                const state = await observeElement(driver, element.handle);
-                return state === undefined ? base : { ...base, state };
-            }));
-            // `label` is page-authored the same way an element's is — bounded here for the same reason
-            // `page.navigate`'s refusal message bounds it below, rather than trusting a host to have kept
-            // every `data-agent-page` label short and clean.
-            const pages = rawPages.map((page) => ({
-                id: page.id,
-                label: normalizeAgentLabel(page.label).text,
-            }));
-            return {
-                elements,
-                pages,
-                untrustedFields: observing
-                    ? ['elements[].label', 'elements[].state.text', 'elements[].state.value', 'pages[].label']
-                    : ['elements[].label', 'pages[].label'],
-                ...(withState && !observing ? { stateUnavailable: true } : {}),
-                ...(observing && found.length > MAX_STATEFUL_ELEMENTS ? { stateTruncated: true } : {}),
-            };
-        }
-        case 'page.highlight': {
-            const handle = requireHandle(input, 'handle');
-            const durationMs = clampHighlightDuration(input['durationMs']);
-            await driver.highlight(handle, durationMs);
-            return { highlighted: handle, durationMs };
-        }
-        case 'page.scroll_to': {
-            const handle = requireHandle(input, 'handle');
-            await driver.scrollTo(handle);
-            return { scrolledTo: handle };
-        }
-        case 'page.click': {
-            const handle = requireHandle(input, 'handle');
-            const observation = await observeWrite(driver, handle, () => driver.click(handle));
-            return { clicked: handle, ...observation };
-        }
-        case 'page.fill': {
-            const handle = requireHandle(input, 'handle');
-            // Declared required and typed `string` in the manifest, and `findCapabilityInputError`
-            // enforced both above — re-checking here would be an unreachable branch, not a safeguard.
-            const text = input['text'];
-            // Ask the page what this field actually is before writing to it. A handle proves the page
-            // published the element; it says nothing about whether it holds a password.
-            const field = await driver.describeField(handle);
-            if (field === null)
-                throw new Error(`"${handle}" is not a fillable field`);
-            const refusal = findFieldFillRefusal(field);
-            if (refusal !== null) {
-                throw new Error(`refusing to fill "${handle}": ${describeFieldRefusal(refusal)}`);
-            }
-            const observation = await observeWrite(driver, handle, () => driver.fill(handle, text));
-            return { filled: handle, ...observation };
-        }
-        case 'page.select_option': {
-            const handle = requireHandle(input, 'handle');
-            // Required and string-typed by the manifest, already enforced above. See page.fill.
-            const option = input['option'];
-            // Optional and boolean-typed by the manifest; absent means "select it", same as before this
-            // argument existed.
-            const selected = input['selected'] === false ? false : true;
-            // No field guard: a dropdown's options are authored by the page, so choosing one reveals
-            // nothing the page had not already published, and none of the credential field types this
-            // surface refuses can be a `<select>`.
-            const observation = await observeWrite(driver, handle, () => driver.selectOption(handle, option, selected));
-            // `optionSelected` names the boolean rather than reusing `selected`, which already means
-            // "the handle this call acted on" for every verb in this switch (`clicked`, `filled`, …).
-            return { selected: handle, option, optionSelected: selected, ...observation };
-        }
-        case 'page.navigate': {
-            // Required and string-typed by the manifest, already enforced above. See page.fill.
-            const page = input['page'];
-            const pages = await driver.listPages();
-            if (!pages.some((candidate) => candidate.id === page)) {
-                // Every other piece of page-authored (or, here, caller-authored-but-page-shaped) text
-                // this system hands to a model goes through normalizeAgentLabel first — bounded, control-
-                // and bidi-stripped. This refusal was the one path that skipped it: the raw `page`
-                // argument, and the `pages` this host actually publishes (itself read verbatim off
-                // `data-agent-page` attributes with no length bound), were interpolated straight into the
-                // thrown message. A 5000+-char bidi payload survived verbatim as a result. The lookup
-                // above still runs on the raw values — only the text that reaches the message is bounded.
-                //
-                // `id (label)`, not just the id: a refusal is the one moment a caller that guessed wrong
-                // is looking straight at the real menu, so it is worth spending the label here even though
-                // `page.find_elements` already carries the same information — a caller that jumped
-                // straight to `page.navigate` without calling that first still lands on the right id.
-                const safePage = normalizeAgentLabel(page).text;
-                const safePages = pages.map((candidate) => `${normalizeAgentLabel(candidate.id).text} (${normalizeAgentLabel(candidate.label).text})`);
-                throw new Error(`"${safePage}" is not a published page. Available: ${safePages.length > 0 ? safePages.join(', ') : '(none)'}`);
-            }
-            const before = await summarizePage(driver);
-            await driver.navigate(page);
-            if (driver.settle !== undefined)
-                await driver.settle();
-            const after = await summarizePage(driver);
-            return { navigatedTo: page, before, after };
-        }
-        /* c8 ignore next 2 -- unreachable: the id was matched against PAGE_CAPABILITIES above. */
-        default:
-            throw new Error(`unhandled page capability: ${capabilityId}`);
-    }
-}
-//# sourceMappingURL=page-executor.js.map