@monoes/monobrowse 1.0.11 → 1.0.13

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,
       };

package/src/browser/screenshot.ts

@@ -1,9 +1,9 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import type { ElementRef } from './types.js';
 import { getObjectIdForRef } from './snapshot.js';
-import { writeFile, mkdir } from 'fs/promises';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
+import type { ElementRef } from './types.js';
 
 export interface ScreenshotOptions {
   path?: string;
@@ -17,16 +17,21 @@ export interface ScreenshotOptions {
 async function getViewportTopLeft(
   client: CdpClient,
   sessionId: string,
-  ref: ElementRef
+  ref: ElementRef,
 ): Promise<{ x: number; y: number } | null> {
   const objectId = await getObjectIdForRef(client, sessionId, ref).catch(() => null);
   if (!objectId) return null;
   try {
-    const r = await client.send<{ result: { value?: string } }>('Runtime.callFunctionOn', {
-      functionDeclaration: 'function() { var r=this.getBoundingClientRect(); if(r.width===0&&r.height===0)return null; return JSON.stringify({x:Math.round(r.left),y:Math.round(r.top)}); }',
-      objectId,
-      returnByValue: true,
-    }, sessionId);
+    const r = await client.send<{ result: { value?: string } }>(
+      'Runtime.callFunctionOn',
+      {
+        functionDeclaration:
+          'function() { var r=this.getBoundingClientRect(); if(r.width===0&&r.height===0)return null; return JSON.stringify({x:Math.round(r.left),y:Math.round(r.top)}); }',
+        objectId,
+        returnByValue: true,
+      },
+      sessionId,
+    );
     if (!r.result?.value) return null;
     return JSON.parse(r.result.value) as { x: number; y: number };
   } catch {
@@ -37,7 +42,7 @@ async function getViewportTopLeft(
 async function injectAnnotationOverlay(
   client: CdpClient,
   sessionId: string,
-  refs: Map<string, ElementRef>
+  refs: Map<string, ElementRef>,
 ): Promise<void> {
   const badges: Array<{ num: number; x: number; y: number }> = [];
   for (const [key, ref] of refs) {
@@ -49,8 +54,11 @@ async function injectAnnotationOverlay(
   if (badges.length === 0) return;
 
   const badgesJson = JSON.stringify(badges);
-  await client.send('Runtime.evaluate', {
-    expression: `(function(){
+  await client
+    .send(
+      'Runtime.evaluate',
+      {
+        expression: `(function(){
       var p=document.getElementById('__mm_ann__');if(p)p.remove();
       var c=document.createElement('div');
       c.id='__mm_ann__';
@@ -64,21 +72,30 @@ async function injectAnnotationOverlay(
       });
       document.body.appendChild(c);
     })()`,
-    returnByValue: false,
-  }, sessionId).catch(() => {});
+        returnByValue: false,
+      },
+      sessionId,
+    )
+    .catch(() => {});
 }
 
 async function removeAnnotationOverlay(client: CdpClient, sessionId: string): Promise<void> {
-  await client.send('Runtime.evaluate', {
-    expression: `(function(){var e=document.getElementById('__mm_ann__');if(e)e.remove();})()`,
-    returnByValue: false,
-  }, sessionId).catch(() => {});
+  await client
+    .send(
+      'Runtime.evaluate',
+      {
+        expression: `(function(){var e=document.getElementById('__mm_ann__');if(e)e.remove();})()`,
+        returnByValue: false,
+      },
+      sessionId,
+    )
+    .catch(() => {});
 }
 
 export async function captureScreenshot(
   client: CdpClient,
   sessionId: string,
-  options: ScreenshotOptions = {}
+  options: ScreenshotOptions = {},
 ): Promise<{ path: string; dataUrl: string }> {
   const format = options.format ?? 'png';
   const params: Record<string, unknown> = { format };
@@ -88,10 +105,15 @@ export async function captureScreenshot(
   }
 
   if (options.fullPage) {
-    const dims = await client.send<{ result: { value: string } }>('Runtime.evaluate', {
-      expression: 'JSON.stringify({w: document.documentElement.scrollWidth, h: document.documentElement.scrollHeight})',
-      returnByValue: true,
-    }, sessionId);
+    const dims = await client.send<{ result: { value: string } }>(
+      'Runtime.evaluate',
+      {
+        expression:
+          'JSON.stringify({w: document.documentElement.scrollWidth, h: document.documentElement.scrollHeight})',
+        returnByValue: true,
+      },
+      sessionId,
+    );
     const { w, h } = JSON.parse(dims.result?.value ?? '{"w":1280,"h":720}');
     params.clip = { x: 0, y: 0, width: w, height: h, scale: 1 };
     params.captureBeyondViewport = true;
@@ -123,20 +145,24 @@ export async function setViewport(
   client: CdpClient,
   sessionId: string,
   width: number,
-  height: number
+  height: number,
 ): Promise<void> {
-  await client.send('Emulation.setDeviceMetricsOverride', {
-    width,
-    height,
-    deviceScaleFactor: 1,
-    mobile: false,
-  }, sessionId);
+  await client.send(
+    'Emulation.setDeviceMetricsOverride',
+    {
+      width,
+      height,
+      deviceScaleFactor: 1,
+      mobile: false,
+    },
+    sessionId,
+  );
 }
 
 export async function setUserAgent(
   client: CdpClient,
   sessionId: string,
-  userAgent: string
+  userAgent: string,
 ): Promise<void> {
   await client.send('Emulation.setUserAgentOverride', { userAgent }, sessionId);
 }

package/src/browser/session.ts

@@ -1,9 +1,16 @@
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
-import type { SessionState, CdpCookie } from './types.js';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import { getCookiesForUrls, setCookies, getLocalStorage, setLocalStorage, getSessionStorage, setSessionStorage } from './network.js';
+import {
+  getCookiesForUrls,
+  getLocalStorage,
+  getSessionStorage,
+  setCookies,
+  setLocalStorage,
+  setSessionStorage,
+} from './network.js';
+import type { SessionState } from './types.js';
 
 // Session state files contain cookies/localStorage — treat as secrets:
 // owner-only read/write on the file (0600) and owner-only access on the
@@ -23,7 +30,12 @@ function validateFilePath(filePath: string): void {
   if (!filePath || filePath.includes('\x00')) {
     throw new Error(`Invalid file path: ${JSON.stringify(filePath)}`);
   }
-  if (filePath.includes('/../') || filePath.startsWith('../') || filePath.endsWith('/..') || filePath.includes('\\')) {
+  if (
+    filePath.includes('/../') ||
+    filePath.startsWith('../') ||
+    filePath.endsWith('/..') ||
+    filePath.includes('\\')
+  ) {
     throw new Error(`Invalid file path (traversal not allowed): ${JSON.stringify(filePath)}`);
   }
 }
@@ -34,7 +46,7 @@ export async function saveSession(
   targetId: string,
   name: string,
   url: string,
-  title: string
+  title: string,
 ): Promise<string> {
   validateSessionName(name);
   await mkdir(SESSION_DIR, { recursive: true, mode: SESSION_DIR_MODE });
@@ -43,7 +55,15 @@ export async function saveSession(
   const localStorage = await getLocalStorage(client, sessionId);
   const sessionStorage = await getSessionStorage(client, sessionId);
 
-  const state: SessionState = { targetId, sessionId, url, title, cookies, localStorage, sessionStorage };
+  const state: SessionState = {
+    targetId,
+    sessionId,
+    url,
+    title,
+    cookies,
+    localStorage,
+    sessionStorage,
+  };
   const filePath = join(SESSION_DIR, `${name}.json`);
   await writeFile(filePath, JSON.stringify(state, null, 2), { mode: SESSION_FILE_MODE });
   return filePath;
@@ -52,7 +72,7 @@ export async function saveSession(
 export async function loadSession(
   client: CdpClient,
   sessionId: string,
-  name: string
+  name: string,
 ): Promise<SessionState> {
   validateSessionName(name);
   const filePath = join(SESSION_DIR, `${name}.json`);
@@ -61,15 +81,18 @@ export async function loadSession(
     throw err;
   });
   const state: SessionState = JSON.parse(raw);
-  if (!Array.isArray(state.cookies)) throw new Error(`Invalid session file: cookies is not an array`);
+  if (!Array.isArray(state.cookies))
+    throw new Error(`Invalid session file: cookies is not an array`);
 
   await setCookies(client, sessionId, state.cookies);
   if (state.localStorage) {
-    if (typeof state.localStorage !== 'object' || Array.isArray(state.localStorage)) throw new Error('Invalid session file: localStorage is not a plain object');
+    if (typeof state.localStorage !== 'object' || Array.isArray(state.localStorage))
+      throw new Error('Invalid session file: localStorage is not a plain object');
     await setLocalStorage(client, sessionId, state.localStorage);
   }
   if (state.sessionStorage) {
-    if (typeof state.sessionStorage !== 'object' || Array.isArray(state.sessionStorage)) throw new Error('Invalid session file: sessionStorage is not a plain object');
+    if (typeof state.sessionStorage !== 'object' || Array.isArray(state.sessionStorage))
+      throw new Error('Invalid session file: sessionStorage is not a plain object');
     await setSessionStorage(client, sessionId, state.sessionStorage);
   }
 
@@ -82,21 +105,29 @@ export async function saveStateFile(
   targetId: string,
   filePath: string,
   url: string,
-  title: string
+  title: string,
 ): Promise<void> {
   validateFilePath(filePath);
   await mkdir(dirname(filePath), { recursive: true, mode: SESSION_DIR_MODE });
   const cookies = await getCookiesForUrls(client, sessionId, [url]);
   const localStorage = await getLocalStorage(client, sessionId);
   const sessionStorage = await getSessionStorage(client, sessionId);
-  const state: SessionState = { targetId, sessionId, url, title, cookies, localStorage, sessionStorage };
+  const state: SessionState = {
+    targetId,
+    sessionId,
+    url,
+    title,
+    cookies,
+    localStorage,
+    sessionStorage,
+  };
   await writeFile(filePath, JSON.stringify(state, null, 2), { mode: SESSION_FILE_MODE });
 }
 
 export async function loadStateFile(
   client: CdpClient,
   sessionId: string,
-  filePath: string
+  filePath: string,
 ): Promise<SessionState> {
   validateFilePath(filePath);
   const raw = await readFile(filePath, 'utf8');
@@ -104,18 +135,20 @@ export async function loadStateFile(
   if (!Array.isArray(state.cookies)) throw new Error(`Invalid state file: cookies is not an array`);
   await setCookies(client, sessionId, state.cookies);
   if (state.localStorage) {
-    if (typeof state.localStorage !== 'object' || Array.isArray(state.localStorage)) throw new Error('Invalid state file: localStorage is not a plain object');
+    if (typeof state.localStorage !== 'object' || Array.isArray(state.localStorage))
+      throw new Error('Invalid state file: localStorage is not a plain object');
     await setLocalStorage(client, sessionId, state.localStorage);
   }
   if (state.sessionStorage) {
-    if (typeof state.sessionStorage !== 'object' || Array.isArray(state.sessionStorage)) throw new Error('Invalid state file: sessionStorage is not a plain object');
+    if (typeof state.sessionStorage !== 'object' || Array.isArray(state.sessionStorage))
+      throw new Error('Invalid state file: sessionStorage is not a plain object');
     await setSessionStorage(client, sessionId, state.sessionStorage);
   }
   return state;
 }
 
 export async function listSessions(): Promise<string[]> {
-  const { readdir } = await import('fs/promises');
+  const { readdir } = await import('node:fs/promises');
   const files = await readdir(SESSION_DIR).catch((err: NodeJS.ErrnoException) => {
     if (err.code === 'ENOENT') return [] as string[];
     throw err;

package/src/browser/snapshot.ts

@@ -1,7 +1,7 @@
+import { getCurrentTitle, getCurrentUrl } from './browser.js';
 import type { CdpClient } from './cdp.js';
 import type { ElementRef, SnapshotOptions, SnapshotResult } from './types.js';
 import { INTERACTIVE_ROLES } from './types.js';
-import { getCurrentUrl, getCurrentTitle } from './browser.js';
 
 interface AXNode {
   nodeId: number;
@@ -20,7 +20,7 @@ interface AXNode {
 export async function captureSnapshot(
   client: CdpClient,
   sessionId: string,
-  options: SnapshotOptions = {}
+  options: SnapshotOptions = {},
 ): Promise<SnapshotResult> {
   const { interactiveOnly = false, compact = false, maxDepth, selector } = options;
 
@@ -28,25 +28,39 @@ export async function captureSnapshot(
   let nodes: AXNode[];
   if (selector) {
     const doc = await client.send<{ root: { nodeId: number } }>('DOM.getDocument', {}, sessionId);
-    const found = await client.send<{ nodeId: number }>(
-      'DOM.querySelector',
-      { nodeId: doc.root.nodeId, selector },
-      sessionId
-    ).catch(() => ({ nodeId: 0 }));
+    const found = await client
+      .send<{ nodeId: number }>(
+        'DOM.querySelector',
+        { nodeId: doc.root.nodeId, selector },
+        sessionId,
+      )
+      .catch(() => ({ nodeId: 0 }));
 
     if (found.nodeId) {
-      const partial = await client.send<{ nodes: AXNode[] }>(
-        'Accessibility.getPartialAXTree',
-        { nodeId: found.nodeId, fetchRelatives: false },
-        sessionId
-      ).catch(async () => client.send<{ nodes: AXNode[] }>('Accessibility.getFullAXTree', {}, sessionId));
+      const partial = await client
+        .send<{ nodes: AXNode[] }>(
+          'Accessibility.getPartialAXTree',
+          { nodeId: found.nodeId, fetchRelatives: false },
+          sessionId,
+        )
+        .catch(async () =>
+          client.send<{ nodes: AXNode[] }>('Accessibility.getFullAXTree', {}, sessionId),
+        );
       nodes = partial.nodes;
     } else {
-      const full = await client.send<{ nodes: AXNode[] }>('Accessibility.getFullAXTree', {}, sessionId);
+      const full = await client.send<{ nodes: AXNode[] }>(
+        'Accessibility.getFullAXTree',
+        {},
+        sessionId,
+      );
       nodes = full.nodes;
     }
   } else {
-    const full = await client.send<{ nodes: AXNode[] }>('Accessibility.getFullAXTree', {}, sessionId);
+    const full = await client.send<{ nodes: AXNode[] }>(
+      'Accessibility.getFullAXTree',
+      {},
+      sessionId,
+    );
     nodes = full.nodes;
   }
 
@@ -192,10 +206,10 @@ function extractProperties(node: AXNode): {
 }
 
 export async function resolveRef(
-  client: CdpClient,
-  sessionId: string,
+  _client: CdpClient,
+  _sessionId: string,
   refs: Map<string, ElementRef>,
-  refKey: string
+  refKey: string,
 ): Promise<ElementRef> {
   const ref = refs.get(refKey);
   if (!ref) throw new Error(`Element ref @${refKey} not found. Run snapshot first.`);
@@ -205,14 +219,14 @@ export async function resolveRef(
 export async function getObjectIdForRef(
   client: CdpClient,
   sessionId: string,
-  ref: ElementRef
+  ref: ElementRef,
 ): Promise<string | null> {
   if (!ref.backendDOMNodeId) return null;
 
   const result = await client.send<{ object: { objectId?: string } }>(
     'DOM.resolveNode',
     { backendNodeId: ref.backendDOMNodeId },
-    sessionId
+    sessionId,
   );
   return result.object?.objectId ?? null;
 }
@@ -231,7 +245,7 @@ export async function getObjectIdForRef(
 export async function getElementBox(
   client: CdpClient,
   sessionId: string,
-  ref: ElementRef
+  ref: ElementRef,
 ): Promise<{ x: number; y: number; width: number; height: number } | null> {
   if (!ref.backendDOMNodeId) return null;
 

package/src/browser/storage.ts

@@ -1,16 +1,37 @@
-import type { CdpClient } from './cdp.js';
 import { evaluateJs } from './actions.js';
+import type { CdpClient } from './cdp.js';
 
-export async function getLocalStorageKey(client: CdpClient, sessionId: string, key: string): Promise<string | null> {
-  const result = await evaluateJs(client, sessionId, `localStorage.getItem(${JSON.stringify(key)})`);
+export async function getLocalStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+): Promise<string | null> {
+  const result = await evaluateJs(
+    client,
+    sessionId,
+    `localStorage.getItem(${JSON.stringify(key)})`,
+  );
   return result as string | null;
 }
 
-export async function setLocalStorageKey(client: CdpClient, sessionId: string, key: string, value: string): Promise<void> {
-  await evaluateJs(client, sessionId, `localStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`);
+export async function setLocalStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+  value: string,
+): Promise<void> {
+  await evaluateJs(
+    client,
+    sessionId,
+    `localStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`,
+  );
 }
 
-export async function removeLocalStorageKey(client: CdpClient, sessionId: string, key: string): Promise<void> {
+export async function removeLocalStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+): Promise<void> {
   await evaluateJs(client, sessionId, `localStorage.removeItem(${JSON.stringify(key)})`);
 }
 
@@ -18,25 +39,53 @@ export async function clearLocalStorage(client: CdpClient, sessionId: string): P
   await evaluateJs(client, sessionId, 'localStorage.clear()');
 }
 
-export async function getAllLocalStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>> {
+export async function getAllLocalStorage(
+  client: CdpClient,
+  sessionId: string,
+): Promise<Record<string, string>> {
   const result = await evaluateJs(
     client,
     sessionId,
-    'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))'
+    'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))',
   );
-  try { return JSON.parse(result as string); } catch { return {}; }
+  try {
+    return JSON.parse(result as string);
+  } catch {
+    return {};
+  }
 }
 
-export async function getSessionStorageKey(client: CdpClient, sessionId: string, key: string): Promise<string | null> {
-  const result = await evaluateJs(client, sessionId, `sessionStorage.getItem(${JSON.stringify(key)})`);
+export async function getSessionStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+): Promise<string | null> {
+  const result = await evaluateJs(
+    client,
+    sessionId,
+    `sessionStorage.getItem(${JSON.stringify(key)})`,
+  );
   return result as string | null;
 }
 
-export async function setSessionStorageKey(client: CdpClient, sessionId: string, key: string, value: string): Promise<void> {
-  await evaluateJs(client, sessionId, `sessionStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`);
+export async function setSessionStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+  value: string,
+): Promise<void> {
+  await evaluateJs(
+    client,
+    sessionId,
+    `sessionStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`,
+  );
 }
 
-export async function removeSessionStorageKey(client: CdpClient, sessionId: string, key: string): Promise<void> {
+export async function removeSessionStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+): Promise<void> {
   await evaluateJs(client, sessionId, `sessionStorage.removeItem(${JSON.stringify(key)})`);
 }
 
@@ -44,11 +93,18 @@ export async function clearSessionStorage(client: CdpClient, sessionId: string):
   await evaluateJs(client, sessionId, 'sessionStorage.clear()');
 }
 
-export async function getAllSessionStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>> {
+export async function getAllSessionStorage(
+  client: CdpClient,
+  sessionId: string,
+): Promise<Record<string, string>> {
   const result = await evaluateJs(
     client,
     sessionId,
-    'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))'
+    'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))',
   );
-  try { return JSON.parse(result as string); } catch { return {}; }
+  try {
+    return JSON.parse(result as string);
+  } catch {
+    return {};
+  }
 }