@monoes/monobrowse 1.0.11 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monobrowse",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Native browser automation via Chrome DevTools Protocol — the engine powering monomind browse",
   "type": "module",
   "bin": {

package/src/__tests__/adapters.test.ts

@@ -2,7 +2,7 @@
  * Platform adapters are pure declarations plus two tiny page-probing methods.
  * A fake PageInterface (evaluate + url) is all that's needed — no browser.
  */
-import { describe, it, expect, vi } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { adapters, getAdapter, type PageInterface } from '../browser/adapters/index.js';
 
 const PLATFORMS = ['linkedin', 'instagram', 'x', 'gemini', 'google', 'microsoft'] as const;
@@ -32,7 +32,7 @@ describe('getAdapter', () => {
 
   it('throws for an unknown platform, listing the supported ones', () => {
     expect(() => getAdapter('myspace')).toThrow(
-      `Unknown platform: myspace. Supported: ${PLATFORMS.join(', ')}`
+      `Unknown platform: myspace. Supported: ${PLATFORMS.join(', ')}`,
     );
   });
 
@@ -72,12 +72,19 @@ describe('adapter invariants', () => {
 
 describe('isLoggedIn', () => {
   it('coerces the page probe to the boolean the caller expects', async () => {
-    await expect(getAdapter('linkedin').isLoggedIn(fakePage({ evaluate: true }))).resolves.toBe(true);
-    await expect(getAdapter('linkedin').isLoggedIn(fakePage({ evaluate: false }))).resolves.toBe(false);
+    await expect(getAdapter('linkedin').isLoggedIn(fakePage({ evaluate: true }))).resolves.toBe(
+      true,
+    );
+    await expect(getAdapter('linkedin').isLoggedIn(fakePage({ evaluate: false }))).resolves.toBe(
+      false,
+    );
   });
 
   it('google short-circuits to false on the sign-in page without probing the DOM', async () => {
-    const page = fakePage({ url: 'https://accounts.google.com/signin/v2/identifier', evaluate: true });
+    const page = fakePage({
+      url: 'https://accounts.google.com/signin/v2/identifier',
+      evaluate: true,
+    });
     await expect(getAdapter('google').isLoggedIn(page)).resolves.toBe(false);
     expect(page.evaluated).toEqual([]);
   });
@@ -109,9 +116,9 @@ describe('isLoggedIn', () => {
 describe('extractUsername', () => {
   it('returns whatever the page evaluation yields', async () => {
     for (const key of PLATFORMS) {
-      await expect(getAdapter(key).extractUsername(fakePage({ evaluate: 'someuser' }))).resolves.toBe(
-        'someuser'
-      );
+      await expect(
+        getAdapter(key).extractUsername(fakePage({ evaluate: 'someuser' })),
+      ).resolves.toBe('someuser');
     }
   });
 

package/src/__tests__/batch-eval-parsing.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { parseBatchCommandLine } from '../cli/commands.js';
 
 describe('parseBatchCommandLine — eval expressions inside a batch command string', () => {
@@ -25,7 +25,9 @@ describe('parseBatchCommandLine — eval expressions inside a batch command stri
     const input = "eval [...document.querySelectorAll('li')].map(x => x.textContent.trim())";
     const { subName, subArgs } = parseBatchCommandLine(input);
     expect(subName).toBe('eval');
-    expect(subArgs).toEqual(["[...document.querySelectorAll('li')].map(x => x.textContent.trim())"]);
+    expect(subArgs).toEqual([
+      "[...document.querySelectorAll('li')].map(x => x.textContent.trim())",
+    ]);
   });
 
   it('still recognizes --json and --max-output flags placed before the expression', () => {

package/src/__tests__/box-model.test.ts

@@ -1,10 +1,10 @@
-import { describe, it, expect, vi } from 'vitest';
-import { deriveBoxOutput } from '../cli/commands.js';
+import { describe, expect, it, vi } from 'vitest';
 import { getElementBox } from '../browser/snapshot.js';
 import type { ElementRef } from '../browser/types.js';
+import { deriveBoxOutput } from '../cli/commands.js';
 
 describe('getElementBox (issue #15: center-vs-top-left contract)', () => {
-  it('averages the CDP content quad\'s four corners into a center point', async () => {
+  it("averages the CDP content quad's four corners into a center point", async () => {
     // Content quad order per CDP DOM.getBoxModel: [x1,y1 top-left, x2,y2
     // top-right, x3,y3 bottom-right, x4,y4 bottom-left]. A 372x37 box whose
     // top-left is (454, 513.5) — matching the issue's own reproduction data.
@@ -28,8 +28,12 @@ describe('deriveBoxOutput (issue #15: get box exposing both conventions)', () =>
     const center = { x: 640, y: 532, width: 372, height: 37 };
     const result = deriveBoxOutput(center);
     expect(result).toEqual({
-      x: 454, y: 513.5, width: 372, height: 37,
-      centerX: 640, centerY: 532,
+      x: 454,
+      y: 513.5,
+      width: 372,
+      height: 37,
+      centerX: 640,
+      centerY: 532,
     });
   });
 

package/src/__tests__/browser-launch.test.ts

@@ -8,9 +8,10 @@
  * Fixed port range (23470-23479) chosen to avoid colliding with real
  * services; each test binds/tears down its own listeners.
  */
-import { describe, it, expect, afterEach } from 'vitest';
-import { createServer as createTcpServer, type Server as TcpServer, type Socket } from 'net';
-import { createServer as createHttpServer, type Server as HttpServer } from 'http';
+
+import { createServer as createHttpServer, type Server as HttpServer } from 'node:http';
+import { createServer as createTcpServer, type Socket, type Server as TcpServer } from 'node:net';
+import { afterEach, describe, expect, it } from 'vitest';
 import { launchBrowser } from '../browser/browser.js';
 
 const BASE = 23470;
@@ -24,16 +25,21 @@ afterEach(async () => {
   // to close on their own, which can outlast the test. Destroy explicitly.
   for (const sock of sockets) sock.destroy();
   sockets = [];
-  await Promise.all(servers.map(s => new Promise<void>(resolve => s.close(() => resolve()))));
+  await Promise.all(servers.map((s) => new Promise<void>((resolve) => s.close(() => resolve()))));
   servers = [];
 }, 5000);
 
 /** Bind a bare TCP listener — accepts connections but speaks no HTTP/CDP. */
 function occupyNonChrome(port: number): Promise<void> {
   return new Promise((resolve, reject) => {
-    const s = createTcpServer(sock => { sockets.push(sock); /* accept and do nothing — no CDP response */ });
+    const s = createTcpServer((sock) => {
+      sockets.push(sock); /* accept and do nothing — no CDP response */
+    });
     s.once('error', reject);
-    s.listen(port, '127.0.0.1', () => { servers.push(s); resolve(); });
+    s.listen(port, '127.0.0.1', () => {
+      servers.push(s);
+      resolve();
+    });
   });
 }
 
@@ -45,12 +51,16 @@ function occupyChrome(port: number): Promise<void> {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ Browser: 'Chrome/999.0.0.0' }));
       } else {
-        res.writeHead(404); res.end();
+        res.writeHead(404);
+        res.end();
       }
     });
-    s.on('connection', sock => sockets.push(sock));
+    s.on('connection', (sock) => sockets.push(sock));
     s.once('error', reject);
-    s.listen(port, '127.0.0.1', () => { servers.push(s); resolve(); });
+    s.listen(port, '127.0.0.1', () => {
+      servers.push(s);
+      resolve();
+    });
   });
 }
 
@@ -65,8 +75,9 @@ describe('launchBrowser — port scan/attach decisions', () => {
     const port = BASE + 1;
     await occupyNonChrome(port);
     await occupyChrome(port + 1); // would succeed if scanning happened — must not be reached
-    await expect(launchBrowser({ port, strictPort: true }))
-      .rejects.toThrow(/does not identify as Chrome/);
+    await expect(launchBrowser({ port, strictPort: true })).rejects.toThrow(
+      /does not identify as Chrome/,
+    );
   });
 
   it('strictPort: attaches on an occupied Chrome requested port (identical to non-strict)', async () => {
@@ -80,7 +91,7 @@ describe('launchBrowser — port scan/attach decisions', () => {
     // Occupy the full 10-port scan window with non-Chrome listeners.
     for (let i = 0; i < 10; i++) await occupyNonChrome(port + i);
     await expect(launchBrowser({ port })).rejects.toThrow(
-      new RegExp(`Ports ${port}-${port + 9} are all occupied`)
+      new RegExp(`Ports ${port}-${port + 9} are all occupied`),
     );
   }, 15000); // generous margin — 10 candidates, each a fast isTcpPortOpen check
 
@@ -92,11 +103,11 @@ describe('launchBrowser — port scan/attach decisions', () => {
     // skipped, so if every candidate is occupied the call still fails even
     // though one of them is an attachable Chrome.
     const port = BASE + 4;
-    await occupyNonChrome(port);       // requested port: occupied, not Chrome
-    await occupyChrome(port + 1);      // scanned candidate: IS Chrome — must be skipped, not attached
+    await occupyNonChrome(port); // requested port: occupied, not Chrome
+    await occupyChrome(port + 1); // scanned candidate: IS Chrome — must be skipped, not attached
     for (let i = 2; i < 10; i++) await occupyNonChrome(port + i); // remaining candidates: occupied
     await expect(launchBrowser({ port })).rejects.toThrow(
-      new RegExp(`Ports ${port}-${port + 9} are all occupied`)
+      new RegExp(`Ports ${port}-${port + 9} are all occupied`),
     );
   }, 15000); // generous margin — 10 candidates, each a fast isTcpPortOpen check
 });

package/src/__tests__/cdp-client.test.ts

@@ -5,7 +5,7 @@
  * `ws` module (so we can drive 'message'/'close'/'error' by hand), and
  * fetchTargets/fetchNewTarget run against a stubbed global fetch.
  */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 // --- fake `ws` -------------------------------------------------------------
 // Captures the most recently constructed socket so tests can drive its events.
@@ -140,7 +140,9 @@ describe('send', () => {
   it('refuses to exceed the 1000 in-flight command cap', async () => {
     const { client } = await connected();
     const inflight = Array.from({ length: 1000 }, () => client.send('A').catch(() => {}));
-    await expect(client.send('A')).rejects.toThrow('CDP command queue full (>1000 in-flight commands)');
+    await expect(client.send('A')).rejects.toThrow(
+      'CDP command queue full (>1000 in-flight commands)',
+    );
     client.close();
     await Promise.all(inflight);
   });
@@ -152,7 +154,9 @@ describe('send', () => {
     it('rejects a command with no response after the default 30s timeout', async () => {
       const { client } = await connected();
       const p = client.send('Runtime.evaluate');
-      const assertion = expect(p).rejects.toThrow('CDP command "Runtime.evaluate" timed out after 30000ms');
+      const assertion = expect(p).rejects.toThrow(
+        'CDP command "Runtime.evaluate" timed out after 30000ms',
+      );
       await vi.advanceTimersByTimeAsync(30_000);
       await assertion;
     });
@@ -171,7 +175,13 @@ describe('send', () => {
       await vi.advanceTimersByTimeAsync(60_000);
       // Still pending — no timeout fired.
       let settled = false;
-      void p.then(() => { settled = true; }).catch(() => { settled = true; });
+      void p
+        .then(() => {
+          settled = true;
+        })
+        .catch(() => {
+          settled = true;
+        });
       await Promise.resolve();
       expect(settled).toBe(false);
       ws.deliver({ id: 1, result: {} });
@@ -331,21 +341,27 @@ describe('fetchTargets / fetchNewTarget', () => {
     globalThis.fetch = realFetch;
   });
 
-  function stubFetch(impl: (url: string, init?: RequestInit) => Response): ReturnType<typeof vi.fn> {
+  function stubFetch(
+    impl: (url: string, init?: RequestInit) => Response,
+  ): ReturnType<typeof vi.fn> {
     const fn = vi.fn((url: string, init?: RequestInit) => Promise.resolve(impl(url, init)));
     globalThis.fetch = fn as unknown as typeof fetch;
     return fn;
   }
 
   it('fetchTargets hits /json/list on the given port', async () => {
-    const fn = stubFetch(() => new Response(JSON.stringify([{ id: 'T1', type: 'page' }]), { status: 200 }));
+    const fn = stubFetch(
+      () => new Response(JSON.stringify([{ id: 'T1', type: 'page' }]), { status: 200 }),
+    );
     await expect(fetchTargets(9333)).resolves.toEqual([{ id: 'T1', type: 'page' }]);
     expect(fn.mock.calls[0]![0]).toBe('http://127.0.0.1:9333/json/list');
   });
 
   it('fetchTargets throws on a non-OK response', async () => {
     stubFetch(() => new Response('nope', { status: 500, statusText: 'Internal Server Error' }));
-    await expect(fetchTargets(9222)).rejects.toThrow('Failed to fetch targets: Internal Server Error');
+    await expect(fetchTargets(9222)).rejects.toThrow(
+      'Failed to fetch targets: Internal Server Error',
+    );
   });
 
   it('fetchNewTarget uses PUT and percent-encodes the URL', async () => {
@@ -354,7 +370,7 @@ describe('fetchTargets / fetchNewTarget', () => {
     const [url, init] = fn.mock.calls[0] as [string, RequestInit];
     expect(init.method).toBe('PUT');
     expect(url).toBe(
-      'http://127.0.0.1:9222/json/new?' + encodeURIComponent('https://x.test/a?b=1&c=2')
+      `http://127.0.0.1:9222/json/new?${encodeURIComponent('https://x.test/a?b=1&c=2')}`,
     );
     // The query separators of the target URL must not leak into Chrome's own query.
     expect(url.split('?').length).toBe(2);
@@ -363,7 +379,7 @@ describe('fetchTargets / fetchNewTarget', () => {
   it('fetchNewTarget throws on a non-OK response', async () => {
     stubFetch(() => new Response('', { status: 405, statusText: 'Method Not Allowed' }));
     await expect(fetchNewTarget(9222, 'about:blank')).rejects.toThrow(
-      'Failed to create target: Method Not Allowed'
+      'Failed to create target: Method Not Allowed',
     );
   });
 

package/src/__tests__/close-browser.test.ts

@@ -11,11 +11,12 @@
  * fake `ws` socket (same pattern as cdp-client.test.ts), and process.kill is
  * spied on rather than actually signaling anything.
  */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdtemp, rm, mkdir, writeFile } from 'fs/promises';
-import { setTimeout as realDelay } from 'timers/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
+
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as realDelay } from 'node:timers/promises';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 let lastSocket: FakeWs | null = null;
 
@@ -73,7 +74,11 @@ afterEach(async () => {
 async function writePersistedPort(port: number, pid: number, savedAt: number): Promise<void> {
   const dir = join(tempDir, '.monomind', 'monobrowse');
   await mkdir(dir, { recursive: true });
-  await writeFile(join(dir, 'active-port.json'), JSON.stringify({ port, pid, launched: true, savedAt }), 'utf-8');
+  await writeFile(
+    join(dir, 'active-port.json'),
+    JSON.stringify({ port, pid, launched: true, savedAt }),
+    'utf-8',
+  );
 }
 
 /**

package/src/__tests__/console-log.test.ts

@@ -3,14 +3,14 @@
  * two per-session Maps. Nothing here touches a browser — we hand it a fake
  * client that just records handlers and lets us fire events by hand.
  */
-import { describe, it, expect, beforeEach } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import type { CdpClient } from '../browser/cdp.js';
 import {
-  setupConsoleCapture,
-  getConsoleMessages,
   clearConsoleMessages,
-  getPageErrors,
   clearPageErrors,
+  getConsoleMessages,
+  getPageErrors,
+  setupConsoleCapture,
   teardownConsoleCapture,
 } from '../browser/console-log.js';
 
@@ -91,13 +91,17 @@ describe('Runtime.consoleAPICalled capture', () => {
     client.emit(
       'Runtime.consoleAPICalled',
       { type: 'log', args: [{ value: 'count:' }, { value: 42 }, { description: 'Object {a: 1}' }] },
-      'S1'
+      'S1',
     );
     expect(getConsoleMessages('S1')[0]!.text).toBe('count: 42 Object {a: 1}');
   });
 
   it('normalizes CDP\'s "warning" to the "warn" type used by ConsoleMessage', () => {
-    client.emit('Runtime.consoleAPICalled', { type: 'warning', args: [{ value: 'careful' }] }, 'S1');
+    client.emit(
+      'Runtime.consoleAPICalled',
+      { type: 'warning', args: [{ value: 'careful' }] },
+      'S1',
+    );
     expect(getConsoleMessages('S1')[0]!.type).toBe('warn');
   });
 
@@ -123,8 +127,15 @@ describe('Log.entryAdded capture', () => {
   it('records text, url and lineNumber and maps "warning" to "warn"', () => {
     client.emit(
       'Log.entryAdded',
-      { entry: { level: 'warning', text: 'deprecated API', url: 'https://x.test/a.js', lineNumber: 17 } },
-      'S1'
+      {
+        entry: {
+          level: 'warning',
+          text: 'deprecated API',
+          url: 'https://x.test/a.js',
+          lineNumber: 17,
+        },
+      },
+      'S1',
     );
     const [msg] = getConsoleMessages('S1');
     expect(msg).toMatchObject({
@@ -156,7 +167,7 @@ describe('Runtime.exceptionThrown capture', () => {
           columnNumber: 9,
         },
       },
-      'S1'
+      'S1',
     );
     expect(getPageErrors('S1')[0]).toMatchObject({
       text: 'TypeError: x is not a function',
@@ -167,7 +178,11 @@ describe('Runtime.exceptionThrown capture', () => {
   });
 
   it('falls back to text, then to "Unknown error"', () => {
-    client.emit('Runtime.exceptionThrown', { exceptionDetails: { text: 'Uncaught (in promise)' } }, 'S1');
+    client.emit(
+      'Runtime.exceptionThrown',
+      { exceptionDetails: { text: 'Uncaught (in promise)' } },
+      'S1',
+    );
     client.emit('Runtime.exceptionThrown', { exceptionDetails: {} }, 'S1');
     expect(getPageErrors('S1').map((e) => e.text)).toEqual([
       'Uncaught (in promise)',
@@ -191,14 +206,22 @@ describe('multi-session isolation and clearing', () => {
     client.emit('Runtime.exceptionThrown', { exceptionDetails: { text: 'e2' } }, 'S2');
   });
 
-  it('keeps each session\'s buffers separate', () => {
+  it("keeps each session's buffers separate", () => {
     expect(getConsoleMessages('S1').map((m) => m.text)).toEqual(['one']);
     expect(getConsoleMessages('S2').map((m) => m.text)).toEqual(['two']);
   });
 
   it('returns a flattened view across sessions when no session id is given', () => {
-    expect(getConsoleMessages().map((m) => m.text).sort()).toEqual(['one', 'two']);
-    expect(getPageErrors().map((e) => e.text).sort()).toEqual(['e1', 'e2']);
+    expect(
+      getConsoleMessages()
+        .map((m) => m.text)
+        .sort(),
+    ).toEqual(['one', 'two']);
+    expect(
+      getPageErrors()
+        .map((e) => e.text)
+        .sort(),
+    ).toEqual(['e1', 'e2']);
   });
 
   it('returns a copy, so mutating the result does not corrupt the buffer', () => {

package/src/__tests__/find.test.ts

@@ -5,21 +5,21 @@
  * browser at all: they filter the in-memory ref Map. findBySelector and
  * findByTestId do issue CDP commands, which a recording stub answers.
  */
-import { describe, it, expect, vi } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import type { CdpClient } from '../browser/cdp.js';
-import type { ElementRef } from '../browser/types.js';
 import {
-  findBySelector,
-  findByRole,
-  findByText,
   findByLabel,
   findByPlaceholder,
+  findByRole,
+  findBySelector,
   findByTestId,
+  findByText,
+  isChecked,
   isEnabled,
   isVisible,
-  isChecked,
   scrollIntoView,
 } from '../browser/find.js';
+import type { ElementRef } from '../browser/types.js';
 
 function ref(partial: Partial<ElementRef> & { ref: string }): ElementRef {
   return { role: 'generic', name: '', nodeId: 1, ...partial };
@@ -31,8 +31,21 @@ function sampleRefs(): Map<string, ElementRef> {
     ref({ ref: 'e1', role: 'button', name: 'Save changes', backendDOMNodeId: 11 }),
     ref({ ref: 'e2', role: 'BUTTON', name: 'Save', backendDOMNodeId: 12 }),
     ref({ ref: 'e3', role: 'link', name: 'Save as draft', backendDOMNodeId: 13 }),
-    ref({ ref: 'e4', role: 'textbox', name: 'Email', placeholder: 'you@example.com', backendDOMNodeId: 14 }),
-    ref({ ref: 'e5', role: 'textbox', name: 'Notes', placeholder: 'Optional notes', backendDOMNodeId: 15, disabled: true }),
+    ref({
+      ref: 'e4',
+      role: 'textbox',
+      name: 'Email',
+      placeholder: 'you@example.com',
+      backendDOMNodeId: 14,
+    }),
+    ref({
+      ref: 'e5',
+      role: 'textbox',
+      name: 'Notes',
+      placeholder: 'Optional notes',
+      backendDOMNodeId: 15,
+      disabled: true,
+    }),
   ];
   return new Map(entries.map((e) => [e.ref, e]));
 }
@@ -84,8 +97,12 @@ describe('findByRole', () => {
 
   it('requires a full name match under exact', async () => {
     const { client } = stubClient();
-    expect((await findByRole(client, 'S1', sampleRefs(), 'button', { name: 'Save', exact: true }))?.ref).toBe('e2');
-    expect(await findByRole(client, 'S1', sampleRefs(), 'button', { name: 'Sav', exact: true })).toBeNull();
+    expect(
+      (await findByRole(client, 'S1', sampleRefs(), 'button', { name: 'Save', exact: true }))?.ref,
+    ).toBe('e2');
+    expect(
+      await findByRole(client, 'S1', sampleRefs(), 'button', { name: 'Sav', exact: true }),
+    ).toBeNull();
   });
 
   it('nth is 1-based over the filtered matches', async () => {
@@ -98,7 +115,9 @@ describe('findByRole', () => {
 
   it('last returns the final match', async () => {
     const { client } = stubClient();
-    expect((await findByRole(client, 'S1', sampleRefs(), 'button', { last: true }))?.ref).toBe('e2');
+    expect((await findByRole(client, 'S1', sampleRefs(), 'button', { last: true }))?.ref).toBe(
+      'e2',
+    );
   });
 
   it('returns null when no ref carries that role', async () => {
@@ -141,7 +160,9 @@ describe('findByText', () => {
   it('findByLabel delegates to the same matching', async () => {
     const { client } = stubClient();
     const refs = sampleRefs();
-    expect(await findByLabel(client, 'S1', refs, 'Email')).toBe(await findByText(client, 'S1', refs, 'Email'));
+    expect(await findByLabel(client, 'S1', refs, 'Email')).toBe(
+      await findByText(client, 'S1', refs, 'Email'),
+    );
   });
 });
 
@@ -154,14 +175,18 @@ describe('findByPlaceholder', () => {
   it('treats a missing placeholder as empty rather than crashing', async () => {
     const { client } = stubClient();
     // e1..e3 have no placeholder; an empty needle must not match them under exact.
-    expect((await findByPlaceholder(client, 'S1', sampleRefs(), '', { exact: true }))?.ref).toBe('e1');
+    expect((await findByPlaceholder(client, 'S1', sampleRefs(), '', { exact: true }))?.ref).toBe(
+      'e1',
+    );
     expect(await findByPlaceholder(client, 'S1', sampleRefs(), 'nope')).toBeNull();
   });
 
   it('honours exact, nth and last', async () => {
     const { client } = stubClient();
     const refs = sampleRefs();
-    expect((await findByPlaceholder(client, 'S1', refs, 'Optional notes', { exact: true }))?.ref).toBe('e5');
+    expect(
+      (await findByPlaceholder(client, 'S1', refs, 'Optional notes', { exact: true }))?.ref,
+    ).toBe('e5');
     expect((await findByPlaceholder(client, 'S1', refs, 'o', { nth: 1 }))?.ref).toBe('e4');
     expect((await findByPlaceholder(client, 'S1', refs, 'o', { last: true }))?.ref).toBe('e5');
   });
@@ -190,7 +215,12 @@ describe('findBySelector', () => {
     });
     const refs = sampleRefs();
     const found = await findBySelector(client, 'S1', refs, 'div.hidden');
-    expect(found).toMatchObject({ ref: 'sel-999', role: 'generic', name: 'div.hidden', nodeId: 55 });
+    expect(found).toMatchObject({
+      ref: 'sel-999',
+      role: 'generic',
+      name: 'div.hidden',
+      nodeId: 55,
+    });
     expect(refs.get('sel-999')).toBe(found);
   });
 
@@ -242,7 +272,9 @@ describe('findBySelector', () => {
       'DOM.getDocument': doc,
       'DOM.querySelector': new Error("SyntaxError: '((' is not a valid selector"),
     });
-    await expect(findBySelector(client, 'S1', sampleRefs(), '((')).rejects.toThrow(/not a valid selector/);
+    await expect(findBySelector(client, 'S1', sampleRefs(), '((')).rejects.toThrow(
+      /not a valid selector/,
+    );
   });
 
   it('swallows transient CDP errors and reports not-found', async () => {
@@ -282,7 +314,9 @@ describe('findByTestId', () => {
   });
 
   it('returns null when no attribute form matches', async () => {
-    const client = { send: vi.fn(async () => ({ result: { value: false } })) } as unknown as CdpClient;
+    const client = {
+      send: vi.fn(async () => ({ result: { value: false } })),
+    } as unknown as CdpClient;
     await expect(findByTestId(client, 'S1', 'nope')).resolves.toBeNull();
   });
 
@@ -330,7 +364,9 @@ describe('element state helpers', () => {
       'DOM.resolveNode': { object: { objectId: 'OBJ1' } },
       'Runtime.callFunctionOn': { result: { value: true } },
     });
-    await expect(isVisible(client, 'S1', ref({ ref: 'e1', backendDOMNodeId: 11 }))).resolves.toBe(true);
+    await expect(isVisible(client, 'S1', ref({ ref: 'e1', backendDOMNodeId: 11 }))).resolves.toBe(
+      true,
+    );
     expect(calls.find((c) => c.method === 'Runtime.callFunctionOn')!.params).toMatchObject({
       objectId: 'OBJ1',
       returnByValue: true,
@@ -342,13 +378,15 @@ describe('element state helpers', () => {
       'DOM.resolveNode': { object: { objectId: 'OBJ1' } },
       'Runtime.callFunctionOn': { result: {} },
     });
-    await expect(isChecked(client, 'S1', ref({ ref: 'e1', backendDOMNodeId: 11 }))).resolves.toBe(false);
+    await expect(isChecked(client, 'S1', ref({ ref: 'e1', backendDOMNodeId: 11 }))).resolves.toBe(
+      false,
+    );
   });
 
   it('scrollIntoView throws a ref-named error when the node is gone', async () => {
     const { client } = stubClient({ 'DOM.resolveNode': { object: {} } });
     await expect(
-      scrollIntoView(client, 'S1', ref({ ref: 'e1', backendDOMNodeId: 11 }))
+      scrollIntoView(client, 'S1', ref({ ref: 'e1', backendDOMNodeId: 11 })),
     ).rejects.toThrow('Cannot scroll: ref @e1 not found in DOM');
   });
 });

package/src/__tests__/frame-command.test.ts

@@ -4,7 +4,7 @@
  * frame, and `frame main` must detach the frame session and restore the
  * page session. The browser engine is mocked; no real Chrome.
  */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import type { Command, CommandContext } from '../cli/types.js';
 
 const mocks = vi.hoisted(() => {
@@ -22,7 +22,12 @@ const mocks = vi.hoisted(() => {
       })),
       loadActivePortInfo: vi.fn(async () => null),
       loadRefCache: vi.fn(async () => null),
-      switchToFrame: vi.fn(async (): Promise<{ url: string | null; sessionId: string | null }> => ({ url: 'https://f.test/frame', sessionId: 'S-FRAME' })),
+      switchToFrame: vi.fn(
+        async (): Promise<{ url: string | null; sessionId: string | null }> => ({
+          url: 'https://f.test/frame',
+          sessionId: 'S-FRAME',
+        }),
+      ),
       enableSessionDomains: vi.fn(async () => {}),
       teardownRouteInterception: vi.fn(),
       stopRequestCapture: vi.fn(),
@@ -52,7 +57,10 @@ beforeEach(() => {
   vi.clearAllMocks();
   mocks.browser.loadActivePortInfo.mockResolvedValue(null);
   mocks.browser.loadRefCache.mockResolvedValue(null);
-  mocks.browser.switchToFrame.mockResolvedValue({ url: 'https://f.test/frame', sessionId: 'S-FRAME' });
+  mocks.browser.switchToFrame.mockResolvedValue({
+    url: 'https://f.test/frame',
+    sessionId: 'S-FRAME',
+  });
   mocks.browser.connectToTarget.mockResolvedValue({
     client: mocks.client,
     sessionId: 'S-PAGE',
@@ -72,9 +80,7 @@ describe('browse frame command (#97)', () => {
 
     // Back to main — must detach the FRAME session (proves _sessionId was updated)
     await frame.action!(ctx(['main']));
-    const detach = mocks.send.mock.calls.find(
-      ([m]) => m === 'Target.detachFromTarget'
-    );
+    const detach = mocks.send.mock.calls.find(([m]) => m === 'Target.detachFromTarget');
     expect(detach).toBeDefined();
     expect(detach![1]).toEqual({ sessionId: 'S-FRAME' });