@monoes/monobrowse 1.0.9 → 1.0.12

package/src/browser/index.ts

@@ -1,23 +1,23 @@
-export * from './types.js';
-export * from './cdp.js';
-export * from './browser.js';
-export * from './snapshot.js';
 export * from './actions.js';
-export * from './wait.js';
-export * from './network.js';
-export * from './screenshot.js';
-export * from './session.js';
-export * from './tabs.js';
-export * from './dialog.js';
+export * from './batch.js';
+export * from './browser.js';
+export * from './cdp.js';
 export * from './console-log.js';
-export * from './storage.js';
+export * from './dialog.js';
+export * from './emulation.js';
 export * from './find.js';
+export * from './har.js';
+export * from './network.js';
 export * from './pdf.js';
-export * from './emulation.js';
-export * from './batch.js';
+export * from './profiler.js';
 export * from './record.js';
+export * from './ref-cache.js';
+export * from './screenshot.js';
+export * from './session.js';
+export * from './snapshot.js';
+export * from './storage.js';
+export * from './tabs.js';
 export * from './trace.js';
-export * from './profiler.js';
+export * from './types.js';
 export * from './vitals.js';
-export * from './har.js';
-export * from './ref-cache.js';
+export * from './wait.js';

package/src/browser/network.ts

@@ -2,7 +2,11 @@ import type { CdpClient } from './cdp.js';
 import type { CdpCookie, NetworkRoute } from './types.js';
 
 export async function getCookies(client: CdpClient, sessionId: string): Promise<CdpCookie[]> {
-  const result = await client.send<{ cookies: CdpCookie[] }>('Network.getAllCookies', {}, sessionId);
+  const result = await client.send<{ cookies: CdpCookie[] }>(
+    'Network.getAllCookies',
+    {},
+    sessionId,
+  );
   return result.cookies ?? [];
 }
 
@@ -12,12 +16,24 @@ export async function getCookies(client: CdpClient, sessionId: string): Promise<
  * profile. Used for session save/export so we don't leak session tokens for
  * unrelated domains the user happens to be logged into.
  */
-export async function getCookiesForUrls(client: CdpClient, sessionId: string, urls: string[]): Promise<CdpCookie[]> {
-  const result = await client.send<{ cookies: CdpCookie[] }>('Network.getCookies', { urls }, sessionId);
+export async function getCookiesForUrls(
+  client: CdpClient,
+  sessionId: string,
+  urls: string[],
+): Promise<CdpCookie[]> {
+  const result = await client.send<{ cookies: CdpCookie[] }>(
+    'Network.getCookies',
+    { urls },
+    sessionId,
+  );
   return result.cookies ?? [];
 }
 
-export async function setCookies(client: CdpClient, sessionId: string, cookies: CdpCookie[]): Promise<void> {
+export async function setCookies(
+  client: CdpClient,
+  sessionId: string,
+  cookies: CdpCookie[],
+): Promise<void> {
   await client.send('Network.setCookies', { cookies }, sessionId);
 }
 
@@ -28,15 +44,19 @@ export async function clearCookies(client: CdpClient, sessionId: string): Promis
 export async function setExtraHeaders(
   client: CdpClient,
   sessionId: string,
-  headers: Record<string, string>
+  headers: Record<string, string>,
 ): Promise<void> {
   await client.send('Network.setExtraHTTPHeaders', { headers }, sessionId);
 }
 
 export async function enableInterception(client: CdpClient, sessionId: string): Promise<void> {
-  await client.send('Fetch.enable', {
-    patterns: [{ requestStage: 'Request' }],
-  }, sessionId);
+  await client.send(
+    'Fetch.enable',
+    {
+      patterns: [{ requestStage: 'Request' }],
+    },
+    sessionId,
+  );
 }
 
 const _routeListeners = new Map<string, () => void>();
@@ -44,11 +64,14 @@ const _routeListeners = new Map<string, () => void>();
 export async function setupRoutes(
   client: CdpClient,
   sessionId: string,
-  routes: NetworkRoute[]
+  routes: NetworkRoute[],
 ): Promise<void> {
   // Remove previous route listener for this session before registering a new one
   const prevOff = _routeListeners.get(sessionId);
-  if (prevOff) { prevOff(); _routeListeners.delete(sessionId); }
+  if (prevOff) {
+    prevOff();
+    _routeListeners.delete(sessionId);
+  }
 
   if (routes.length === 0) {
     await client.send('Fetch.disable', {}, sessionId).catch(() => {});
@@ -77,14 +100,21 @@ export async function setupRoutes(
           await client.send('Fetch.failRequest', { requestId, errorReason: 'Failed' }, sessionId);
           break;
         case 'fulfill':
-          await client.send('Fetch.fulfillRequest', {
-            requestId,
-            responseCode: matchedRoute.response?.status ?? 200,
-            responseHeaders: Object.entries(matchedRoute.response?.headers ?? {}).map(([name, value]) => ({ name, value })),
-            body: matchedRoute.response?.body ? Buffer.from(matchedRoute.response.body).toString('base64') : '',
-          }, sessionId);
+          await client.send(
+            'Fetch.fulfillRequest',
+            {
+              requestId,
+              responseCode: matchedRoute.response?.status ?? 200,
+              responseHeaders: Object.entries(matchedRoute.response?.headers ?? {}).map(
+                ([name, value]) => ({ name, value }),
+              ),
+              body: matchedRoute.response?.body
+                ? Buffer.from(matchedRoute.response.body).toString('base64')
+                : '',
+            },
+            sessionId,
+          );
           break;
-        case 'continue':
         default:
           await client.send('Fetch.continueRequest', { requestId }, sessionId);
           break;
@@ -96,15 +126,29 @@ export async function setupRoutes(
   });
   _routeListeners.set(sessionId, off);
 
-  await client.send('Fetch.enable', {
-    patterns: routes.map((r) => ({ urlPattern: globToFetchPattern(r.pattern), requestStage: 'Request' })),
-  }, sessionId);
+  await client.send(
+    'Fetch.enable',
+    {
+      patterns: routes.map((r) => ({
+        urlPattern: globToFetchPattern(r.pattern),
+        requestStage: 'Request',
+      })),
+    },
+    sessionId,
+  );
 }
 
 type CapturedRequest = {
-  id: string; url: string; method: string; status?: number; mimeType?: string;
-  requestHeaders?: Record<string, string>; responseHeaders?: Record<string, string>;
-  startTime: number; endTime?: number; encodedSize?: number;
+  id: string;
+  url: string;
+  method: string;
+  status?: number;
+  mimeType?: string;
+  requestHeaders?: Record<string, string>;
+  responseHeaders?: Record<string, string>;
+  startTime: number;
+  endTime?: number;
+  encodedSize?: number;
 };
 
 const _capturedRequests = new Map<string, Map<string, CapturedRequest>>();
@@ -121,29 +165,53 @@ export function startRequestCapture(client: CdpClient, sessionId: string): void
 
   const offReq = client.on('Network.requestWillBeSent', (params, sid) => {
     if (sid !== sessionId) return;
-    const p = params as { requestId: string; request: { url: string; method: string; headers: Record<string, string> }; timestamp: number };
-    idx().set(p.requestId, { id: p.requestId, url: p.request.url, method: p.request.method, requestHeaders: p.request.headers, startTime: p.timestamp * 1000 });
+    const p = params as {
+      requestId: string;
+      request: { url: string; method: string; headers: Record<string, string> };
+      timestamp: number;
+    };
+    idx().set(p.requestId, {
+      id: p.requestId,
+      url: p.request.url,
+      method: p.request.method,
+      requestHeaders: p.request.headers,
+      startTime: p.timestamp * 1000,
+    });
   });
 
   const offResp = client.on('Network.responseReceived', (params, sid) => {
     if (sid !== sessionId) return;
-    const p = params as { requestId: string; response: { status: number; mimeType: string; headers: Record<string, string> }; timestamp: number };
+    const p = params as {
+      requestId: string;
+      response: { status: number; mimeType: string; headers: Record<string, string> };
+      timestamp: number;
+    };
     const entry = idx().get(p.requestId);
-    if (entry) { entry.status = p.response.status; entry.mimeType = p.response.mimeType; entry.responseHeaders = p.response.headers; entry.endTime = p.timestamp * 1000; }
+    if (entry) {
+      entry.status = p.response.status;
+      entry.mimeType = p.response.mimeType;
+      entry.responseHeaders = p.response.headers;
+      entry.endTime = p.timestamp * 1000;
+    }
   });
 
   const offFinished = client.on('Network.loadingFinished', (params, sid) => {
     if (sid !== sessionId) return;
     const p = params as { requestId: string; encodedDataLength: number; timestamp: number };
     const entry = idx().get(p.requestId);
-    if (entry) { entry.encodedSize = p.encodedDataLength; entry.endTime = p.timestamp * 1000; }
+    if (entry) {
+      entry.encodedSize = p.encodedDataLength;
+      entry.endTime = p.timestamp * 1000;
+    }
   });
 
   const offFailed = client.on('Network.loadingFailed', (params, sid) => {
     if (sid !== sessionId) return;
     const p = params as { requestId: string; timestamp: number };
     const entry = idx().get(p.requestId);
-    if (entry) { entry.endTime = p.timestamp * 1000; }
+    if (entry) {
+      entry.endTime = p.timestamp * 1000;
+    }
   });
 
   _captureListeners.set(sessionId, [offReq, offResp, offFinished, offFailed]);
@@ -151,7 +219,10 @@ export function startRequestCapture(client: CdpClient, sessionId: string): void
 
 export function stopRequestCapture(sessionId: string): void {
   const offs = _captureListeners.get(sessionId);
-  if (offs) { for (const off of offs) off(); _captureListeners.delete(sessionId); }
+  if (offs) {
+    for (const off of offs) off();
+    _captureListeners.delete(sessionId);
+  }
   _capturedRequests.delete(sessionId);
 }
 
@@ -165,20 +236,36 @@ export function clearCapturedRequests(sessionId: string): void {
 
 export async function disableInterception(client: CdpClient, sessionId: string): Promise<void> {
   const prevOff = _routeListeners.get(sessionId);
-  if (prevOff) { prevOff(); _routeListeners.delete(sessionId); }
+  if (prevOff) {
+    prevOff();
+    _routeListeners.delete(sessionId);
+  }
   await client.send('Fetch.disable', {}, sessionId);
 }
 
 export function teardownRouteInterception(sessionId: string): void {
   const prevOff = _routeListeners.get(sessionId);
-  if (prevOff) { prevOff(); _routeListeners.delete(sessionId); }
+  if (prevOff) {
+    prevOff();
+    _routeListeners.delete(sessionId);
+  }
 }
 
-export async function getLocalStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>> {
-  const result = await client.send<{ result: { value?: string }; exceptionDetails?: { text: string; exception?: { description?: string } } }>('Runtime.evaluate', {
-    expression: 'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))',
-    returnByValue: true,
-  }, sessionId);
+export async function getLocalStorage(
+  client: CdpClient,
+  sessionId: string,
+): Promise<Record<string, string>> {
+  const result = await client.send<{
+    result: { value?: string };
+    exceptionDetails?: { text: string; exception?: { description?: string } };
+  }>(
+    'Runtime.evaluate',
+    {
+      expression: 'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))',
+      returnByValue: true,
+    },
+    sessionId,
+  );
   if (result.exceptionDetails) return {};
   try {
     return JSON.parse(result.result?.value ?? '{}');
@@ -190,7 +277,7 @@ export async function getLocalStorage(client: CdpClient, sessionId: string): Pro
 export async function setLocalStorage(
   client: CdpClient,
   sessionId: string,
-  data: Record<string, string>
+  data: Record<string, string>,
 ): Promise<void> {
   const script = Object.entries(data)
     .map(([k, v]) => `localStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`)
@@ -201,16 +288,28 @@ export async function setLocalStorage(
       exceptionDetails?: { text: string; exception?: { description?: string } };
     }>('Runtime.evaluate', { expression: script, returnByValue: true }, sessionId);
     if (result.exceptionDetails) {
-      throw new Error(`setLocalStorage failed: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`);
+      throw new Error(
+        `setLocalStorage failed: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`,
+      );
     }
   }
 }
 
-export async function getSessionStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>> {
-  const result = await client.send<{ result: { value?: string }; exceptionDetails?: { text: string; exception?: { description?: string } } }>('Runtime.evaluate', {
-    expression: 'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))',
-    returnByValue: true,
-  }, sessionId);
+export async function getSessionStorage(
+  client: CdpClient,
+  sessionId: string,
+): Promise<Record<string, string>> {
+  const result = await client.send<{
+    result: { value?: string };
+    exceptionDetails?: { text: string; exception?: { description?: string } };
+  }>(
+    'Runtime.evaluate',
+    {
+      expression: 'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))',
+      returnByValue: true,
+    },
+    sessionId,
+  );
   if (result.exceptionDetails) return {};
   try {
     return JSON.parse(result.result?.value ?? '{}');
@@ -222,7 +321,7 @@ export async function getSessionStorage(client: CdpClient, sessionId: string): P
 export async function setSessionStorage(
   client: CdpClient,
   sessionId: string,
-  data: Record<string, string>
+  data: Record<string, string>,
 ): Promise<void> {
   const script = Object.entries(data)
     .map(([k, v]) => `sessionStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`)
@@ -233,7 +332,9 @@ export async function setSessionStorage(
       exceptionDetails?: { text: string; exception?: { description?: string } };
     }>('Runtime.evaluate', { expression: script, returnByValue: true }, sessionId);
     if (result.exceptionDetails) {
-      throw new Error(`setSessionStorage failed: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`);
+      throw new Error(
+        `setSessionStorage failed: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`,
+      );
     }
   }
 }

package/src/browser/pdf.ts

@@ -1,7 +1,7 @@
+import { writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
 
 export interface PdfOptions {
   path?: string;
@@ -19,7 +19,7 @@ export interface PdfOptions {
 export async function capturePdf(
   client: CdpClient,
   sessionId: string,
-  options: PdfOptions = {}
+  options: PdfOptions = {},
 ): Promise<string> {
   const params: Record<string, unknown> = {
     landscape: options.landscape ?? false,

package/src/browser/profiler.ts

@@ -1,7 +1,7 @@
+import { writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
 
 export interface ProfilerOptions {
   path?: string;
@@ -14,14 +14,18 @@ const _heapSessions = new Set<string>();
 export async function startCpuProfile(
   client: CdpClient,
   sessionId: string,
-  options: ProfilerOptions = {}
+  options: ProfilerOptions = {},
 ): Promise<void> {
   if (_sessions.has(sessionId)) {
     throw new Error('CPU profiler already running for this session');
   }
   await client.send('Profiler.enable', {}, sessionId);
   if (options.samplingInterval !== undefined) {
-    await client.send('Profiler.setSamplingInterval', { interval: options.samplingInterval }, sessionId);
+    await client.send(
+      'Profiler.setSamplingInterval',
+      { interval: options.samplingInterval },
+      sessionId,
+    );
   }
   await client.send('Profiler.start', {}, sessionId);
   _sessions.add(sessionId);
@@ -30,7 +34,7 @@ export async function startCpuProfile(
 export async function stopCpuProfile(
   client: CdpClient,
   sessionId: string,
-  outputPath?: string
+  outputPath?: string,
 ): Promise<string> {
   if (!_sessions.has(sessionId)) {
     throw new Error('No active CPU profiler for this session');
@@ -57,7 +61,7 @@ export function isProfilingActive(sessionId: string): boolean {
 export async function startHeapSnapshot(
   client: CdpClient,
   sessionId: string,
-  outputPath?: string
+  outputPath?: string,
 ): Promise<string> {
   if (_heapSessions.has(sessionId)) {
     throw new Error('Heap snapshot already in progress for this session');
@@ -79,10 +83,19 @@ export async function startHeapSnapshot(
       }, 120_000);
       const off2 = client.on('HeapProfiler.reportHeapSnapshotProgress', (params, sid) => {
         if (sid !== sessionId) return;
-        if (params.finished) { clearTimeout(timeoutHandle); off2(); resolve(); }
+        if (params.finished) {
+          clearTimeout(timeoutHandle);
+          off2();
+          resolve();
+        }
       });
-      client.send('HeapProfiler.takeHeapSnapshot', { reportProgress: true }, sessionId)
-        .catch((err) => { clearTimeout(timeoutHandle); off2(); reject(err); });
+      client
+        .send('HeapProfiler.takeHeapSnapshot', { reportProgress: true }, sessionId)
+        .catch((err) => {
+          clearTimeout(timeoutHandle);
+          off2();
+          reject(err);
+        });
     });
   } finally {
     off();

package/src/browser/record.ts

@@ -1,7 +1,7 @@
+import { writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
 
 export interface RecordOptions {
   path?: string;
@@ -34,7 +34,7 @@ const _sessions = new Map<string, RecordingState>();
 export async function startRecording(
   client: CdpClient,
   sessionId: string,
-  options: RecordOptions = {}
+  options: RecordOptions = {},
 ): Promise<void> {
   const existing = _sessions.get(sessionId);
   if (existing && !existing.autoStopped) {
@@ -48,7 +48,12 @@ export async function startRecording(
     _sessions.delete(sessionId);
   }
 
-  const state: RecordingState = { frames: [], offScreencast: null, totalBytes: 0, autoStopped: false };
+  const state: RecordingState = {
+    frames: [],
+    offScreencast: null,
+    totalBytes: 0,
+    autoStopped: false,
+  };
   _sessions.set(sessionId, state);
 
   state.offScreencast = client.on('Page.screencastFrame', async (params, sid) => {
@@ -63,22 +68,28 @@ export async function startRecording(
         // eslint-disable-next-line no-console
         console.error(
           `[monobrowse] Screen recording auto-stopped: reached ${Math.round(MAX_SCREENCAST_BYTES / (1024 * 1024))}MB ` +
-          `of buffered frame data (${state.frames.length} frames). Call "record stop" to save what was captured.`
+            `of buffered frame data (${state.frames.length} frames). Call "record stop" to save what was captured.`,
         );
         await client.send('Page.stopScreencast', {}, sessionId).catch(() => {});
       }
     }
-    await client.send('Page.screencastFrameAck', { sessionId: frameSessionId }, sessionId).catch(() => {});
+    await client
+      .send('Page.screencastFrameAck', { sessionId: frameSessionId }, sessionId)
+      .catch(() => {});
   });
 
   try {
-    await client.send('Page.startScreencast', {
-      format: options.format ?? 'jpeg',
-      quality: options.quality ?? 80,
-      everyNthFrame: options.everyNthFrame ?? 1,
-      ...(options.maxWidth ? { maxWidth: options.maxWidth } : {}),
-      ...(options.maxHeight ? { maxHeight: options.maxHeight } : {}),
-    }, sessionId);
+    await client.send(
+      'Page.startScreencast',
+      {
+        format: options.format ?? 'jpeg',
+        quality: options.quality ?? 80,
+        everyNthFrame: options.everyNthFrame ?? 1,
+        ...(options.maxWidth ? { maxWidth: options.maxWidth } : {}),
+        ...(options.maxHeight ? { maxHeight: options.maxHeight } : {}),
+      },
+      sessionId,
+    );
   } catch (err) {
     state.offScreencast?.();
     _sessions.delete(sessionId);
@@ -89,7 +100,7 @@ export async function startRecording(
 export async function stopRecording(
   client: CdpClient,
   sessionId: string,
-  outputPath?: string
+  outputPath?: string,
 ): Promise<string> {
   const state = _sessions.get(sessionId);
   if (!state) throw new Error('No active recording for this session');
@@ -110,16 +121,24 @@ export async function stopRecording(
   return path;
 }
 
-export function getRecordingStatus(sessionId: string): { recording: boolean; frames: number; autoStopped: boolean } {
+export function getRecordingStatus(sessionId: string): {
+  recording: boolean;
+  frames: number;
+  autoStopped: boolean;
+} {
   const state = _sessions.get(sessionId);
-  return { recording: !!state && !state.autoStopped, frames: state?.frames.length ?? 0, autoStopped: state?.autoStopped ?? false };
+  return {
+    recording: !!state && !state.autoStopped,
+    frames: state?.frames.length ?? 0,
+    autoStopped: state?.autoStopped ?? false,
+  };
 }
 
 export async function saveFrameAsPng(
-  client: CdpClient,
+  _client: CdpClient,
   sessionId: string,
   frameIndex: number,
-  outputPath: string
+  outputPath: string,
 ): Promise<void> {
   const state = _sessions.get(sessionId);
   if (!state || frameIndex >= state.frames.length) {

package/src/browser/ref-cache.ts

@@ -10,8 +10,8 @@
  * The full AX-tree text/dump is intentionally NOT persisted — only the
  * per-ref index, to keep the file small.
  */
-import { readFile, writeFile, mkdir, rm } from 'fs/promises';
-import { join } from 'path';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import type { ElementRef } from './types.js';
 
 const CACHE_DIR = join(process.cwd(), '.monomind', 'monobrowse');
@@ -40,7 +40,7 @@ export interface RefCacheEntry {
 export async function saveRefCache(
   targetId: string,
   url: string,
-  refs: Map<string, ElementRef>
+  refs: Map<string, ElementRef>,
 ): Promise<void> {
   try {
     await mkdir(CACHE_DIR, { recursive: true });
@@ -99,7 +99,7 @@ export async function clearRefCache(): Promise<void> {
  */
 export async function saveActivePort(
   port: number,
-  opts?: { launched?: boolean; pid?: number; userDataDir?: string }
+  opts?: { launched?: boolean; pid?: number; userDataDir?: string },
 ): Promise<void> {
   try {
     await mkdir(CACHE_DIR, { recursive: true });
@@ -113,13 +113,16 @@ export async function saveActivePort(
     // and kill the Chrome this one launched. Without this, closeBrowser()'s
     // PID-kill fallback can never fire outside the launching process, since
     // the in-memory launchedPids Map (browser.ts) is empty there.
-    await writeFile(PORT_FILE, JSON.stringify({
-      port,
-      launched: opts?.launched !== false,
-      pid: opts?.pid,
-      userDataDir: opts?.userDataDir,
-      savedAt: Date.now(),
-    }));
+    await writeFile(
+      PORT_FILE,
+      JSON.stringify({
+        port,
+        launched: opts?.launched !== false,
+        pid: opts?.pid,
+        userDataDir: opts?.userDataDir,
+        savedAt: Date.now(),
+      }),
+    );
   } catch {
     // Best-effort — persistence failure just means the next process falls
     // back to the hardcoded default port, matching prior behavior.
@@ -142,17 +145,35 @@ export async function loadActivePort(): Promise<number | null> {
 }
 
 /** Load the persisted active port with its provenance flag, PID, user-data-dir, and save timestamp. */
-export async function loadActivePortInfo(): Promise<
-  { port: number; launched: boolean; pid?: number; userDataDir?: string; savedAt?: number } | null
-> {
+export async function loadActivePortInfo(): Promise<{
+  port: number;
+  launched: boolean;
+  pid?: number;
+  userDataDir?: string;
+  savedAt?: number;
+} | null> {
   try {
     const raw = await readFile(PORT_FILE, 'utf8');
-    const data = JSON.parse(raw) as { port?: unknown; launched?: unknown; pid?: unknown; userDataDir?: unknown; savedAt?: unknown };
-    if (typeof data.port === 'number' && Number.isInteger(data.port) && data.port >= 1024 && data.port <= 65535) {
+    const data = JSON.parse(raw) as {
+      port?: unknown;
+      launched?: unknown;
+      pid?: unknown;
+      userDataDir?: unknown;
+      savedAt?: unknown;
+    };
+    if (
+      typeof data.port === 'number' &&
+      Number.isInteger(data.port) &&
+      data.port >= 1024 &&
+      data.port <= 65535
+    ) {
       return {
         port: data.port,
         launched: data.launched !== false,
-        pid: typeof data.pid === 'number' && Number.isInteger(data.pid) && data.pid > 0 ? data.pid : undefined,
+        pid:
+          typeof data.pid === 'number' && Number.isInteger(data.pid) && data.pid > 0
+            ? data.pid
+            : undefined,
         userDataDir: typeof data.userDataDir === 'string' ? data.userDataDir : undefined,
         savedAt: typeof data.savedAt === 'number' ? data.savedAt : undefined,
       };