@monoes/monobrowse 1.0.11 → 1.0.12

package/src/browser/dialog.ts

@@ -9,7 +9,11 @@ export interface DialogInfo {
 const _pendingDialogs = new Map<string, DialogInfo | null>();
 const _dialogListeners = new Map<string, Array<() => void>>();
 
-export function setupDialogAutoHandling(client: CdpClient, sessionId: string, autoAccept = true): void {
+export function setupDialogAutoHandling(
+  client: CdpClient,
+  sessionId: string,
+  autoAccept = true,
+): void {
   if (_pendingDialogs.has(sessionId)) return;
   _pendingDialogs.set(sessionId, null);
 
@@ -27,7 +31,9 @@ export function setupDialogAutoHandling(client: CdpClient, sessionId: string, au
     if (autoAccept) {
       try {
         await client.send('Page.handleJavaScriptDialog', { accept: true }, sessionId);
-      } catch { /* dialog may have already been dismissed */ }
+      } catch {
+        /* dialog may have already been dismissed */
+      }
       _pendingDialogs.set(sessionId, null);
     }
   });
@@ -41,15 +47,26 @@ export function setupDialogAutoHandling(client: CdpClient, sessionId: string, au
 
 export function teardownDialogHandling(sessionId: string): void {
   const offs = _dialogListeners.get(sessionId);
-  if (offs) { for (const off of offs) off(); _dialogListeners.delete(sessionId); }
+  if (offs) {
+    for (const off of offs) off();
+    _dialogListeners.delete(sessionId);
+  }
   _pendingDialogs.delete(sessionId);
 }
 
-export async function acceptDialog(client: CdpClient, sessionId: string, text?: string): Promise<void> {
-  await client.send('Page.handleJavaScriptDialog', {
-    accept: true,
-    promptText: text,
-  }, sessionId);
+export async function acceptDialog(
+  client: CdpClient,
+  sessionId: string,
+  text?: string,
+): Promise<void> {
+  await client.send(
+    'Page.handleJavaScriptDialog',
+    {
+      accept: true,
+      promptText: text,
+    },
+    sessionId,
+  );
   _pendingDialogs.set(sessionId, null);
 }
 

package/src/browser/emulation.ts

@@ -10,39 +10,69 @@ export interface DeviceProfile {
 
 const DEVICES: Record<string, DeviceProfile> = {
   'iPhone 14': {
-    width: 390, height: 844, deviceScaleFactor: 3, mobile: true,
-    userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1',
+    width: 390,
+    height: 844,
+    deviceScaleFactor: 3,
+    mobile: true,
+    userAgent:
+      'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1',
   },
   'iPhone SE': {
-    width: 375, height: 667, deviceScaleFactor: 2, mobile: true,
-    userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1',
+    width: 375,
+    height: 667,
+    deviceScaleFactor: 2,
+    mobile: true,
+    userAgent:
+      'Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1',
   },
-  'iPad': {
-    width: 768, height: 1024, deviceScaleFactor: 2, mobile: true,
-    userAgent: 'Mozilla/5.0 (iPad; CPU OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1',
+  iPad: {
+    width: 768,
+    height: 1024,
+    deviceScaleFactor: 2,
+    mobile: true,
+    userAgent:
+      'Mozilla/5.0 (iPad; CPU OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1',
   },
   'Galaxy S21': {
-    width: 360, height: 800, deviceScaleFactor: 3, mobile: true,
-    userAgent: 'Mozilla/5.0 (Linux; Android 11; SM-G991B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.101 Mobile Safari/537.36',
+    width: 360,
+    height: 800,
+    deviceScaleFactor: 3,
+    mobile: true,
+    userAgent:
+      'Mozilla/5.0 (Linux; Android 11; SM-G991B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.101 Mobile Safari/537.36',
   },
   'Pixel 5': {
-    width: 393, height: 851, deviceScaleFactor: 2.75, mobile: true,
-    userAgent: 'Mozilla/5.0 (Linux; Android 11; Pixel 5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.101 Mobile Safari/537.36',
+    width: 393,
+    height: 851,
+    deviceScaleFactor: 2.75,
+    mobile: true,
+    userAgent:
+      'Mozilla/5.0 (Linux; Android 11; Pixel 5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.101 Mobile Safari/537.36',
   },
 };
 
-export async function emulateDevice(client: CdpClient, sessionId: string, deviceName: string): Promise<void> {
+export async function emulateDevice(
+  client: CdpClient,
+  sessionId: string,
+  deviceName: string,
+): Promise<void> {
   const device = DEVICES[deviceName];
   if (!device) {
-    throw new Error(`Unknown device: "${deviceName}". Available: ${Object.keys(DEVICES).join(', ')}`);
+    throw new Error(
+      `Unknown device: "${deviceName}". Available: ${Object.keys(DEVICES).join(', ')}`,
+    );
   }
 
-  await client.send('Emulation.setDeviceMetricsOverride', {
-    width: device.width,
-    height: device.height,
-    deviceScaleFactor: device.deviceScaleFactor,
-    mobile: device.mobile,
-  }, sessionId);
+  await client.send(
+    'Emulation.setDeviceMetricsOverride',
+    {
+      width: device.width,
+      height: device.height,
+      deviceScaleFactor: device.deviceScaleFactor,
+      mobile: device.mobile,
+    },
+    sessionId,
+  );
 
   await client.send('Emulation.setUserAgentOverride', { userAgent: device.userAgent }, sessionId);
   await client.send('Emulation.setTouchEmulationEnabled', { enabled: device.mobile }, sessionId);
@@ -53,40 +83,60 @@ export async function setGeolocation(
   sessionId: string,
   latitude: number,
   longitude: number,
-  accuracy = 100
+  accuracy = 100,
 ): Promise<void> {
-  await client.send('Emulation.setGeolocationOverride', { latitude, longitude, accuracy }, sessionId);
+  await client.send(
+    'Emulation.setGeolocationOverride',
+    { latitude, longitude, accuracy },
+    sessionId,
+  );
 }
 
-export async function setOfflineMode(client: CdpClient, sessionId: string, offline: boolean): Promise<void> {
-  await client.send('Network.emulateNetworkConditions', {
-    offline,
-    latency: 0,
-    downloadThroughput: -1,
-    uploadThroughput: -1,
-  }, sessionId);
+export async function setOfflineMode(
+  client: CdpClient,
+  sessionId: string,
+  offline: boolean,
+): Promise<void> {
+  await client.send(
+    'Network.emulateNetworkConditions',
+    {
+      offline,
+      latency: 0,
+      downloadThroughput: -1,
+      uploadThroughput: -1,
+    },
+    sessionId,
+  );
 }
 
 export async function setColorScheme(
   client: CdpClient,
   sessionId: string,
-  scheme: 'dark' | 'light' | 'no-preference'
+  scheme: 'dark' | 'light' | 'no-preference',
 ): Promise<void> {
-  await client.send('Emulation.setEmulatedMedia', {
-    features: [{ name: 'prefers-color-scheme', value: scheme }],
-  }, sessionId);
+  await client.send(
+    'Emulation.setEmulatedMedia',
+    {
+      features: [{ name: 'prefers-color-scheme', value: scheme }],
+    },
+    sessionId,
+  );
 }
 
 export async function setBasicAuth(
   client: CdpClient,
   sessionId: string,
   username: string,
-  password: string
+  password: string,
 ): Promise<void> {
   const encoded = Buffer.from(`${username}:${password}`).toString('base64');
-  await client.send('Network.setExtraHTTPHeaders', {
-    headers: { Authorization: `Basic ${encoded}` },
-  }, sessionId);
+  await client.send(
+    'Network.setExtraHTTPHeaders',
+    {
+      headers: { Authorization: `Basic ${encoded}` },
+    },
+    sessionId,
+  );
 }
 
 export function listDevices(): string[] {

package/src/browser/find.ts

@@ -1,9 +1,17 @@
-import type { CdpClient } from './cdp.js';
-import type { ElementRef } from './types.js';
 import { evaluateJs } from './actions.js';
+import type { CdpClient } from './cdp.js';
 import { getObjectIdForRef } from './snapshot.js';
+import type { ElementRef } from './types.js';
 
-export type FindAction = 'click' | 'fill' | 'type' | 'hover' | 'focus' | 'check' | 'uncheck' | 'text';
+export type FindAction =
+  | 'click'
+  | 'fill'
+  | 'type'
+  | 'hover'
+  | 'focus'
+  | 'check'
+  | 'uncheck'
+  | 'text';
 
 export interface FindOptions {
   name?: string;
@@ -18,7 +26,7 @@ export async function findBySelector(
   sessionId: string,
   refs: Map<string, ElementRef>,
   selector: string,
-  options: FindOptions = {}
+  options: FindOptions = {},
 ): Promise<ElementRef | null> {
   if (options.nth !== undefined && options.nth < 1) {
     throw new Error(`nth must be >= 1 (received ${options.nth})`);
@@ -29,14 +37,20 @@ export async function findBySelector(
     let targetNodeId: number;
     if (options.nth !== undefined || options.last) {
       const result = await client.send<{ nodeIds: number[] }>(
-        'DOM.querySelectorAll', { nodeId: doc.root.nodeId, selector }, sessionId
+        'DOM.querySelectorAll',
+        { nodeId: doc.root.nodeId, selector },
+        sessionId,
       );
       const nodeIds = result.nodeIds ?? [];
       if (nodeIds.length === 0) return null;
-      targetNodeId = options.last ? nodeIds[nodeIds.length - 1] : (nodeIds[(options.nth ?? 1) - 1] ?? 0);
+      targetNodeId = options.last
+        ? nodeIds[nodeIds.length - 1]
+        : (nodeIds[(options.nth ?? 1) - 1] ?? 0);
     } else {
       const result = await client.send<{ nodeId: number }>(
-        'DOM.querySelector', { nodeId: doc.root.nodeId, selector }, sessionId
+        'DOM.querySelector',
+        { nodeId: doc.root.nodeId, selector },
+        sessionId,
       );
       targetNodeId = result.nodeId ?? 0;
     }
@@ -44,7 +58,9 @@ export async function findBySelector(
     if (!targetNodeId) return null;
 
     const desc = await client.send<{ node: { backendNodeId: number } }>(
-      'DOM.describeNode', { nodeId: targetNodeId }, sessionId
+      'DOM.describeNode',
+      { nodeId: targetNodeId },
+      sessionId,
     );
     const backendDOMNodeId = desc.node?.backendNodeId;
     if (!backendDOMNodeId) return null;
@@ -54,7 +70,13 @@ export async function findBySelector(
     if (existing) return existing;
 
     // Synthetic ref for elements not represented in the AX tree — insert into refs so it can be used in subsequent commands
-    const syntheticRef: ElementRef = { ref: `sel-${backendDOMNodeId}`, role: 'generic', name: selector, nodeId: targetNodeId, backendDOMNodeId };
+    const syntheticRef: ElementRef = {
+      ref: `sel-${backendDOMNodeId}`,
+      role: 'generic',
+      name: selector,
+      nodeId: targetNodeId,
+      backendDOMNodeId,
+    };
     refs.set(syntheticRef.ref, syntheticRef);
     return syntheticRef;
   } catch (err: unknown) {
@@ -65,11 +87,11 @@ export async function findBySelector(
 }
 
 export async function findByRole(
-  client: CdpClient,
-  sessionId: string,
+  _client: CdpClient,
+  _sessionId: string,
   refs: Map<string, ElementRef>,
   role: string,
-  options: FindOptions = {}
+  options: FindOptions = {},
 ): Promise<ElementRef | null> {
   if (options.nth !== undefined && options.nth < 1) {
     throw new Error(`nth must be >= 1 (received ${options.nth})`);
@@ -92,18 +114,18 @@ export async function findByRole(
 }
 
 export async function findByText(
-  client: CdpClient,
-  sessionId: string,
+  _client: CdpClient,
+  _sessionId: string,
   refs: Map<string, ElementRef>,
   text: string,
-  options: FindOptions = {}
+  options: FindOptions = {},
 ): Promise<ElementRef | null> {
   if (options.nth !== undefined && options.nth < 1) {
     throw new Error(`nth must be >= 1 (received ${options.nth})`);
   }
   const lower = text.toLowerCase();
   const candidates = [...refs.values()].filter((r) =>
-    options.exact ? r.name.toLowerCase() === lower : r.name.toLowerCase().includes(lower)
+    options.exact ? r.name.toLowerCase() === lower : r.name.toLowerCase().includes(lower),
   );
   if (options.nth !== undefined) return candidates[options.nth - 1] ?? null;
   if (options.last) return candidates[candidates.length - 1] ?? null;
@@ -115,17 +137,17 @@ export async function findByLabel(
   sessionId: string,
   refs: Map<string, ElementRef>,
   label: string,
-  options: FindOptions = {}
+  options: FindOptions = {},
 ): Promise<ElementRef | null> {
   return findByText(client, sessionId, refs, label, options);
 }
 
 export async function findByPlaceholder(
-  client: CdpClient,
-  sessionId: string,
+  _client: CdpClient,
+  _sessionId: string,
   refs: Map<string, ElementRef>,
   placeholder: string,
-  options: FindOptions = {}
+  options: FindOptions = {},
 ): Promise<ElementRef | null> {
   if (options.nth !== undefined && options.nth < 1) {
     throw new Error(`nth must be >= 1 (received ${options.nth})`);
@@ -143,7 +165,7 @@ export async function findByPlaceholder(
 export async function findByTestId(
   client: CdpClient,
   sessionId: string,
-  testId: string
+  testId: string,
 ): Promise<string | null> {
   const escapedId = testId.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
   const selectors = [
@@ -152,18 +174,28 @@ export async function findByTestId(
     `[data-test="${escapedId}"]`,
   ];
   for (const sel of selectors) {
-    const result = await evaluateJs(client, sessionId, `!!document.querySelector(${JSON.stringify(sel)})`);
+    const result = await evaluateJs(
+      client,
+      sessionId,
+      `!!document.querySelector(${JSON.stringify(sel)})`,
+    );
     if (result) return sel;
   }
   return null;
 }
 
-export async function isVisible(client: CdpClient, sessionId: string, ref: ElementRef): Promise<boolean> {
+export async function isVisible(
+  client: CdpClient,
+  sessionId: string,
+  ref: ElementRef,
+): Promise<boolean> {
   const objectId = await getObjectIdForRef(client, sessionId, ref);
   if (!objectId) return false;
 
-  const result = await client.send<{ result: { value?: boolean } }>('Runtime.callFunctionOn', {
-    functionDeclaration: `function() {
+  const result = await client.send<{ result: { value?: boolean } }>(
+    'Runtime.callFunctionOn',
+    {
+      functionDeclaration: `function() {
       const rect = this.getBoundingClientRect();
       const style = window.getComputedStyle(this);
       return rect.width > 0 && rect.height > 0 &&
@@ -171,45 +203,74 @@ export async function isVisible(client: CdpClient, sessionId: string, ref: Eleme
              style.visibility !== 'hidden' &&
              style.opacity !== '0';
     }`,
-    objectId,
-    returnByValue: true,
-  }, sessionId);
+      objectId,
+      returnByValue: true,
+    },
+    sessionId,
+  );
   return result.result?.value ?? false;
 }
 
-export async function isEnabled(client: CdpClient, sessionId: string, ref: ElementRef): Promise<boolean> {
+export async function isEnabled(
+  _client: CdpClient,
+  _sessionId: string,
+  ref: ElementRef,
+): Promise<boolean> {
   return !ref.disabled;
 }
 
-export async function isChecked(client: CdpClient, sessionId: string, ref: ElementRef): Promise<boolean> {
+export async function isChecked(
+  client: CdpClient,
+  sessionId: string,
+  ref: ElementRef,
+): Promise<boolean> {
   const objectId = await getObjectIdForRef(client, sessionId, ref);
   if (!objectId) return false;
 
-  const result = await client.send<{ result: { value?: boolean } }>('Runtime.callFunctionOn', {
-    functionDeclaration: 'function() { return !!this.checked; }',
-    objectId,
-    returnByValue: true,
-  }, sessionId);
+  const result = await client.send<{ result: { value?: boolean } }>(
+    'Runtime.callFunctionOn',
+    {
+      functionDeclaration: 'function() { return !!this.checked; }',
+      objectId,
+      returnByValue: true,
+    },
+    sessionId,
+  );
   return result.result?.value ?? false;
 }
 
-export async function scrollIntoView(client: CdpClient, sessionId: string, ref: ElementRef): Promise<void> {
+export async function scrollIntoView(
+  client: CdpClient,
+  sessionId: string,
+  ref: ElementRef,
+): Promise<void> {
   const objectId = await getObjectIdForRef(client, sessionId, ref);
   if (!objectId) throw new Error(`Cannot scroll: ref @${ref.ref} not found in DOM`);
 
-  await client.send('Runtime.callFunctionOn', {
-    functionDeclaration: 'function() { this.scrollIntoView({ behavior: "smooth", block: "center" }); }',
-    objectId,
-    returnByValue: true,
-  }, sessionId);
+  await client.send(
+    'Runtime.callFunctionOn',
+    {
+      functionDeclaration:
+        'function() { this.scrollIntoView({ behavior: "smooth", block: "center" }); }',
+      objectId,
+      returnByValue: true,
+    },
+    sessionId,
+  );
 }
 
-export async function highlightElement(client: CdpClient, sessionId: string, ref: ElementRef): Promise<void> {
+export async function highlightElement(
+  client: CdpClient,
+  sessionId: string,
+  ref: ElementRef,
+): Promise<void> {
   const objectId = await getObjectIdForRef(client, sessionId, ref);
   if (!objectId) return;
 
-  await client.send('Runtime.callFunctionOn', {
-    functionDeclaration: `function() {
+  await client.send(
+    'Runtime.callFunctionOn',
+    {
+      functionDeclaration: `function() {
       const prev = this.style.outline;
       const prevBg = this.style.backgroundColor;
       this.style.outline = '3px solid #ff5722';
@@ -219,7 +280,9 @@ export async function highlightElement(client: CdpClient, sessionId: string, ref
         this.style.backgroundColor = prevBg;
       }, 2000);
     }`,
-    objectId,
-    returnByValue: true,
-  }, sessionId);
+      objectId,
+      returnByValue: true,
+    },
+    sessionId,
+  );
 }

package/src/browser/har.ts

@@ -1,7 +1,7 @@
+import { writeFile } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { isAbsolute, join, relative, resolve } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import { writeFile } from 'fs/promises';
-import { join, resolve, relative, isAbsolute } from 'path';
-import { tmpdir, homedir } from 'os';
 
 interface HarRequest {
   id: string;
@@ -24,14 +24,17 @@ interface HarRequest {
 const MAX_CONCURRENT_SESSIONS = 100;
 const MAX_REQUESTS_PER_SESSION = 5_000;
 
-const _sessions = new Map<string, {
-  requests: Map<string, Partial<HarRequest>>;
-  offReq: () => void;
-  offResp: () => void;
-  offFinished: () => void;
-  startTime: number;
-  startWallMs: number;
-}>();
+const _sessions = new Map<
+  string,
+  {
+    requests: Map<string, Partial<HarRequest>>;
+    offReq: () => void;
+    offResp: () => void;
+    offFinished: () => void;
+    startTime: number;
+    startWallMs: number;
+  }
+>();
 
 /** Validate output path is within cwd or home dir to prevent path traversal. */
 function safeOutputPath(p: string): string {
@@ -40,8 +43,10 @@ function safeOutputPath(p: string): string {
   const home = homedir();
   const relCwd = relative(cwd, resolved);
   const relHome = relative(home, resolved);
-  if ((!relCwd.startsWith('..') && !isAbsolute(relCwd)) ||
-      (!relHome.startsWith('..') && !isAbsolute(relHome))) {
+  if (
+    (!relCwd.startsWith('..') && !isAbsolute(relCwd)) ||
+    (!relHome.startsWith('..') && !isAbsolute(relHome))
+  ) {
     return resolved;
   }
   // Reject out-of-scope paths — fall back to tmpdir
@@ -51,7 +56,9 @@ function safeOutputPath(p: string): string {
 export async function startHarRecording(client: CdpClient, sessionId: string): Promise<void> {
   if (_sessions.has(sessionId)) throw new Error('HAR recording already in progress');
   if (_sessions.size >= MAX_CONCURRENT_SESSIONS) {
-    throw new Error(`HAR recording limit reached (max ${MAX_CONCURRENT_SESSIONS} concurrent sessions)`);
+    throw new Error(
+      `HAR recording limit reached (max ${MAX_CONCURRENT_SESSIONS} concurrent sessions)`,
+    );
   }
 
   const requests = new Map<string, Partial<HarRequest>>();
@@ -68,7 +75,11 @@ export async function startHarRecording(client: CdpClient, sessionId: string): P
     if (sid !== sessionId) return;
     // Cap to prevent unbounded memory growth on high-traffic pages
     if (requests.size >= MAX_REQUESTS_PER_SESSION) return;
-    const p = params as { requestId: string; request: { url: string; method: string; headers: Record<string, string> }; timestamp: number };
+    const p = params as {
+      requestId: string;
+      request: { url: string; method: string; headers: Record<string, string> };
+      timestamp: number;
+    };
     requests.set(p.requestId, {
       id: p.requestId,
       url: p.request.url,
@@ -81,7 +92,19 @@ export async function startHarRecording(client: CdpClient, sessionId: string): P
 
   const offResp = client.on('Network.responseReceived', (params, sid) => {
     if (sid !== sessionId) return;
-    const p = params as { requestId: string; response: { url: string; status: number; statusText: string; mimeType: string; headers: Record<string, string>; fromDiskCache: boolean; fromServiceWorker: boolean }; timestamp: number };
+    const p = params as {
+      requestId: string;
+      response: {
+        url: string;
+        status: number;
+        statusText: string;
+        mimeType: string;
+        headers: Record<string, string>;
+        fromDiskCache: boolean;
+        fromServiceWorker: boolean;
+      };
+      timestamp: number;
+    };
     const entry = requests.get(p.requestId);
     if (entry) {
       entry.status = p.response.status;
@@ -110,7 +133,7 @@ export async function stopHarRecording(
   client: CdpClient,
   sessionId: string,
   outputPath?: string,
-  captureResponseBodies = false
+  captureResponseBodies = false,
 ): Promise<string> {
   const state = _sessions.get(sessionId);
   if (!state) throw new Error('No active HAR recording for this session');
@@ -125,7 +148,9 @@ export async function stopHarRecording(
     for (const [reqId, entry] of state.requests.entries()) {
       try {
         const body = await client.send<{ body: string; base64Encoded: boolean }>(
-          'Network.getResponseBody', { requestId: reqId }, sessionId
+          'Network.getResponseBody',
+          { requestId: reqId },
+          sessionId,
         );
         entry.responseBody = body.body;
         entry.bodyEncoding = body.base64Encoded ? 'base64' : undefined;
@@ -139,7 +164,9 @@ export async function stopHarRecording(
   }
 
   const har = buildHar(Array.from(state.requests.values()), state.startTime);
-  const safePath = outputPath ? safeOutputPath(outputPath) : join(tmpdir(), `monomind-har-${Date.now()}.har`);
+  const safePath = outputPath
+    ? safeOutputPath(outputPath)
+    : join(tmpdir(), `monomind-har-${Date.now()}.har`);
   await writeFile(safePath, JSON.stringify(har, null, 2));
   return safePath;
 }
@@ -159,12 +186,14 @@ function buildHar(entries: Partial<HarRequest>[], startTime: number) {
     log: {
       version: '1.2',
       creator: { name: 'monomind browse', version: '1.0.0' },
-      pages: [{
-        startedDateTime: new Date(startTime).toISOString(),
-        id: 'page_1',
-        title: '',
-        pageTimings: {},
-      }],
+      pages: [
+        {
+          startedDateTime: new Date(startTime).toISOString(),
+          id: 'page_1',
+          title: '',
+          pageTimings: {},
+        },
+      ],
       entries: entries.map((e) => ({
         startedDateTime: new Date(e.startTime ?? startTime).toISOString(),
         time: (e.endTime ?? e.startTime ?? startTime) - (e.startTime ?? startTime),
@@ -183,7 +212,10 @@ function buildHar(entries: Partial<HarRequest>[], startTime: number) {
           statusText: e.statusText ?? '',
           httpVersion: 'HTTP/1.1',
           cookies: [],
-          headers: Object.entries(e.responseHeaders ?? {}).map(([name, value]) => ({ name, value })),
+          headers: Object.entries(e.responseHeaders ?? {}).map(([name, value]) => ({
+            name,
+            value,
+          })),
           content: {
             size: e.size ?? -1,
             mimeType: e.mimeType ?? 'application/octet-stream',