@monoes/monobrowse 1.0.9 → 1.0.12

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' });
 

package/src/__tests__/open-url-navigate-error.test.ts

@@ -7,8 +7,8 @@
  * this checks that response before doing anything else.
  */
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { CdpClient } from '../browser/cdp.js';
 import { openUrl } from '../browser/browser.js';
+import type { CdpClient } from '../browser/cdp.js';
 
 afterEach(() => {
   vi.restoreAllMocks();
@@ -43,9 +43,7 @@ describe('openUrl navigation-failure detection', () => {
     await expect(openUrl(client, 'sess-1', 'http://127.0.0.1:1/')).rejects.toThrow(
       /net::ERR_CONNECTION_REFUSED/,
     );
-    expect(calls).toEqual([
-      { method: 'Page.navigate', params: { url: 'http://127.0.0.1:1/' } },
-    ]);
+    expect(calls).toEqual([{ method: 'Page.navigate', params: { url: 'http://127.0.0.1:1/' } }]);
   });
 
   it('rejects the 2 MB URL guard before ever calling Page.navigate', async () => {

package/src/__tests__/output.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 // The module exports a singleton `output` which reads process.stdout.isTTY at
 // construction time. We need to control that, so we reset modules per test.

package/src/__tests__/reap-idle-browser.test.ts

@@ -0,0 +1,276 @@
+/**
+ * #310: a launched Chrome outlives its session, holding its CDP port (9222 by
+ * convention, which other local tools want) with zero targets left to
+ * reattach to. reapIdleLaunchedBrowser() gives that port back.
+ *
+ * No real Chrome is spawned: the CDP HTTP endpoints (/json/version, /json/list)
+ * are served by a local http server that answers exactly like Chrome does
+ * (same approach as browser-launch.test.ts), the browser-level websocket is a
+ * fake `ws` socket (same approach as close-browser.test.ts), and process.kill
+ * is spied on rather than actually signaling anything.
+ *
+ * Fixed port range (23490-23499) chosen to avoid colliding with real services.
+ */
+
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { createServer as createHttpServer, type Server as HttpServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { CdpTarget } from '../browser/types.js';
+
+const BASE = 23490;
+const MINUTE = 60_000;
+
+let lastSocket: FakeWs | null = null;
+
+/** Minimal `ws` stand-in: opens on its own and acknowledges every command,
+ *  so `Browser.close` takes the graceful path without a real browser. */
+class FakeWs {
+  handlers = new Map<string, Array<(...a: unknown[]) => void>>();
+  sent: string[] = [];
+  constructor(public url: string) {
+    lastSocket = this;
+    queueMicrotask(() => this.emit('open'));
+  }
+  on(event: string, fn: (...a: unknown[]) => void): void {
+    if (!this.handlers.has(event)) this.handlers.set(event, []);
+    this.handlers.get(event)!.push(fn);
+  }
+  emit(event: string, ...args: unknown[]): void {
+    for (const fn of [...(this.handlers.get(event) ?? [])]) fn(...args);
+  }
+  send(data: string, cb?: (err?: Error) => void): void {
+    void cb;
+    this.sent.push(data);
+    const { id } = JSON.parse(data) as { id: number };
+    queueMicrotask(() => this.emit('message', Buffer.from(JSON.stringify({ id, result: {} }))));
+  }
+  close(): void {}
+  /** Methods this socket was asked to run, e.g. ['Browser.close']. */
+  methods(): string[] {
+    return this.sent.map((s) => (JSON.parse(s) as { method: string }).method);
+  }
+}
+
+vi.mock('ws', () => ({ WebSocket: FakeWs }));
+
+let tempDir: string;
+let servers: HttpServer[] = [];
+let killSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(async () => {
+  lastSocket = null;
+  tempDir = await mkdtemp(join(tmpdir(), 'monobrowse-reap-test-'));
+  // ref-cache.ts resolves its cache dir from process.cwd() at module load, so
+  // this must be in place before the dynamic import in each test.
+  vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+  // The browser is "already gone" by the time closeBrowser polls for its exit
+  // (ESRCH on the liveness probe) — the realistic outcome of Browser.close.
+  killSpy = vi.spyOn(process, 'kill').mockImplementation((_pid: unknown, signal?: unknown) => {
+    if (signal === 0) throw Object.assign(new Error('ESRCH'), { code: 'ESRCH' });
+    return true as never;
+  });
+});
+
+afterEach(async () => {
+  await Promise.all(servers.map((s) => new Promise<void>((resolve) => s.close(() => resolve()))));
+  servers = [];
+  vi.restoreAllMocks();
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+/** An http server answering /json/version and /json/list exactly like Chrome. */
+function fakeChrome(port: number, targets: Partial<CdpTarget>[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const s = createHttpServer((req, res) => {
+      if (req.url === '/json/version') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(
+          JSON.stringify({
+            Browser: 'Chrome/999.0.0.0',
+            webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser/fake-browser-id`,
+          }),
+        );
+      } else if (req.url === '/json/list') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(targets));
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    s.once('error', reject);
+    s.listen(port, '127.0.0.1', () => {
+      servers.push(s);
+      resolve();
+    });
+  });
+}
+
+const PORT_FILE = () => join(tempDir, '.monomind', 'monobrowse', 'active-port.json');
+
+async function writePersistedPort(record: {
+  port: number;
+  pid?: number;
+  launched: boolean;
+  savedAt: number;
+}): Promise<void> {
+  await mkdir(join(tempDir, '.monomind', 'monobrowse'), { recursive: true });
+  await writeFile(PORT_FILE(), JSON.stringify(record), 'utf-8');
+}
+
+async function portFileExists(): Promise<boolean> {
+  return readFile(PORT_FILE(), 'utf-8').then(
+    () => true,
+    () => false,
+  );
+}
+
+async function loadBrowser() {
+  vi.resetModules();
+  return import('../browser/browser.js');
+}
+
+/** A page target as Chrome reports it when NO debugger is attached to it. */
+function idlePageTarget(id: string, port: number): Partial<CdpTarget> {
+  return {
+    id,
+    type: 'page',
+    title: 'Example',
+    url: 'https://example.com/',
+    webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/page/${id}`,
+  };
+}
+
+describe('#310 reapIdleLaunchedBrowser — give back a CDP port nothing is using', () => {
+  it('reaps a launched instance that has had zero targets past the idle threshold', async () => {
+    const port = BASE + 0;
+    await fakeChrome(port, []);
+    await writePersistedPort({
+      port,
+      pid: 54321,
+      launched: true,
+      savedAt: Date.now() - 45 * MINUTE,
+    });
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBe(port);
+
+    expect(lastSocket?.url).toBe(`ws://127.0.0.1:${port}/devtools/browser/fake-browser-id`);
+    expect(lastSocket?.methods()).toContain('Browser.close');
+    // The port file is the session handle — a reaped session must not leave
+    // one behind for the next command to chase.
+    expect(await portFileExists()).toBe(false);
+  });
+
+  it('does NOT reap a launched instance that still has open page targets', async () => {
+    const port = BASE + 1;
+    await fakeChrome(port, [idlePageTarget('AAA', port)]);
+    await writePersistedPort({
+      port,
+      pid: 54322,
+      launched: true,
+      savedAt: Date.now() - 45 * MINUTE,
+    });
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+
+    expect(lastSocket).toBeNull();
+    expect(killSpy).not.toHaveBeenCalled();
+    expect(await portFileExists()).toBe(true);
+  });
+
+  it('does NOT reap a browser this tool never launched, however idle or old it is', async () => {
+    // `connect` records launched:false — that browser belongs to the user.
+    const port = BASE + 2;
+    await fakeChrome(port, []);
+    await writePersistedPort({
+      port,
+      pid: 54323,
+      launched: false,
+      savedAt: Date.now() - 48 * 60 * MINUTE,
+    });
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+
+    expect(lastSocket).toBeNull();
+    expect(killSpy).not.toHaveBeenCalled();
+    expect(await portFileExists()).toBe(true);
+  });
+
+  it('does NOT reap while a client is still attached to a target', async () => {
+    // Chrome omits webSocketDebuggerUrl from a target that already has a
+    // debugger attached — an in-flight session, not an abandoned browser.
+    const port = BASE + 3;
+    await fakeChrome(port, [
+      { id: 'BBB', type: 'page', title: 'Example', url: 'https://example.com/' },
+    ]);
+    await writePersistedPort({
+      port,
+      pid: 54324,
+      launched: true,
+      savedAt: Date.now() - 45 * MINUTE,
+    });
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+
+    expect(lastSocket).toBeNull();
+    expect(await portFileExists()).toBe(true);
+  });
+
+  it('does NOT reap an instance that is still inside the idle threshold', async () => {
+    // A live session can momentarily have no targets (last tab closed, next
+    // command about to open one) — reaping that would break reattach.
+    const port = BASE + 4;
+    await fakeChrome(port, []);
+    await writePersistedPort({ port, pid: 54325, launched: true, savedAt: Date.now() - MINUTE });
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+
+    expect(lastSocket).toBeNull();
+    expect(await portFileExists()).toBe(true);
+  });
+
+  it('does NOT reap when the persisted record has no savedAt (age unknowable)', async () => {
+    const port = BASE + 5;
+    await fakeChrome(port, []);
+    await mkdir(join(tempDir, '.monomind', 'monobrowse'), { recursive: true });
+    await writeFile(PORT_FILE(), JSON.stringify({ port, pid: 54326, launched: true }), 'utf-8');
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+    expect(lastSocket).toBeNull();
+  });
+
+  it('is a no-op with no persisted session at all', async () => {
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+    expect(killSpy).not.toHaveBeenCalled();
+  });
+
+  it('launchBrowser reaps the stale instance before deciding what to do with the port', async () => {
+    // The wiring that makes the reaper run at all: every launch/attach is a
+    // chance to give back a port a previous session abandoned.
+    const port = BASE + 6;
+    await fakeChrome(port, []);
+    await writePersistedPort({
+      port,
+      pid: 54327,
+      launched: true,
+      savedAt: Date.now() - 45 * MINUTE,
+    });
+
+    const { launchBrowser } = await loadBrowser();
+    // The fake Chrome stays listening, so launchBrowser attaches to it after
+    // the reap rather than spawning a real browser.
+    await expect(launchBrowser({ port })).resolves.toBe(port);
+
+    expect(lastSocket?.methods()).toContain('Browser.close');
+    expect(await portFileExists()).toBe(false);
+  });
+});

package/src/__tests__/ref-cache.test.ts

@@ -1,7 +1,7 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdtemp, readFile, rm, stat } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
+import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 // We need to mock process.cwd() before importing ref-cache so CACHE_DIR
 // resolves to our temp directory.
@@ -26,7 +26,9 @@ async function importRefCache() {
   return import('../browser/ref-cache.js');
 }
 
-function makeRefs(count = 2): Map<string, { ref: string; role: string; name: string; nodeId: number }> {
+function makeRefs(
+  count = 2,
+): Map<string, { ref: string; role: string; name: string; nodeId: number }> {
   const map = new Map();
   for (let i = 1; i <= count; i++) {
     map.set(`ref${i}`, { ref: `ref${i}`, role: 'button', name: `Button ${i}`, nodeId: i });
@@ -68,7 +70,7 @@ describe('ref-cache', () => {
 
     // Now overwrite the file with invalid JSON
     const cacheFile = join(tempDir, '.monomind', 'monobrowse', 'ax-snapshot.json');
-    const { writeFile: wf } = await import('fs/promises');
+    const { writeFile: wf } = await import('node:fs/promises');
     await wf(cacheFile, '{{{not valid json!!!');
 
     const loaded = await mod.loadRefCache('t');
@@ -117,7 +119,7 @@ describe('ref-cache', () => {
     const cacheFile = join(tempDir, '.monomind', 'monobrowse', 'ax-snapshot.json');
     const raw = JSON.parse(await readFile(cacheFile, 'utf8'));
     raw.savedAt = Date.now() - mod.REF_CACHE_STALE_MS - 5000;
-    const { writeFile: wf } = await import('fs/promises');
+    const { writeFile: wf } = await import('node:fs/promises');
     await wf(cacheFile, JSON.stringify(raw));
 
     const loaded = await mod.loadRefCache('t1');
@@ -138,13 +140,21 @@ describe('active-port persistence', () => {
     const mod = await importRefCache();
     await mod.saveActivePort(9333);
     expect(await mod.loadActivePort()).toBe(9333);
-    expect(await mod.loadActivePortInfo()).toEqual({ port: 9333, launched: true, savedAt: expect.any(Number) });
+    expect(await mod.loadActivePortInfo()).toEqual({
+      port: 9333,
+      launched: true,
+      savedAt: expect.any(Number),
+    });
   });
 
   it('connect provenance: launched:false survives the round-trip', async () => {
     const mod = await importRefCache();
     await mod.saveActivePort(9229, { launched: false });
-    expect(await mod.loadActivePortInfo()).toEqual({ port: 9229, launched: false, savedAt: expect.any(Number) });
+    expect(await mod.loadActivePortInfo()).toEqual({
+      port: 9229,
+      launched: false,
+      savedAt: expect.any(Number),
+    });
   });
 
   it('clear removes the file; load returns null afterwards', async () => {
@@ -196,11 +206,14 @@ describe('active-port persistence', () => {
 
   it('#115: a non-numeric or non-positive persisted pid is dropped, not trusted', async () => {
     const mod = await importRefCache();
-    const { writeFile, mkdir } = await import('fs/promises');
+    const { writeFile, mkdir } = await import('node:fs/promises');
     const dir = join(process.cwd(), '.monomind', 'monobrowse');
     await mkdir(dir, { recursive: true });
     for (const badPid of ['54321', -1, 0, 1.5, null]) {
-      await writeFile(join(dir, 'active-port.json'), JSON.stringify({ port: 9333, launched: true, pid: badPid }));
+      await writeFile(
+        join(dir, 'active-port.json'),
+        JSON.stringify({ port: 9333, launched: true, pid: badPid }),
+      );
       const info = await mod.loadActivePortInfo();
       expect(info!.pid).toBeUndefined();
     }
@@ -208,7 +221,7 @@ describe('active-port persistence', () => {
 
   it('rejects out-of-range or non-integer persisted ports', async () => {
     const mod = await importRefCache();
-    const { writeFile, mkdir } = await import('fs/promises');
+    const { writeFile, mkdir } = await import('node:fs/promises');
     const dir = join(process.cwd(), '.monomind', 'monobrowse');
     await mkdir(dir, { recursive: true });
     for (const bad of [80, 70000, 1.5, '9222', null]) {