cdp-toolkit 1.1.0 → 1.2.0

package/src/shared-tools.ts

@@ -38,6 +38,7 @@ import type {
   BrowserDriver, DriverUid, ElementLocator, NavigateResult, PageDriver, PageInfo, SnapshotNode,
 } from "./driver.ts";
 import type { TargetSelector } from "./types.ts";
+import { assertLeaseOk, claimLease, leaseTtlMs, releaseLeaseFor, type LeaseBackend, type LeaseToken } from "./leases.ts";
 
 const ARTIFACT_DIR = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 const STATE_DIR = process.env.CDP_STATE_DIR ?? "/tmp/cdp-toolkit";
@@ -49,6 +50,12 @@ function target3(p: PageInfo): { id: string; url: string; title: string } {
   return { id: p.id, url: p.url, title: p.title };
 }
 
+/** Same discriminator leases-tools.ts uses: the driver's own uid scheme tag
+ *  ("cdp" for Chrome, "bidi" for Firefox). */
+function backendOf(driver: BrowserDriver): LeaseBackend {
+  return driver.scheme === "bidi" ? "firefox" : "chrome";
+}
+
 /* -------------------------------- page acquisition -------------------------------- */
 
 /** Acquire, run, always release: the Driver counterpart of client.ts's withPage. */
@@ -61,14 +68,31 @@ async function withPage<T>(driver: BrowserDriver, target: TargetSelector | undef
   }
 }
 
+async function resolvePage(driver: BrowserDriver, selector?: TargetSelector): Promise<PageInfo> {
+  const pages = await driver.listPages();
+  const hit = await pickPage(driver, pages, selector);
+  // THE third choke point. close_page and select_page resolve here and nowhere
+  // else, so the lease check has to be here too, not only in resolveTarget /
+  // resolveContext. Closing someone else's leased tab is the worst version of
+  // the collision this feature exists to stop.
+  //
+  // Deliberately NOT passing liveIds, matching resolveTarget and resolveContext.
+  // For every branch but one it would be inert (hit is an element of `pages`),
+  // and for the bare-id branch it would be actively wrong: that branch can
+  // return a non-page target off the `all:true` listing, whose id is absent
+  // from `pages`, so passing pages' ids would report a perfectly healthy lease
+  // as target-gone and wave the caller straight through it.
+  await assertLeaseOk(backendOf(driver), hit.id, { url: hit.url, title: hit.title });
+  return hit;
+}
+
 /**
  * Same TargetSelector grammar as client.ts's resolveTarget. Matches its one asymmetry exactly:
  * every branch resolves against page-type targets only EXCEPT a bare-id lookup, which (like
  * legacy resolveTarget's `targets.find`) searches the FULL unfiltered listing, so passing an
  * exact non-page targetId (a worker, an iframe) still resolves.
  */
-async function resolvePage(driver: BrowserDriver, selector?: TargetSelector): Promise<PageInfo> {
-  const pages = await driver.listPages();
+async function pickPage(driver: BrowserDriver, pages: PageInfo[], selector?: TargetSelector): Promise<PageInfo> {
   if (selector === undefined || selector === "active") {
     if (!pages.length) throw new SharedToolError("no page targets open");
     return pages[0]!;
@@ -114,16 +138,38 @@ export async function listPages(driver: BrowserDriver, args: { all?: boolean } =
   return { pages, count: pages.length };
 }
 
-export async function newPage(driver: BrowserDriver, args: { url?: string } = {}): Promise<{ targetId: string; url: string }> {
+export async function newPage(
+  driver: BrowserDriver,
+  args: { url?: string; claim?: boolean; label?: string; ttlMs?: number } = {},
+): Promise<{ targetId: string; url: string; lease?: LeaseToken; label?: string; expiresAt?: number }> {
   const p = await driver.newPage(args.url);
-  return { targetId: p.id, url: p.url };
+  if (args.claim !== true) return { targetId: p.id, url: p.url };
+  // Atomic in the sense that matters: the tab is claimed before this call
+  // returns, so no other agent can see it unclaimed and take it first.
+  const { record, token } = await claimLease(backendOf(driver), p.id, {
+    label: typeof args.label === "string" && args.label.length ? args.label : `pid-${process.pid}`,
+    ttlMs: typeof args.ttlMs === "number" && args.ttlMs > 0 ? args.ttlMs : leaseTtlMs(),
+  });
+  return { targetId: p.id, url: p.url, lease: token, label: record.label, expiresAt: record.lastUsedAt + record.ttlMs };
 }
 
-export async function closePage(driver: BrowserDriver, args: { target?: TargetSelector }): Promise<{ closed: string; success: boolean }> {
+export async function closePage(
+  driver: BrowserDriver,
+  args: { target?: TargetSelector },
+): Promise<{ closed: string; success: boolean; leaseReleased?: boolean }> {
   if (args.target === undefined || args.target === "") throw new SharedToolError("close_page requires an explicit target; refusing to guess which page to close");
   const p = await resolvePage(driver, args.target);
   const res = await driver.closePage(p.id);
-  return { closed: p.id, success: res.success };
+  // A failed close (target refused to close, or was already gone) must leave
+  // the lease intact: the caller still owns a tab that never actually closed,
+  // and releasing it here would let another agent claim a tab this one still
+  // thinks it holds.
+  if (!res.success) return { closed: p.id, success: false, leaseReleased: false };
+  // Closing a leased tab must not leave its lease file behind waiting on the
+  // TTL. resolvePage above already refused this call unless the caller holds
+  // the lease, so no token is needed here.
+  const released = await releaseLeaseFor(backendOf(driver), p.id);
+  return { closed: p.id, success: true, ...(released.released ? { leaseReleased: true } : {}) };
 }
 
 async function writeSelectedFile(id: string): Promise<void> {

package/src/tools/console.ts

@@ -1,5 +1,5 @@
 /**
- * console.ts — read console output captured by the recorder.
+ * console.ts: read console output captured by the recorder.
  *
  *   list_console_messages -> listConsoleMessages
  *   get_console_message   -> getConsoleMessage
@@ -135,7 +135,7 @@ async function readConsoleEntries(file: string): Promise<ConsoleEntry[]> {
 }
 
 /**
- * list_console_messages — return console output for the target. With
+ * list_console_messages: return console output for the target. With
  * `reload:true`, records a fresh capture window by reloading the page.
  */
 export async function listConsoleMessages(args: ListConsoleMessagesArgs = {}): Promise<{
@@ -166,7 +166,7 @@ export async function listConsoleMessages(args: ListConsoleMessagesArgs = {}): P
 }
 
 /**
- * get_console_message — return a single console entry by index from the
+ * get_console_message: return a single console entry by index from the
  * existing buffer for the target. Throws if the index is out of range.
  */
 export async function getConsoleMessage(args: GetConsoleMessageArgs = {}): Promise<ConsoleEntry> {

package/src/tools/evaluate.ts

@@ -1,5 +1,5 @@
 /**
- * evaluate_script — run arbitrary JavaScript in a page's main context over raw
+ * evaluate_script: run arbitrary JavaScript in a page's main context over raw
  * CDP and return the evaluated value.
  *
  * Two modes, selected by whether `args` is supplied:
@@ -148,7 +148,7 @@ export async function evaluateScript(args: EvaluateScriptArgs): Promise<unknown>
  *
  * Parity gaps vs chrome-devtools-mcp evaluate_script:
  *   - MCP injects a typed `page`/element handle into the evaluated function; here `args` are plain
- *     JSON-serializable values passed positionally — no live element/page handle is bound.
+ *     JSON-serializable values passed positionally; no live element/page handle is bound.
  *   - Non-serializable return values (DOM nodes, functions, circular objects) come back as their CDP
  *     `description` string rather than a structured handle, since returnByValue is used.
  *   - No isolated-world/contextId selection: evaluation runs in the page's default main-world context.

package/src/tools/heap.ts

@@ -1,5 +1,5 @@
 /**
- * heap.ts — `take_heapsnapshot` over raw CDP.
+ * heap.ts: `take_heapsnapshot` over raw CDP.
  *
  * Captures a V8 heap snapshot of a page target and writes it as a
  * `.heapsnapshot` file (the JSON format DevTools' Memory panel loads).
@@ -7,7 +7,7 @@
  * CDP semantics this module relies on:
  *   - `HeapProfiler.takeHeapSnapshot` streams the snapshot back as a sequence
  *     of `HeapProfiler.addHeapSnapshotChunk` events. The command's own result
- *     does NOT carry the data — it resolves only after the final chunk has been
+ *     does NOT carry the data; it resolves only after the final chunk has been
  *     emitted. So we subscribe to the chunk event first, accumulate every
  *     chunk's string, then `await` the command; once it resolves we have the
  *     complete snapshot and join the chunks into one JSON document.
@@ -103,7 +103,7 @@ export async function takeHeapsnapshot(
  *
  * Parity gaps vs chrome-devtools-mcp `take_heapsnapshot`:
  *   - reportProgress is forced false; no incremental progress callbacks surfaced.
- *   - Returns {path,bytes,chunks,target} only — does not parse/summarize the
+ *   - Returns {path,bytes,chunks,target} only; does not parse/summarize the
  *     snapshot (node counts, retained sizes); the .heapsnapshot file is for the
  *     DevTools Memory panel to load, matching the MCP tool's artifact behavior.
  * --------------------------------------------------------------------------*/

package/src/tools/lighthouse.ts

@@ -1,5 +1,5 @@
 /**
- * lighthouse_audit — THE ONLY non-CDP tool in this toolkit.
+ * lighthouse_audit: THE ONLY non-CDP tool in this toolkit.
  *
  * Unlike every other module, this one does NOT speak the Chrome DevTools
  * Protocol over a WebSocket. Instead it shells out to the external Lighthouse
@@ -105,7 +105,7 @@ interface LighthouseReport {
 }
 
 export interface LighthouseAuditArgs {
-  /** The URL to audit. Required — never points at a user tab implicitly. */
+  /** The URL to audit. Required, and never points at a user tab implicitly. */
   url: string;
   /**
    * Lighthouse categories to run. Defaults to the full set.
@@ -206,7 +206,7 @@ export async function lighthouseAudit(
     const hint = /not found|could not determine executable|npm ERR|E404|ERR_MODULE/i.test(
       res.stderr,
     )
-      ? " The Lighthouse CLI could not be fetched/installed via npx — ensure network access and that 'lighthouse' is installable."
+      ? " The Lighthouse CLI could not be fetched/installed via npx; ensure network access and that 'lighthouse' is installable."
       : "";
     throw new CdpError(
       `lighthouse_audit produced no report (exit code ${res.code}).${hint} stderr: ${truncate(res.stderr)}`,
@@ -264,7 +264,7 @@ function truncate(s: string, max = 600): string {
  * ---------------------------------------------------------------------------
  * NON-CDP MODULE. This is the toolkit's sole tool that does not speak raw CDP.
  *
- * External dependency (subprocess, fetched on demand by npx — not an npm dep):
+ * External dependency (subprocess, fetched on demand by npx, not an npm dep):
  *   - `npx --yes lighthouse <url> --port=<cdpPort> --output=json
  *      --output-path=<artifact> --quiet --preset=desktop
  *      [--only-categories=...] --chrome-flags=--headless=new`

package/src/tools/navigation.ts

@@ -48,7 +48,7 @@ export interface NavigatePageResult {
  * finish loading.
  *
  * `Page.navigate`/`Page.reload` resolve once the action is *committed*. We
- * separately race the load milestone event — subscribed BEFORE issuing the
+ * separately race the load milestone event, subscribed BEFORE issuing the
  * command so a fast load can't fire before we're listening. Pass
  * `reload:true, ignoreCache:true` for a hard reload that refetches every
  * subresource (the only way to pick up a freshly-deployed bundle the HTTP

package/src/tools/network.ts

@@ -1,5 +1,5 @@
 /**
- * network.ts — read network activity captured by the recorder.
+ * network.ts: read network activity captured by the recorder.
  *
  *   list_network_requests -> listNetworkRequests
  *   get_network_request   -> getNetworkRequest
@@ -8,14 +8,14 @@
  *   - default ({ reload: false }): read the target's shared "latest" buffer
  *     (rec-<targetId>.jsonl), correlate the four Network.* events by requestId,
  *     and return one row per request.
- *   - { reload: true }: run a captureWindow (both domains) — Page.reload, capture
+ *   - { reload: true }: run a captureWindow (both domains): Page.reload, capture
  *     for `durationMs` (default 2500ms), stop, then read+return the requests.
  *
  * Response bodies: CDP only serves a body from the LIVE renderer session, so
  * get_network_request with { includeBody: true } drives a fresh reload capture
  * and calls Network.getResponseBody before closing. Because a reload re-mints
  * requestIds, body fetch is matched by `url` (stable), not by a carried-over
- * requestId — see getNetworkRequest for the exact contract.
+ * requestId; see getNetworkRequest for the exact contract.
  */
 import { readFile } from "node:fs/promises";
 import { CdpError, resolveTarget } from "../client.ts";
@@ -59,7 +59,7 @@ export interface ListNetworkRequestsArgs {
 
 export interface GetNetworkRequestArgs {
   target?: TargetSelector;
-  /** Match by exact requestId (metadata only — see includeBody). */
+  /** Match by exact requestId (metadata only, see includeBody). */
   requestId?: string;
   /** Match by URL substring (first match). Required for body fetch (includeBody). */
   url?: string;
@@ -153,7 +153,7 @@ async function readNetworkRequests(file: string): Promise<NetworkRequest[]> {
 }
 
 /**
- * list_network_requests — correlated request rows for the target. With
+ * list_network_requests: correlated request rows for the target. With
  * `reload:true`, records a fresh capture window (both domains) by reloading.
  */
 export async function listNetworkRequests(args: ListNetworkRequestsArgs = {}): Promise<{
@@ -187,13 +187,13 @@ export async function listNetworkRequests(args: ListNetworkRequestsArgs = {}): P
 }
 
 /**
- * get_network_request — return one request (matched by requestId, else by URL
+ * get_network_request: return one request (matched by requestId, else by URL
  * substring) including response status/headers.
  *
  * Body retrieval: CDP only serves a response body from the LIVE renderer
  * session, so `includeBody:true` must drive a fresh reload capture and fetch the
  * body before the connection closes. A reload re-mints requestIds, so a body
- * fetch can only be matched by `url` (stable across reload) — NOT by a
+ * fetch can only be matched by `url` (stable across reload), NOT by a
  * `requestId` carried over from a prior `list_network_requests`. When a
  * requestId is supplied with includeBody we therefore return metadata from the
  * existing buffer and explain why the body is unavailable, rather than reloading

package/src/tools/network_mock.ts

@@ -1,13 +1,13 @@
 /**
- * network_mock.ts — a per-target FAKE BACKEND for the page: intercept matching
+ * network_mock.ts: a per-target FAKE BACKEND for the page: intercept matching
  * requests via the CDP Fetch domain and fulfill them with a canned response,
  * fail (abort) them, or let them continue (optionally with fault injection).
  * The rod `HijackRequests` capability the read-only console/network tools lack.
  *
  * This file is split into two layers:
  *   1. PURE logic (urlMatches / selectRule / buildFulfillParams / effectiveAction)
- *      — no browser, unit-tested in test/network_mock.test.ts.
- *   2. STATEFUL tools (mockRequest / listMocks / clearMocks) — hold a persistent
+ *      No browser needed, unit-tested in test/network_mock.test.ts.
+ *   2. STATEFUL tools (mockRequest / listMocks / clearMocks): hold a persistent
  *      CDP connection per target; integration-tested in test/mock-smoke.ts.
  */
 import { CdpError, openPage, resolveTarget } from "../client.ts";
@@ -15,7 +15,7 @@ import type { CdpConnection } from "../client.ts";
 import type { Target, TargetSelector } from "../types.ts";
 
 /* ============================================================================
- * LAYER 1 — pure logic (no I/O)
+ * LAYER 1: pure logic (no I/O)
  * ========================================================================== */
 
 export type MockAction = "fulfill" | "fail" | "continue";
@@ -111,7 +111,7 @@ export function effectiveAction(rule: { action: MockAction; failRate?: number },
 }
 
 /* ============================================================================
- * LAYER 2 — stateful tools (persistent per-target CDP connection)
+ * LAYER 2: stateful tools (persistent per-target CDP connection)
  *
  * A "fake backend" is a per-target SESSION holding ONE persistent CDP connection
  * with the Fetch domain enabled. Each session carries a list of rules; an
@@ -122,7 +122,7 @@ export function effectiveAction(rule: { action: MockAction; failRate?: number },
  * Persistence works because the MCP server process is long-lived across tool
  * calls, so this module-level `sessions` map and its open connections outlive a
  * single call. (The stateless CLI process exits after one command, so persistent
- * mocking is an MCP-server capability — like the recorder's background mode.)
+ * mocking is an MCP-server capability, like the recorder's background mode.)
  *
  * SAFETY: every paused request MUST be answered or the renderer hangs. A request
  * that pauses but matches no rule is continued untouched.
@@ -182,7 +182,7 @@ function registerHandler(session: MockSession): void {
         session.intercepted.push({ url: p.request.url, method: p.request.method, action: act });
       })
       .catch((e) => {
-        // Tab navigated away mid-flight or the connection dropped — best-effort.
+        // Tab navigated away mid-flight or the connection dropped, best-effort.
         if (/closed|connection|Target|Inspected/i.test(String(e))) session.dead = true;
       });
   });
@@ -359,7 +359,7 @@ export async function clearMocks(args: ClearMocksArgs = {}): Promise<{ cleared:
  *   Page.enable + Page.reload (reload:true), Runtime.evaluate (liveness probe).
  * Model: persistent per-target session (like recorder.ts), MCP-server-scoped state.
  * Parity gaps vs rod HijackRequests / chrome-devtools-mcp:
- *   - Request-stage only — no live Response-body rewriting (add requestStage:"Response"
+ *   - Request-stage only, no live Response-body rewriting (add requestStage:"Response"
  *     + Fetch.getResponseBody/continueResponse for that).
  *   - Persistence is in-process: works via the long-lived MCP server, not the
  *     one-shot CLI (mirrors the recorder's background mode).

package/src/tools/performance.ts

@@ -1,19 +1,19 @@
 /**
- * performance.ts — performance tracing + insight analysis over raw CDP.
+ * performance.ts: performance tracing + insight analysis over raw CDP.
  *
  * NOTE ON THE INSIGHT ANALYZER: `performanceAnalyzeInsight` is a CDP-native
  * APPROXIMATION of chrome-devtools-mcp's insight analyzer. The MCP tool runs the
  * DevTools/Lighthouse "Trace Engine" insight pipeline (a large TS engine that
  * models the full RAIL/Core-Web-Vitals heuristics). We do NOT vendor that
  * engine (zero-runtime-deps rule). Instead we parse the raw Chrome trace event
- * stream ourselves and derive the headline metrics — navigationStart, FCP, LCP,
- * long tasks (>50ms), layout shifts / CLS, and total blocking time — directly
+ * stream ourselves and derive the headline metrics (navigationStart, FCP, LCP,
+ * long tasks (>50ms), layout shifts / CLS, and total blocking time) directly
  * from the trace events. Numbers will be close to but not byte-identical with
  * the MCP/DevTools panel, which applies extra normalization (e.g. main-thread
  * attribution, frame-scoped LCP, soft-navigation handling).
  *
  * NOTE ON TRACING STATE: CDP `Tracing.start`/`Tracing.end` are bound to a single
- * live session — the recording lives on the WebSocket connection, and
+ * live session: the recording lives on the WebSocket connection, and
  * `Tracing.dataCollected` events stream back on that same connection. There is
  * no way to "re-attach" to an in-flight trace from a fresh process, because the
  * buffer is owned by the connection that started it. Cross-process persistence
@@ -213,7 +213,7 @@ export async function performanceStopTrace(
 ): Promise<{ path: string; bytes: number; events: number; metrics: TraceMetrics }> {
   // CDP tracing is browser-GLOBAL: a second Tracing.start throws "Tracing has
   // already been started", so at most one trace is ever live in this process.
-  // There is therefore nothing to disambiguate by target — take the single live
+  // There is therefore nothing to disambiguate by target; take the single live
   // trace if present. (`args.target` is accepted for API symmetry with start.)
   void args.target;
   const entry: LiveTrace | undefined = liveTraces.size === 1 ? [...liveTraces.values()][0] : undefined;
@@ -250,7 +250,7 @@ export async function performanceStopTrace(
 }
 
 /* ------------------------------------------------------------------ */
-/* performanceTrace (PRIMARY one-shot — the smoke path)               */
+/* performanceTrace (PRIMARY one-shot, the smoke path)                */
 /* ------------------------------------------------------------------ */
 
 export interface PerformanceTraceArgs {
@@ -366,7 +366,7 @@ export function analyzeEvents(events: TraceEvent[]): TraceMetrics {
       continue;
     }
 
-    // LCP candidate — the LAST candidate before user input is the real LCP.
+    // LCP candidate: the LAST candidate before user input is the real LCP.
     if (name === "largestContentfulPaint::Candidate" && typeof e.ts === "number") {
       // candidates are monotonic; keep the latest timestamp seen.
       if (lcpUs === undefined || e.ts > lcpUs) lcpUs = e.ts;
@@ -383,7 +383,7 @@ export function analyzeEvents(events: TraceEvent[]): TraceMetrics {
       continue;
     }
 
-    // Layout shifts — sum scores that did NOT follow recent user input.
+    // Layout shifts: sum scores that did NOT follow recent user input.
     if (name === "LayoutShift") {
       const data = e.args?.data;
       const hadRecentInput = data?.had_recent_input === true;
@@ -438,7 +438,7 @@ export interface PerformanceAnalyzeInsightArgs {
 /**
  * CDP-native approximation of the MCP insight analyzer. Reads a trace JSON file
  * (bare array OR { traceEvents: [...] }) and returns structured headline
- * metrics. If `tracePath` is omitted, throws — there is no implicit "latest
+ * metrics. If `tracePath` is omitted, throws; there is no implicit "latest
  * trace" magic; callers pass the path returned by a trace tool.
  */
 export async function performanceAnalyzeInsight(
@@ -473,9 +473,9 @@ export async function performanceAnalyzeInsight(
 /*
  * CDP methods/domains used:
  *   - Tracing.start (traceConfig.includedCategories, transferMode:ReportEvents)
- *   - Tracing.dataCollected   (event — buffered into the event array)
+ *   - Tracing.dataCollected   (event, buffered into the event array)
  *   - Tracing.end
- *   - Tracing.tracingComplete (event — awaited to know recording is flushed)
+ *   - Tracing.tracingComplete (event, awaited to know recording is flushed)
  *   - Page.enable / Page.navigate / Page.reload / Page.loadEventFired (one-shot reload path)
  *
  * Parity gaps vs chrome-devtools-mcp performance tools:

package/src/tools/recorder.ts

@@ -1,5 +1,5 @@
 /**
- * recorder.ts — the stateful console+network capture engine.
+ * recorder.ts: the stateful console+network capture engine.
  *
  * RECORDER MODEL
  * ==============
@@ -22,7 +22,7 @@
  *
  * CAPTURE MODEL (what the tool surface actually uses)
  * ---------------------------------------------------
- * The console/network tools drive `captureWindow()` — a one-shot reload capture
+ * The console/network tools drive `captureWindow()`, a one-shot reload capture
  * that records BOTH domains into a UNIQUE per-capture file
  * (`rec-<targetId>-<captureId>.jsonl`) and, on stop, publishes that capture as
  * the target's shared "latest" buffer (`rec-<targetId>.jsonl`). Capturing both
@@ -154,7 +154,7 @@ export async function startRecorder(target: TargetSelector, opts: RecorderOption
       try {
         await conn.send("Log.enable");
       } catch {
-        /* Log not supported on this target type — Runtime events still flow */
+        /* Log not supported on this target type; Runtime events still flow */
       }
       for (const ev of CONSOLE_EVENTS) {
         unsubs.push(conn.on(ev, (params) => persist("console", ev, params)));
@@ -165,7 +165,7 @@ export async function startRecorder(target: TargetSelector, opts: RecorderOption
     throw err;
   }
 
-  // Stop accepting new events, then let queued appends settle — without closing
+  // Stop accepting new events, then let queued appends settle, without closing
   // the connection (response bodies stay fetchable on `conn`).
   const flush = async (): Promise<void> => {
     for (const off of unsubs) off();
@@ -195,7 +195,7 @@ export async function startRecorder(target: TargetSelector, opts: RecorderOption
 export interface CaptureWindow {
   /** The unique per-capture buffer file (read this for isolated results). */
   file: string;
-  /** Live connection (open until stop) — for Network.getResponseBody etc. */
+  /** Live connection (open until stop), for Network.getResponseBody etc. */
   conn: CdpConnection;
   /** Resolved target identity. */
   resolved: { id: string; url: string; title: string };

package/src/tools/snapshot.ts

@@ -3,7 +3,7 @@
  *
  * The reference scheme (CONTRACT.md "The element-reference scheme"):
  *   A `Uid` IS a CDP `backendDOMNodeId` (a number). Refs are therefore
- *   stateless — `take_snapshot` emits them straight from the a11y tree, and
+ *   stateless: `take_snapshot` emits them straight from the a11y tree, and
  *   every interaction tool resolves them back to a live DOM node via
  *   `DOM.resolveNode({ backendNodeId: uid })`. There is no server-side ref
  *   table to drift or expire.
@@ -124,7 +124,7 @@ export interface TakeSnapshotResult {
 }
 
 /**
- * take_snapshot — Accessibility.getFullAXTree walked into a compact indented
+ * take_snapshot: Accessibility.getFullAXTree walked into a compact indented
  * text tree. Each emitted line carries the node's backendDOMNodeId as [uid],
  * which interaction tools feed straight back to resolveUid.
  */