@descryy/mcp 0.11.5 → 0.11.6

package/dist/browser/driver.d.ts

@@ -0,0 +1,591 @@
+/**
+ * Browser port for @descryy/mcp — testable without a real Chromium; runtime-browser isn't
+ * registry-published yet (§3.1). Mirrors runtime-browser's real exports (exception: `type()`);
+ * no verdict/severity (DEC-381). Rule 1: nothing here names a language, framework or extension.
+ */
+import type { StackTrace } from "@descryy/runtime-contracts";
+import type { PageFingerprint } from "./capability-probe.ts";
+import type { WaitForTarget } from "./wait-target.ts";
+/** One document a snapshot read — an iframe inside the page. The main document is never a
+ *  `FrameRef`; it is `null`, so "in the page" and "in a frame" can never render alike. */
+export interface FrameRef {
+    /** Stable within one snapshot only, exactly like a `ref` — a frame's index is not a page
+     *  identity, and pretending otherwise would let a caller carry it across a re-render. */
+    readonly id: string;
+    readonly url: string;
+    /** The frame's `name`, or the iframe element's `id`/`title` — whichever it carries, so a
+     *  reply reads "the checkout frame" rather than "frame 3". Null when it carries none. */
+    readonly name: string | null;
+}
+/** A page element as a snapshot presented it. `ref` is the handle an action takes. */
+export interface SnapshotElement {
+    readonly ref: string;
+    readonly role: string;
+    readonly name: string;
+    /** How the driver finds this element again; every verb takes a `ref`, never a selector,
+     *  because a ref ties to the snapshot the agent saw. Also what a scenario persists across
+     *  sessions. **Null when no candidate resolves to exactly one element** (rule 2: no guessed selector). */
+    readonly selector: string | null;
+    /** The iframe this element lives in, or null for the main document. A selector is unique
+     *  only within its own document — two frames can both hold `[id="submit"]` — so a selector
+     *  without this beside it is ambiguous. Elements in a frame carry `selector: null` for that
+     *  reason: the scenario format has no field to name a frame, so there is nothing that could
+     *  be saved, and a selector that silently replayed against the main document is the quiet
+     *  wrong answer rule 2 exists to refuse. They stay actionable by `ref` for this session. */
+    readonly frame: FrameRef | null;
+    /** True when the element was found inside an **open** shadow root. Its selector, when one
+     *  was found, is checked for uniqueness both inside that root and across the whole document
+     *  under piercing resolution — a hook unique only inside its own component is not addressable. */
+    readonly inShadowRoot: boolean;
+    /**
+     * Which component's render produced this element, additive to role+name — never a
+     * replacement. Role+name is what survives a production build; this is what does not, so
+     * every verb keeps taking `ref` and every scenario keeps saving `role`+`name`+`selector`
+     * regardless of what this field says.
+     *
+     * **Null** means grounding did not run for this element at all — no grounder was
+     * configured for this session, or the element carries no `selector` to probe by (grounding
+     * resolves a document selector, and a framed or hookless element has none). That is a
+     * different fact from `outcome: "refused"`, which means grounding ran and is naming why it
+     * could not identify a component — rule 7: a skip and an empty answer must not read alike.
+     */
+    readonly identity: ElementComponentIdentity | null;
+}
+/** Every way an element's producing component can be reported, as a closed set — mirrors
+ *  identity grounding's own outcome vocabulary without naming what produced them (rule 1:
+ *  nothing in this port names a language or framework). */
+export type ComponentIdentityOutcome = "grounded" | "component-only" | "refused";
+/** How this element's producing component was identified. Never a guess: `refused` is a
+ *  named reason, not an absence, and a caller must not read a null `component` on any
+ *  outcome as "there is no component" — it means grounding could not say which one. */
+export interface ElementComponentIdentity {
+    readonly outcome: ComponentIdentityOutcome;
+    /** The component's name, when one was named. Null on `refused`. */
+    readonly component: string | null;
+    /** The file said to have authored this component. Null when no location was produced. */
+    readonly file: string | null;
+    readonly line: number | null;
+    /**
+     * True when `file` names authored source. False when it names compiled output instead —
+     * still real, still worth reporting, just not the file a developer wrote. Meaningless when
+     * `file` is null.
+     */
+    readonly authoredSource: boolean;
+    /** Why nothing could be named. Null except on `refused` — including the production-build
+     *  case, where the honest answer is a named refusal, never a guessed or mangled name. */
+    readonly reason: string | null;
+}
+/** One document the snapshot tried to read. A frame that could not be read is present with
+ *  `enumerated: false` and a reason, never dropped — rule 7: a silent omission and an empty
+ *  frame are different facts and must not render alike. */
+export interface FrameReach {
+    /** Null for the main document. */
+    readonly frame: FrameRef | null;
+    readonly enumerated: boolean;
+    /** How many interactive elements this document contributed. 0 with `enumerated: true` means
+     *  the document really holds none. */
+    readonly elements: number;
+    /** Why nothing was read. Null exactly when `enumerated` is true. */
+    readonly reason: string | null;
+}
+/** What shadow-root piercing saw, and what it cannot see. */
+export interface ShadowReach {
+    /** Elements in this snapshot that came from inside an open shadow root. */
+    readonly piercedElements: number;
+    /** Elements whose own hook was unique inside their shadow root but **not** across the
+     *  document, so their selector was withheld. Counted rather than guessed at. */
+    readonly ambiguousInDocument: number;
+    /** Custom elements exposing no reachable shadow root and holding no light-DOM children —
+     *  the signature of a **closed** shadow root. No API can confirm one: `element.shadowRoot`
+     *  is null for "closed" and for "none at all" alike. **Suspected, never asserted**, and
+     *  reported so a caller knows the page may hold controls nothing here can reach. */
+    readonly suspectedClosedHosts: number;
+    /** False when the closed-root probe could not run at all — then `suspectedClosedHosts: 0`
+     *  means "not looked for", not "none found", and a caller must not read it as the latter. */
+    readonly probed: boolean;
+}
+/**
+ * What the interactive query matched and this snapshot would not repeat.
+ *
+ * The CSS query matches what is in the *document*; a snapshot is supposed to say what is on
+ * the *page*. A `display:none` menu, a closed `<dialog>`, an inactive tab panel and `<canvas>`
+ * fallback content all match the query and none of them is on the screen, so listing them is
+ * Descry naming a control the user does not have — which rule 2 makes worse than naming none.
+ *
+ * It is **not** an off-screen count. An element below the fold is on the page and is listed;
+ * the reveal pass depends on that, and rejecting it would swap this precision defect for a
+ * recall one.
+ */
+export interface HiddenReach {
+    /** Elements withheld from `elements` because the page renders them nowhere. */
+    readonly withheld: number;
+    /** Elements the visibility test could not answer for. They are **listed anyway** — omitting
+     *  on an unanswered question would hide real controls behind a test that did not run — which
+     *  also makes `withheld` a floor rather than a total whenever this is above zero (rule 7). */
+    readonly untested: number;
+}
+/** Nothing withheld and nothing left unanswered — the honest reading for a driver with no DOM. */
+export declare const NO_HIDDEN_REACH: HiddenReach;
+/** What a reveal pass did. Null on `PageSnapshot` when no reveal was asked for — "not
+ *  attempted" and "attempted and found nothing" are different facts. */
+export interface RevealOutcome {
+    /** How many scroll-and-re-enumerate rounds ran. */
+    readonly passes: number;
+    /** Scrollable containers (`overflow: auto|scroll`) this pass scrolled **in addition to the
+     *  page itself**. A list inside one does not move when the window does, so a window-only
+     *  reveal reports "nothing below the fold" about a page whose content is entirely below one.
+     *  Counted rather than named: a container has no ref and no stable name to give. */
+    readonly containersScrolled: number;
+    /** Elements that were not in the first enumeration and are still present at the end. */
+    readonly revealedElements: number;
+    /** Elements seen during the pass that were **gone by the end of it** — a virtualized list
+     *  recycling its rows. They are counted and not listed, deliberately: a ref to an element
+     *  the page has already destroyed is a lie, and this number is the honest form of
+     *  "there is more here than one snapshot can hold at once". */
+    readonly recycledElements: number;
+    /** True when the pass cap stopped it while the page was still producing new elements — so
+     *  "nothing more below" and "I stopped looking" stay distinguishable. */
+    readonly stoppedAtCap: boolean;
+    /** Where the page was left scrolled. Revealing changes the page's scroll position; saying
+     *  so is cheaper than pretending observation was free. */
+    readonly finalScrollY: number;
+    /** Frames are not scrolled — only the main document is. Non-empty names the frames whose
+     *  below-the-fold content this pass did not reach. */
+    readonly framesNotScrolled: readonly string[];
+    /** Why the pass could not run, or could not run fully. Null when it ran normally. A reveal
+     *  that silently did nothing and a reveal that found nothing would otherwise read alike. */
+    readonly reason: string | null;
+}
+/** How a snapshot should be taken. */
+export interface SnapshotOptions {
+    /** Scroll the main document and re-enumerate until it stops producing new elements, or a
+     *  cap is hit. Off by default: it moves the page, and a virtualized list will destroy rows
+     *  as it goes. On, it is the only way to see content that does not exist until it scrolls
+     *  into view. Either way the outcome is reported in `reveal`. */
+    readonly reveal?: boolean;
+}
+export type { WaitForTarget } from "./wait-target.ts";
+export interface PageSnapshot {
+    readonly url: string;
+    readonly title: string;
+    readonly elements: readonly SnapshotElement[];
+    /** Element count before any budget applied, always uncapped (§5.2) — lets a caller
+     *  distinguish "no more elements" from "the rest didn't fit". Driver never truncates
+     *  (equals elements.length here), but lives on the port so a tool can't lose the real count.
+     *  It counts what this snapshot can hand back a ref for — never what the page might hold
+     *  after scrolling. That second number, when it is known at all, is `reveal`'s. */
+    readonly totalElements: number;
+    /** Every document this snapshot tried to read — the main one first, then each iframe,
+     *  including any it could not read. Always at least one entry. */
+    readonly frames: readonly FrameReach[];
+    readonly shadow: ShadowReach;
+    readonly hidden: HiddenReach;
+    /** Null when `SnapshotOptions.reveal` was not set. */
+    readonly reveal: RevealOutcome | null;
+}
+/** The main document's entry, for a driver with no frames of its own to report. */
+export declare function mainFrameOnly(elements: number): readonly FrameReach[];
+/** Nothing pierced, nothing suspected — the honest reading for a driver with no DOM behind it. */
+export declare const NO_SHADOW_REACH: ShadowReach;
+/** Every verb that changes the application. `waitFor` is deliberately absent: it performs
+ *  nothing, so recording it as an action would claim a change that never happened, and
+ *  `PerformedStep` would carry steps with no target, no url and no text. */
+export type BrowserActionKind = "navigate" | "click" | "type" | "fill" | "select" | "submit";
+export interface ObservedAction {
+    readonly action: BrowserActionKind;
+    /** Null for `navigate`, which acts on the page rather than on an element. */
+    readonly ref: string | null;
+    /** How text reached the field — "append" for `type`, "replace" for `fill`, null when no
+     *  text entered. Without it "field now contains X" and "X was appended" read identically;
+     *  the runtime collector's INPUT payload carries the same field for the same reason. */
+    readonly mode: "replace" | "append" | null;
+    readonly url: string;
+    readonly at: string;
+}
+/** What rewriteScriptUrls did with one script URL. Per-URL, not a summary — partial mapping
+ *  is the steady state (own bundle maps, CDN dependency doesn't), and collapsing to a count
+ *  would hide that boundary and any third-party script a caller should ignore. */
+export interface ScriptUrlOutcome {
+    /** The URL as it appeared in the stack, `:line:column` suffix included. */
+    readonly url: string;
+    /** The on-disk file it was rewritten to, or null when it was left as a URL. */
+    readonly mapped: string | null;
+    /** Why it was left alone. Null exactly when `mapped` is set. */
+    readonly reason: string | null;
+}
+export interface ObservedConsoleError {
+    readonly text: string;
+    /** Stack rendered from parsed frames, or null. Already rewritten to real files/lines where
+     *  possible — rewriteScriptUrls runs inside the runtime collector before the parser sees it.
+     *  A surviving http:// URL is a frame that genuinely didn't map (see scriptUrlMapping). */
+    readonly stackText: string | null;
+    /** Per-URL mapping outcomes; empty means no rewrite ran (no stack parser configured),
+     *  not "nothing mapped" — the two must not be reported alike. */
+    readonly scriptUrlMapping: readonly ScriptUrlOutcome[];
+    readonly at: string;
+}
+/** How a request's lifecycle ended, when the collector can tell. `status: null` used to
+ *  conflate "never answers" with "hasn't yet" — `"pending"` splits that back out (still
+ *  in flight at drain, neither success nor failure); `"unanswered"` is Playwright's own requestfailed. */
+/** How a request ended, as far as anything can say. Three of the four come off the
+ *  collector's own terminal event. The fourth, `"unattributed"`, is this package's and never
+ *  the collector's: it means a terminal event for this URL exists and Descry cannot say it
+ *  belongs to *this* request — see `collect()` in `playwright-driver.ts`. It is deliberately
+ *  not "pending", which is a positive claim that the request is still in flight. */
+export type RequestOutcome = "answered" | "unanswered" | "pending" | "unattributed";
+export interface ObservedRequest {
+    readonly method: string;
+    readonly url: string;
+    /** Null when the request produced no response at all, which is a different fact from a 500. */
+    readonly status: number | null;
+    /** How this request's lifecycle ended, when the collector reports it. Optional: a separate
+     *  lane's field to populate, this port can't assume that build is running. Absent degrades to
+     *  isFailedRequest's pre-existing status-only rule rather than mis-reading an older build. */
+    readonly outcome?: RequestOutcome;
+    /** The `fetch()` call site as raw text, when the initiator capture claimed one. Null is honest absence. */
+    readonly stackText: string | null;
+    /** Per-URL mapping outcomes for that call site. See `ScriptUrlOutcome`. */
+    readonly scriptUrlMapping: readonly ScriptUrlOutcome[];
+    /** Same call site parsed into frames with real file paths. Null unless the caller named a
+     *  stack-trace parser — this package can't parse a stack itself without naming a language
+     *  (rule 1). **The field the R4 edge write needs** (confirmObservedFrontendCaller). */
+    readonly stackTrace: StackTrace | null;
+    readonly at: string;
+}
+/** A request that didn't succeed — mechanical, not a judgement. With no `outcome` (older
+ *  descry-runtime build): no response, or 4xx/5xx. With `outcome`: "pending" excluded (in-flight
+ *  proves nothing); "unanswered" is always a failure (requestfailed is stronger than a bare status). */
+export declare function isFailedRequest(request: ObservedRequest): boolean;
+/** Everything witnessed since the last drain. Raw — see this file's header. */
+export interface BrowserObservation {
+    readonly actions: readonly ObservedAction[];
+    readonly consoleErrors: readonly ObservedConsoleError[];
+    /** Every request issued, not only failures — a success proves *this frontend action reached
+     *  this backend route*, the arrow the R4 edge write runs on. Filtering here would discard
+     *  it; the reply narrows to failures for readability, correlation does not. */
+    readonly requests: readonly ObservedRequest[];
+    /** Actions whose network activity hadn't finished when the driver stopped waiting. Without
+     *  this, "nothing happened" and "I stopped looking" render identically — rule 7 forbids that.
+     *  Non-empty means that action's observation is incomplete, and says so. */
+    readonly unsettled: readonly UnsettledAction[];
+    /** B4: facts this evidence path refused to publish, each already named for the user. Populated
+     *  when a collector payload contradicted itself (a numeric status alongside `"unanswered"`, or
+     *  the reverse) and the unreconcilable half was therefore dropped. Empty on every ordinary
+     *  drain; non-empty means this observation is *narrower* than what the collector said, and rule
+     *  7 requires saying so rather than letting the narrowing pass as the whole truth. */
+    readonly evidenceWarnings: readonly string[];
+}
+export interface UnsettledAction {
+    readonly action: ObservedAction["action"];
+    readonly ref: string | null;
+    /** How long the driver waited before giving up, in ms. */
+    readonly waitedMs: number;
+}
+export declare const EMPTY_OBSERVATION: BrowserObservation;
+/** An element the way a scenario stores it — role+name+selector — restated here rather than
+ *  imported from the scenario format (this port must stay readable with no scenario format in
+ *  the process, same reasoning as `ScenarioActionKind` mirroring `BrowserActionKind` the other
+ *  way). `selector` stays nullable, unlike the scenario's `TargetDescriptor` — an element with no
+ *  stable hook can still be acted on mid-session, it just can never be *saved* (B1, unchanged). */
+export interface PerformedTarget {
+    readonly role: string;
+    readonly name: string;
+    readonly selector: string | null;
+}
+/** One action this session actually performed, kept for the session's whole lifetime —
+ *  unlike `ObservedAction`, this is never drained. It is provenance for `browser_save_scenario`:
+ *  a step recorded here was necessarily resolvable at the moment it ran, on this session's own
+ *  consented origin (every action here acts on a ref that only exists because a snapshot of a
+ *  consented page issued it) — stronger evidence than re-resolving the same step against a LATER
+ *  static snapshot, which is exactly what fails for a UI that reveals controls progressively.
+ *  Assertions have no counterpart here: an assertion is never "performed". */
+export interface PerformedStep {
+    readonly action: BrowserActionKind;
+    /** The element actually resolved and acted on, at the moment this action ran. Null for `navigate`. */
+    readonly target: PerformedTarget | null;
+    /** Where a `navigate` went. Null for click/type/fill. */
+    readonly url: string | null;
+    /** What was entered, for `type`/`fill`. Null otherwise. */
+    readonly text: string | null;
+    readonly at: string;
+}
+/**
+ * One cookie to seed before the first navigation (11.4-b). Deliberately carries no
+ * `domain`: the driver sets it to the target origin's own, so a caller cannot name a
+ * second origin here even by mistake — accepting one would silently widen the
+ * single-origin consent every other browser tool is bound to.
+ */
+export interface SeededCookie {
+    readonly name: string;
+    readonly value: string;
+    /** Defaults to "/" when omitted. */
+    readonly path?: string;
+    readonly httpOnly?: boolean;
+    readonly secure?: boolean;
+    readonly sameSite?: "Strict" | "Lax" | "None";
+}
+/**
+ * An already-authenticated session to seed before the first navigation — 11.4-b.
+ * Without this, browser tooling can drive a login *form* within the consented
+ * origin but cannot reach a screen that requires an existing session, and
+ * re-authenticates on every fresh session. Both halves are same-origin by
+ * construction: `SeededCookie` carries no domain, and `localStorage` here is a
+ * flat key/value map for the one consented origin rather than Playwright's own
+ * multi-origin `storageState` array — a second origin has no field to name.
+ */
+export interface BrowserStorageState {
+    readonly cookies?: readonly SeededCookie[];
+    readonly localStorage?: Readonly<Record<string, string>>;
+}
+/**
+ * What `BrowserPageSession.injectStorageState` actually did — the mid-session
+ * counterpart to `BrowserLaunchOptions.storageState`, which only ever seeds
+ * before the first navigation. A scenario's sign-in step needs this to land a
+ * previously captured session (`browser_start_session`'s `saveStorageStateTo`
+ * half, or any other cookie/token) into a session that is already open and
+ * has already navigated somewhere.
+ */
+export interface StorageStateInjectionResult {
+    readonly cookiesInjected: number;
+    readonly localStorageInjected: number;
+    /**
+     * Non-null when one or more `localStorage` entries were requested for an
+     * origin the page is not currently showing. A page can only write
+     * `localStorage` for its own current origin — there is no browser
+     * primitive that writes it for an origin the page isn't on — so those
+     * entries were skipped rather than silently dropped or written to the
+     * wrong origin. Cookies are unaffected: they land regardless of the page's
+     * current origin.
+     */
+    readonly localStorageSkipped: string | null;
+}
+export interface BrowserLaunchOptions {
+    readonly targetUrl: string;
+    readonly headless?: boolean;
+    readonly storageState?: BrowserStorageState;
+    /**
+     * Headers added to requests **on this session's own origin only** — B1.
+     *
+     * The second way an application authenticates a browser, and the one a
+     * storage state cannot express: a bearer token that lives in the caller's
+     * hands rather than in the browser's.
+     *
+     * The origin restriction is load-bearing and belongs on the port rather
+     * than in a driver's discretion. A header set on a whole browser travels
+     * with every request that browser makes, which on an ordinary page means
+     * the third-party scripts, fonts and analytics endpoints it loads — so an
+     * unrestricted implementation of this field hands the developer's token to
+     * everyone their page embeds. A driver that cannot scope it must not
+     * implement it.
+     */
+    readonly extraHttpHeaders?: Readonly<Record<string, string>>;
+    /**
+     * Write this session's cookies and stored data here when it closes, so a
+     * login performed once can seed later sessions — B1's "log in once" half.
+     *
+     * Absolute, and the caller above has already refused a path inside the
+     * repository: the file is a live credential.
+     */
+    readonly saveStorageStateTo?: string;
+}
+/** launchBrowserSessionOrRefuse's refusal, unchanged. `remedy` is supplied by the driver
+ *  (CHROMIUM_INSTALL_REMEDY), never held as a constant here — a copy would be a second
+ *  source of truth that goes stale. */
+export interface ChromiumRefusal {
+    readonly refusal: "chromiumNotInstalled";
+    readonly message: string;
+    readonly remedy: string;
+    readonly expectedExecutablePath: string;
+}
+export type BrowserLaunchResult = {
+    readonly launched: true;
+    readonly session: BrowserPageSession;
+} | ({
+    readonly launched: false;
+} & ChromiumRefusal);
+/** The browser died. Distinct from a closed session: a crash invalidates the id rather than ending it cleanly. */
+export declare class BrowserSessionCrashedError extends Error {
+    readonly sessionId: string;
+    constructor(sessionId: string);
+}
+/** The ref named no element in the current snapshot. Thrown for an invented ref and for a
+ *  ref from a superseded snapshot alike — both are acting on an element the agent never saw;
+ *  falling back to a stale selector could click whatever now matches on an uninspected page. */
+export declare class UnknownElementRefError extends Error {
+    constructor(ref: string);
+}
+/** The ref named an element that is not a chooser, so there is no option to pick. Distinct
+ *  from `NoSuchOptionError`: one says "wrong kind of element", the other "right element,
+ *  wrong value", and they send a caller to two different fixes. */
+export declare class NotSelectableError extends Error {
+    constructor(ref: string, role: string);
+}
+/** The element is a chooser, but nothing it offers matches the value asked for. Carries the
+ *  real option list rather than a count: the next call needs the labels, and a caller told
+ *  only "no match" has to spend a round trip discovering them. */
+export declare class NoSuchOptionError extends Error {
+    readonly available: readonly string[];
+    constructor(ref: string, value: string, available: readonly string[]);
+}
+/** Nothing about this element amounts to a submit. Either it is in no form at all, or its
+ *  form carries no submit control — in which case whatever submits it is a script on some
+ *  other control, and clicking that control is the honest way to reach it. */
+export declare class NotSubmittableError extends Error {
+    constructor(ref: string, reason: "noForm" | "noSubmitControl");
+}
+/**
+ * The element is on the page and cannot be operated by a person.
+ *
+ * Distinct from every refusal above it, which say the element is the wrong
+ * *kind* of thing. This one says it is the right kind and the page has put it
+ * out of reach — an `inert` subtree under a modal, or a disabled control.
+ *
+ * It exists because `click` gets this check from Playwright's own actionability
+ * rules and `select`/`submit` do not: `selectOption` does not hit-test, and a
+ * form submitted through `requestSubmit()` in page script is not checked at
+ * all. So two verbs could drive a control their sibling `click` correctly
+ * refused, and rule 2 makes that worse than a missing capability — a false
+ * success is recorded as reach.
+ */
+export declare class NotOperableError extends Error {
+    constructor(ref: string, reason: "inert" | "disabled");
+}
+export interface WaitForOptions {
+    /** Hard ceiling in ms. The driver applies its own maximum; the outcome reports the ceiling actually used. */
+    readonly timeoutMs?: number;
+}
+/**
+ * What a wait ended up seeing.
+ *
+ * Always carries a fresh snapshot, on both outcomes. On success because the element the
+ * wait was for has just come into existence and needs a ref; on a timeout because "it did
+ * not appear" and "here is what is there instead" is the difference between a caller that
+ * can act next and one that has to guess. Taking it invalidates every earlier ref, which is
+ * a real consequence of waiting for a page to change and is disclosed rather than hidden.
+ */
+export interface WaitForOutcome {
+    readonly appeared: boolean;
+    /** How long was actually spent waiting, in ms. */
+    readonly waitedMs: number;
+    /** The ceiling that applied, after the driver's own maximum. Reported so a caller can tell a short wait from a clamped one. */
+    readonly timeoutMs: number;
+    /** The first element that satisfied the target, or null. */
+    readonly matched: SnapshotElement | null;
+    /** How many elements satisfied it. More than one is not a refusal — the question a wait asks is whether the thing is there — but a caller acting on `matched` should know it was not the only one. */
+    readonly matchCount: number;
+    /** The page as it stood when the wait ended. Every ref issued before this call is now stale. */
+    readonly snapshot: PageSnapshot;
+}
+export interface BrowserPageSession {
+    readonly sessionId: string;
+    /** When the page was actually created, ISO-8601. What evidence is ordered by. */
+    readonly startedAt: string;
+    /** False once the page crashed or closed. Not derivable from closure — runtime-browser
+     *  verified a real crash still reports isClosed() === false, so this is a member, not
+     *  something a caller computes. */
+    isUsable(): boolean;
+    currentUrl(): string;
+    navigate(url: string): Promise<void>;
+    snapshot(options?: SnapshotOptions): Promise<PageSnapshot>;
+    click(ref: string): Promise<void>;
+    /** Types real keystrokes, appending to the field. Unlike `fill`, **this fires key events** —
+     *  an autocomplete, per-character validation, or debounced search sees nothing from `fill`.
+     *  Using `fill` on such a field is a wrong answer from entirely correct code. */
+    type(ref: string, text: string): Promise<void>;
+    /** Replace the element's value with `text`, setting it directly. Fires no key events. */
+    fill(ref: string, text: string): Promise<void>;
+    /** Choose `value` on a chooser, by option value or by the label a person reads — whichever
+     *  matches exactly. Refuses rather than picking a near match (`NoSuchOptionError`), and
+     *  refuses on an element that offers nothing to choose (`NotSelectableError`). */
+    select(ref: string, value: string): Promise<void>;
+    /** Submit the form `ref` sits in, through that form's own submit control, so the page sees
+     *  the submission it would see from a person. Refuses with `NotSubmittableError` when the
+     *  element is in no form, or in a form with no submit control — neither is guessed at. */
+    submit(ref: string): Promise<void>;
+    /** Wait until an element matching `target` is on the page, or until the ceiling. Performs
+     *  nothing, so it records no action; it is still not a pure read, because the fresh snapshot
+     *  it returns invalidates every ref issued before it. A timeout is an outcome, never a throw —
+     *  "it did not appear" is a fact about the page and the caller needs it in hand. */
+    waitFor(target: WaitForTarget, options?: WaitForOptions): Promise<WaitForOutcome>;
+    /** Everything witnessed since the last drain, removed as it's returned. Drained, not peeked —
+     *  a contract (§4 requires flush on four teardown paths): a peeking read would re-report
+     *  observations already attached to an earlier reply. */
+    /**
+     * Why a `saveStorageStateTo` write did not happen, or null — B1.
+     *
+     * Optional on the port because a driver that was never asked to save one
+     * has nothing to report, and a driver that saved successfully reports null.
+     * It exists at all because rule 7 makes a silent failure the wrong outcome:
+     * a caller who asked for a state and got none would otherwise find out on
+     * the next run, when a session seeded from an absent file quietly drove the
+     * logged-out surface.
+     */
+    storageStateSaveFailure?(): string | null;
+    /**
+     * Injects cookies and localStorage into this session's ALREADY-open
+     * browser context — the mid-session counterpart to
+     * `BrowserLaunchOptions.storageState`, which only ever seeds before the
+     * first navigation. A scenario's sign-in step uses this to land a
+     * previously captured session, or any other cookie/token, without
+     * replaying a login form on every run.
+     *
+     * `origin` is named explicitly, unlike the launch-time seed — a
+     * mid-drive page has quite possibly navigated away from the session's
+     * original target (an SSO redirect, for instance), so there is no single
+     * origin to default to the way there is at launch. Cookies land
+     * regardless of the page's current origin; `localStorage` can only be
+     * written for the origin the page is actually showing right now, and a
+     * mismatch is disclosed on the result (`StorageStateInjectionResult.
+     * localStorageSkipped`) rather than thrown or silently dropped.
+     */
+    injectStorageState(origin: string, state: BrowserStorageState): Promise<StorageStateInjectionResult>;
+    drainEvidence(): Promise<BrowserObservation>;
+    /** Every action this session has performed, in order, since it opened — never drained (contrast
+     *  `drainEvidence`), so `browser_save_scenario` can check a step against the whole session's
+     *  history, not just what has not yet been reported. There is no path back to a
+     *  `BrowserPageSession` once its session id is closed or reaped (`registry.ts`'s `use()` returns
+     *  `ok: false`), so this history is unreachable — never fabricable — after `browser_close_session`. */
+    performedSteps(): readonly PerformedStep[];
+    /**
+     * Count the shapes on this page that put reach at risk — shadow roots, child
+     * frames, windowed regions, a canvas, a password field, a challenge (§4.2).
+     *
+     * **Optional on purpose.** A driver that cannot probe must be able to say so
+     * by not having the method, because the alternative is a driver returning a
+     * fingerprint of zeroes, which reads as a clean page rather than as an
+     * unexamined one. `reach-recording-session.ts` records the absence as a skip.
+     */
+    fingerprint?(): Promise<PageFingerprint>;
+    /**
+     * RT-263: a fast, read-only reachability probe for `targetUrl`, run before a
+     * scenario replay spends real navigate/step timeouts discovering the same thing —
+     * "the application this session was opened against has since died." Optional
+     * because it is only meaningful for a page session actually backed by a network
+     * client; the fake driver used in tests has no real network to probe and correctly
+     * leaves this undefined rather than guessing an answer. `null` means "not
+     * applicable" (e.g. an unparseable target) — the caller should proceed as if this
+     * method did not exist, not treat it as a refusal.
+     */
+    probeTargetReachable?(targetUrl: string): Promise<{
+        readonly reachable: boolean;
+        readonly message: string;
+    } | null>;
+    /** Tear down and return whatever was still held. Idempotent, returns the final flush rather
+     *  than void — evidence captured then dropped is worse than never captured, since nothing
+     *  discloses it; every path, crash included, hands back what it was holding. */
+    close(): Promise<BrowserObservation>;
+}
+export interface BrowserDriver {
+    /** Open a session at targetUrl, or refuse. A missing browser is a **returned value**, never
+     *  a thrown error, so a tool mapping it to `refused` can't forget to catch it — `refused` is
+     *  a fact about Descry, never the user's code. */
+    launch(options: BrowserLaunchOptions): Promise<BrowserLaunchResult>;
+    /** Same probe as `BrowserPageSession.probeTargetReachable`, run before `launch()` itself —
+     *  see that method's doc. Optional for the same reason: the fake driver has nothing real
+     *  to probe. */
+    probeTargetReachable?(targetUrl: string): Promise<{
+        readonly reachable: boolean;
+        readonly message: string;
+    } | null>;
+}
+//# sourceMappingURL=driver.d.ts.map

package/dist/browser/driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../src/browser/driver.ts"],"names":[],"mappings":"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"}