@monoes/monobrowse 1.0.11 → 1.0.13

package/src/__tests__/report-render.test.ts

@@ -0,0 +1,175 @@
+/**
+ * The renderer's contract is that the HTML is SELF-CONTAINED: it must render
+ * identically on a machine with no network, because monomind's document
+ * pipeline ingests it as an ordinary document and because an archived report
+ * has to still work years later. These tests enforce that mechanically.
+ */
+import { describe, expect, it } from 'vitest';
+import { buildReport } from '../report/analyze.js';
+import { DEFAULT_BUDGET, parseBudget } from '../report/budget.js';
+import { escapeHtml, renderHtml } from '../report/render.js';
+import type { CaptureData, Report } from '../report/types.js';
+
+const PNG =
+  'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==';
+
+function capture(partial: Partial<CaptureData> = {}): CaptureData {
+  return {
+    url: 'https://shop.test/checkout',
+    finalUrl: 'https://shop.test/checkout',
+    title: 'Checkout',
+    capturedAt: '2026-09-21T10:00:00.000Z',
+    durationMs: 3200,
+    console: [],
+    pageErrors: [],
+    requests: [],
+    vitals: {},
+    a11y: [],
+    screenshots: [],
+    notes: [],
+    ...partial,
+  };
+}
+
+function report(partial: Partial<CaptureData> = {}, budget = DEFAULT_BUDGET): Report {
+  return buildReport(capture(partial), budget);
+}
+
+/** Anything that would make the browser go to the network to render the page. */
+function externalReferences(html: string): string[] {
+  const patterns = [
+    /<script[^>]+\ssrc\s*=/gi,
+    /<link\b/gi,
+    /@import/gi,
+    /url\(\s*['"]?https?:/gi,
+    /\s(?:src|href|poster|action|data)\s*=\s*["']https?:/gi,
+    /\s(?:src|href)\s*=\s*["']\/\//gi,
+  ];
+  return patterns.flatMap((p) => html.match(p) ?? []);
+}
+
+describe('renderHtml — self-containment', () => {
+  it('references no external resource of any kind', () => {
+    const html = renderHtml(
+      report({
+        screenshots: [{ label: 'page', width: 1280, height: 3000, dataUrl: PNG }],
+        requests: [{ url: 'https://cdn.test/app.js', method: 'GET', status: 404, failed: true }],
+        console: [{ type: 'error', text: 'boom', url: 'https://cdn.test/app.js', timestamp: 0 }],
+      }),
+    );
+    expect(externalReferences(html)).toEqual([]);
+  });
+
+  it('inlines its CSS in a style element and inlines screenshots as data URIs', () => {
+    const html = renderHtml(
+      report({ screenshots: [{ label: 'page', width: 800, height: 600, dataUrl: PNG }] }),
+    );
+    expect(html).toContain('<style>');
+    expect(html).toContain('src="data:image/png;base64,');
+  });
+
+  it('themes for both light and dark without JavaScript', () => {
+    const html = renderHtml(report());
+    expect(html).toContain('@media (prefers-color-scheme: dark)');
+    expect(html).not.toMatch(/<script(?![^>]*type="application\/json")/i);
+  });
+});
+
+describe('renderHtml — content', () => {
+  it('leads with a PASS verdict for a clean page', () => {
+    const html = renderHtml(report({ vitals: { lcp: 800, cls: 0.01, inp: 20 } }));
+    const verdictAt = html.indexOf('PASS');
+    expect(verdictAt).toBeGreaterThan(-1);
+    expect(verdictAt).toBeLessThan(html.indexOf('Failed requests'));
+    expect(html).toContain('All budgets met.');
+  });
+
+  it('orders the sections verdict, errors, failed requests, vitals, a11y, screenshots', () => {
+    const html = renderHtml(report());
+    const order = [
+      'PASS',
+      'Errors',
+      'Failed requests',
+      'Web vitals',
+      'Accessibility',
+      'Screenshots',
+    ];
+    const positions = order.map((s) => html.indexOf(s));
+    expect(positions.every((p) => p > -1)).toBe(true);
+    expect([...positions].sort((a, b) => a - b)).toEqual(positions);
+  });
+
+  it('shows each budget failure with its expected and actual values', () => {
+    const html = renderHtml(
+      report({ vitals: { lcp: 4100, cls: 0, inp: 0 } }, parseBudget({ lcp: 2500 })),
+    );
+    expect(html).toContain('FAIL');
+    expect(html).toContain('LCP (Largest Contentful Paint)');
+    expect(html).toContain('&lt;= 2500ms');
+    expect(html).toContain('4100ms');
+  });
+
+  it('lists failed requests and omits the successful ones', () => {
+    const html = renderHtml(
+      report({
+        requests: [
+          { url: 'https://shop.test/api/cart', method: 'POST', status: 500, failed: true },
+          { url: 'https://shop.test/ok', method: 'GET', status: 200, failed: false },
+        ],
+      }),
+    );
+    expect(html).toContain('https://shop.test/api/cart');
+    expect(html).not.toContain('https://shop.test/ok');
+  });
+
+  it('says a metric was not measured rather than showing a fake zero', () => {
+    const html = renderHtml(report({ vitals: { cls: 0.05 } }));
+    expect(html).toContain('not measured');
+  });
+
+  it('renders a11y findings with role, name state and locator', () => {
+    const html = renderHtml(
+      report({
+        a11y: [
+          {
+            rule: 'unlabelled-control',
+            impact: 'error',
+            role: 'button',
+            name: null,
+            locator: 'form > button:nth-of-type(2)',
+            detail: 'button has no accessible name',
+          },
+        ],
+      }),
+    );
+    expect(html).toContain('unlabelled-control');
+    expect(html).toContain('form &gt; button:nth-of-type(2)');
+    expect(html).toContain('(no accessible name)');
+  });
+
+  it('states plainly that contrast was not evaluated', () => {
+    expect(renderHtml(report())).toMatch(/[Cc]olour contrast is not evaluated/);
+  });
+
+  it('surfaces degraded-run notes', () => {
+    const html = renderHtml(report({ notes: ['Page never went network-idle within 20000ms'] }));
+    expect(html).toContain('Run notes');
+    expect(html).toContain('never went network-idle');
+  });
+});
+
+describe('escapeHtml', () => {
+  it('neutralizes markup from page-controlled strings', () => {
+    expect(escapeHtml('<img src=x onerror="alert(1)">')).toBe(
+      '&lt;img src=x onerror=&quot;alert(1)&quot;&gt;',
+    );
+  });
+
+  it('keeps an injected error message from breaking out of the document', () => {
+    const html = renderHtml(
+      report({ pageErrors: [{ text: '</table><script>alert(1)</script>', timestamp: 0 }] }),
+    );
+    expect(html).not.toContain('<script>alert(1)</script>');
+    expect(html).toContain('&lt;script&gt;');
+  });
+});

package/src/__tests__/report-run.test.ts

@@ -0,0 +1,264 @@
+/**
+ * The orchestration seam in report/index.ts: history is read before the run
+ * is saved, evidence is only built when it is warranted, and `--repeat`
+ * judges the set rather than the last run.
+ *
+ * `collect` is mocked, so nothing here launches Chrome. Output and history
+ * both go to a scratch directory under the monomind data dir — never the
+ * shared /tmp.
+ */
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { CdpClient } from '../browser/cdp.js';
+import { historyKey, listRuns } from '../report/history.js';
+import { encodePng, pngToDataUrl } from '../report/png.js';
+import type { CaptureData } from '../report/types.js';
+
+const collect = vi.hoisted(() => vi.fn());
+vi.mock('../report/collect.js', () => ({ collect }));
+
+const { runReport, runReportRepeated, readHistory } = await import('../report/index.js');
+
+const URL_UNDER_TEST = 'https://shop.test/checkout';
+const client = {} as CdpClient;
+
+function shot(shade: number, width = 8, height = 8) {
+  const data = new Uint8Array(width * height * 4);
+  for (let i = 0; i < width * height; i++) data.set([shade, shade, shade, 255], i * 4);
+  return {
+    label: 'page',
+    width,
+    height,
+    dataUrl: pngToDataUrl(encodePng({ width, height, data })),
+  };
+}
+
+function capture(partial: Partial<CaptureData> = {}): CaptureData {
+  return {
+    url: URL_UNDER_TEST,
+    finalUrl: URL_UNDER_TEST,
+    title: 'Checkout',
+    capturedAt: '2026-09-21T10:00:00.000Z',
+    durationMs: 1000,
+    console: [],
+    pageErrors: [],
+    requests: [],
+    vitals: { lcp: 2000, cls: 0.01, inp: 50 },
+    a11y: [],
+    structure: [{ path: '/main[1]/button[1]', role: 'button', name: 'Pay now', depth: 1 }],
+    screenshots: [shot(200)],
+    notes: [],
+    ...partial,
+  };
+}
+
+let root: string;
+let outDir: string;
+
+beforeEach(async () => {
+  await mkdir(join(homedir(), '.monomind'), { recursive: true });
+  root = await mkdtemp(join(homedir(), '.monomind', 'monobrowse-run-test-'));
+  outDir = join(root, 'out');
+  await mkdir(outDir, { recursive: true });
+  collect.mockReset();
+});
+
+afterEach(async () => {
+  await rm(root, { recursive: true, force: true });
+});
+
+const run = (data: CaptureData, extra: Record<string, unknown> = {}) => {
+  collect.mockResolvedValueOnce(data);
+  return runReport(client, 'S1', {
+    url: URL_UNDER_TEST,
+    out: join(outDir, `${Math.random().toString(36).slice(2)}.html`),
+    historyDir: root,
+    cwd: outDir,
+    ...extra,
+  });
+};
+
+describe('runReport and history', () => {
+  it('does not let the first run trend or diff against itself', async () => {
+    const result = await run(capture());
+    expect(result.report.trend?.runs).toBe(0);
+    expect(result.report.diff).toBeUndefined();
+    // ...but it is on disk for the next run to compare against.
+    expect((await listRuns(join(root, historyKey(URL_UNDER_TEST)))).length).toBe(1);
+  });
+
+  it('trends and diffs the second run against the first', async () => {
+    await run(capture());
+    const second = await run(
+      capture({
+        capturedAt: '2026-09-21T11:00:00.000Z',
+        vitals: { lcp: 2600, cls: 0.01, inp: 50 },
+        structure: [{ path: '/main[1]/button[1]', role: 'button', name: 'Place order', depth: 1 }],
+        screenshots: [shot(40)],
+      }),
+    );
+
+    expect(second.report.trend?.runs).toBe(1);
+    const lcp = second.report.trend?.series.find((s) => s.key === 'lcp');
+    expect(lcp).toMatchObject({ previous: 2000, current: 2600, direction: 'regressed' });
+
+    expect(second.report.diff?.previousCapturedAt).toBe('2026-09-21T10:00:00.000Z');
+    expect(second.report.diff?.structure?.renamed).toEqual([
+      { path: '/main[1]/button[1]', role: 'button', from: 'Pay now', to: 'Place order' },
+    ]);
+    // Every pixel went from light grey to dark — a whole-screenshot change.
+    expect(second.report.diff?.pixels?.changedPercent).toBe(100);
+  });
+
+  it('reports the history directory it wrote to', async () => {
+    const result = await run(capture());
+    expect(result.historyDir).toBe(join(root, historyKey(URL_UNDER_TEST)));
+  });
+
+  it('prunes to the configured maximum across runs', async () => {
+    for (let i = 0; i < 4; i++) {
+      await run(capture({ capturedAt: `2026-09-2${i + 1}T10:00:00.000Z` }), { historyMax: 2 });
+    }
+    const runs = await listRuns(join(root, historyKey(URL_UNDER_TEST)));
+    expect(runs.map((r) => r.capturedAt)).toEqual([
+      '2026-09-23T10:00:00.000Z',
+      '2026-09-24T10:00:00.000Z',
+    ]);
+  });
+
+  it('writes nothing to the store when history is off, and says nothing about trends', async () => {
+    const result = await run(capture(), { history: false });
+    expect(result.report.trend).toBeUndefined();
+    expect(result.historyDir).toBeUndefined();
+    await expect(readdir(join(root, historyKey(URL_UNDER_TEST)))).rejects.toThrow();
+  });
+
+  it('keeps the report when the history store cannot be written', async () => {
+    // A regular file where the store's directory needs to be: mkdir fails
+    // with ENOTDIR, and the report still has to come out.
+    const blocked = join(root, 'blocked-store');
+    await writeFile(blocked, 'not a directory', 'utf8');
+    const result = await run(capture(), { historyDir: blocked });
+    expect(result.report.verdict).toBe('pass');
+    expect(result.report.notes.join(' ')).toMatch(/Run history unavailable/);
+    expect(result.historyDir).toBeUndefined();
+  });
+
+  it('exposes the stored runs through readHistory', async () => {
+    await run(capture());
+    const { runs } = await readHistory(URL_UNDER_TEST, { historyDir: root });
+    expect(runs.length).toBe(1);
+    expect(runs[0]).toMatchObject({ url: URL_UNDER_TEST, verdict: 'pass' });
+  });
+});
+
+describe('runReport and evidence', () => {
+  const recording = {
+    startedAtMs: 1_000_000,
+    frames: [
+      { offsetMs: 0, data: 'AAAA', bytes: 4 },
+      { offsetMs: 900, data: 'BBBB', bytes: 4 },
+    ],
+    droppedFrames: 0,
+    requested: false,
+  };
+
+  it('attaches evidence when the run breaches its budget', async () => {
+    const result = await run(
+      capture({
+        recording,
+        console: [{ type: 'error', text: 'boom', timestamp: 1_000_800 }],
+      }),
+    );
+    expect(result.report.verdict).toBe('fail');
+    expect(result.report.evidence?.reason).toBe('budget-failure');
+    expect(result.report.evidence?.focusOffsetMs).toBe(800);
+    expect(result.report.evidence?.frames.length).toBe(2);
+  });
+
+  it('does not attach evidence to a passing run that did not ask for it', async () => {
+    const result = await run(capture({ recording }));
+    expect(result.report.verdict).toBe('pass');
+    expect(result.report.evidence).toBeUndefined();
+  });
+
+  it('attaches evidence to a passing run when --record asked for it', async () => {
+    const result = await run(capture({ recording: { ...recording, requested: true } }));
+    expect(result.report.evidence?.reason).toBe('requested');
+  });
+
+  it('never leaves the raw recording on the report it returns', async () => {
+    const result = await run(capture({ recording: { ...recording, requested: true } }));
+    expect(result.report.recording).toBeUndefined();
+  });
+
+  it('keeps the frame images out of the JSON sibling', async () => {
+    const result = await run(capture({ recording: { ...recording, requested: true } }));
+    const json = JSON.parse(await readFile(result.jsonPath, 'utf8'));
+    expect(json.evidence.frames).toEqual([
+      { offsetMs: 0, bytes: 4 },
+      { offsetMs: 900, bytes: 4 },
+    ]);
+  });
+});
+
+describe('runReportRepeated', () => {
+  const failing = capture({ console: [{ type: 'error', text: 'boom', timestamp: 0 }] });
+
+  it('runs the URL N times and judges the set', async () => {
+    for (const data of [capture(), failing, capture()]) collect.mockResolvedValueOnce(data);
+    const result = await runReportRepeated(client, 'S1', {
+      url: URL_UNDER_TEST,
+      out: join(outDir, 'repeat.html'),
+      historyDir: root,
+      cwd: outDir,
+      repeat: 3,
+    });
+
+    expect(collect).toHaveBeenCalledTimes(3);
+    expect(result.reports.length).toBe(3);
+    expect(result.flake.verdict).toBe('flaky');
+    expect(result.summary).toMatch(/^FLAKY/);
+  });
+
+  it('refuses to call a sometimes-failing URL a pass, even when the last run is green', async () => {
+    for (const data of [failing, capture()]) collect.mockResolvedValueOnce(data);
+    const result = await runReportRepeated(client, 'S1', {
+      url: URL_UNDER_TEST,
+      out: join(outDir, 'repeat2.html'),
+      historyDir: root,
+      cwd: outDir,
+      repeat: 2,
+    });
+    expect(result.report.verdict).toBe('pass'); // the last run alone
+    expect(result.flake.verdict).toBe('flaky'); // what the command reports
+  });
+
+  it('writes one history entry for the whole command, not one per run', async () => {
+    for (const data of [capture(), capture(), capture()]) collect.mockResolvedValueOnce(data);
+    await runReportRepeated(client, 'S1', {
+      url: URL_UNDER_TEST,
+      out: join(outDir, 'repeat3.html'),
+      historyDir: root,
+      cwd: outDir,
+      repeat: 3,
+    });
+    expect((await listRuns(join(root, historyKey(URL_UNDER_TEST)))).length).toBe(1);
+  });
+
+  it('puts the flake analysis in the JSON sibling', async () => {
+    for (const data of [capture(), failing]) collect.mockResolvedValueOnce(data);
+    const result = await runReportRepeated(client, 'S1', {
+      url: URL_UNDER_TEST,
+      out: join(outDir, 'repeat4.html'),
+      historyDir: root,
+      cwd: outDir,
+      repeat: 2,
+    });
+    const json = JSON.parse(await readFile(result.jsonPath, 'utf8'));
+    expect(json.flake.verdict).toBe('flaky');
+    expect(json.flake.runs).toBe(2);
+  });
+});

package/src/__tests__/session-state.test.ts

@@ -6,23 +6,21 @@
  * validation logic: the CdpClient is a stub that answers the handful of CDP
  * commands the round trip issues.
  */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdtemp, rm, readFile, stat, mkdir } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
+
+import { mkdir, 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';
 import type { CdpClient } from '../browser/cdp.js';
-import {
-  saveStateFile,
-  loadStateFile,
-  saveSession,
-  loadSession,
-  listSessions,
-} from '../browser/session.js';
+import { loadSession, loadStateFile, saveSession, saveStateFile } from '../browser/session.js';
 
 const COOKIES = [{ name: 'sid', value: 'abc', domain: 'x.test', path: '/' }];
 
 /** Records every CDP command and answers the ones session.ts depends on. */
-function stubClient(): { client: CdpClient; calls: Array<{ method: string; params: unknown; sid?: string }> } {
+function stubClient(): {
+  client: CdpClient;
+  calls: Array<{ method: string; params: unknown; sid?: string }>;
+} {
   const calls: Array<{ method: string; params: unknown; sid?: string }> = [];
   const client = {
     send: vi.fn(async (method: string, params: unknown, sid?: string) => {
@@ -30,8 +28,10 @@ function stubClient(): { client: CdpClient; calls: Array<{ method: string; param
       if (method === 'Network.getCookies') return { cookies: COOKIES };
       if (method === 'Runtime.evaluate') {
         const expr = (params as { expression: string }).expression;
-        if (expr.includes('Object.entries(localStorage)')) return { result: { value: '{"k":"v"}' } };
-        if (expr.includes('Object.entries(sessionStorage)')) return { result: { value: '{"s":"1"}' } };
+        if (expr.includes('Object.entries(localStorage)'))
+          return { result: { value: '{"k":"v"}' } };
+        if (expr.includes('Object.entries(sessionStorage)'))
+          return { result: { value: '{"s":"1"}' } };
       }
       return {};
     }),
@@ -69,7 +69,7 @@ describe('validateSessionName (via saveSession/loadSession)', () => {
   for (const [label, name] of bad) {
     it(`rejects ${label}`, async () => {
       await expect(saveSession(client, 'S1', 'T1', name, 'https://x.test', 'T')).rejects.toThrow(
-        /Invalid session name/
+        /Invalid session name/,
       );
       await expect(loadSession(client, 'S1', name)).rejects.toThrow(/Invalid session name/);
     });
@@ -77,7 +77,7 @@ describe('validateSessionName (via saveSession/loadSession)', () => {
 
   it('accepts an ordinary name (fails later, on the missing file, not on validation)', async () => {
     await expect(loadSession(client, 'S1', 'no-such-session-xyz')).rejects.toThrow(
-      'Session not found: no-such-session-xyz'
+      'Session not found: no-such-session-xyz',
     );
   });
 
@@ -103,7 +103,7 @@ describe('validateFilePath (via saveStateFile/loadStateFile)', () => {
   for (const [label, filePath] of bad) {
     it(`rejects ${label}`, async () => {
       await expect(
-        saveStateFile(client, 'S1', 'T1', filePath, 'https://x.test', 'T')
+        saveStateFile(client, 'S1', 'T1', filePath, 'https://x.test', 'T'),
       ).rejects.toThrow(/Invalid file path/);
       await expect(loadStateFile(client, 'S1', filePath)).rejects.toThrow(/Invalid file path/);
     });
@@ -111,7 +111,9 @@ describe('validateFilePath (via saveStateFile/loadStateFile)', () => {
 
   it('allows a plain absolute path', async () => {
     const p = join(dir, 'state.json');
-    await expect(saveStateFile(client, 'S1', 'T1', p, 'https://x.test', 'T')).resolves.toBeUndefined();
+    await expect(
+      saveStateFile(client, 'S1', 'T1', p, 'https://x.test', 'T'),
+    ).resolves.toBeUndefined();
   });
 });
 
@@ -164,38 +166,41 @@ describe('state file round trip', () => {
   it('rejects a state file whose cookies field is not an array', async () => {
     const { client } = stubClient();
     const p = join(dir, 'bad.json');
-    const { writeFile } = await import('fs/promises');
+    const { writeFile } = await import('node:fs/promises');
     await writeFile(p, JSON.stringify({ cookies: { name: 'sid' } }));
     await expect(loadStateFile(client, 'S1', p)).rejects.toThrow(
-      'Invalid state file: cookies is not an array'
+      'Invalid state file: cookies is not an array',
     );
   });
 
   it('rejects a state file whose localStorage is an array rather than an object', async () => {
     const { client } = stubClient();
     const p = join(dir, 'bad2.json');
-    const { writeFile } = await import('fs/promises');
+    const { writeFile } = await import('node:fs/promises');
     await writeFile(p, JSON.stringify({ cookies: [], localStorage: ['nope'] }));
     await expect(loadStateFile(client, 'S1', p)).rejects.toThrow(
-      'Invalid state file: localStorage is not a plain object'
+      'Invalid state file: localStorage is not a plain object',
     );
   });
 
   it('rejects a state file whose sessionStorage is an array', async () => {
     const { client } = stubClient();
     const p = join(dir, 'bad3.json');
-    const { writeFile } = await import('fs/promises');
+    const { writeFile } = await import('node:fs/promises');
     await writeFile(p, JSON.stringify({ cookies: [], sessionStorage: ['nope'] }));
     await expect(loadStateFile(client, 'S1', p)).rejects.toThrow(
-      'Invalid state file: sessionStorage is not a plain object'
+      'Invalid state file: sessionStorage is not a plain object',
     );
   });
 
   it('accepts a state file with neither storage map present', async () => {
     const { client, calls } = stubClient();
     const p = join(dir, 'minimal.json');
-    const { writeFile } = await import('fs/promises');
-    await writeFile(p, JSON.stringify({ targetId: 'T', sessionId: 'S', url: '', title: '', cookies: [] }));
+    const { writeFile } = await import('node:fs/promises');
+    await writeFile(
+      p,
+      JSON.stringify({ targetId: 'T', sessionId: 'S', url: '', title: '', cookies: [] }),
+    );
     await expect(loadStateFile(client, 'S1', p)).resolves.toMatchObject({ cookies: [] });
     expect(calls.filter((c) => c.method === 'Runtime.evaluate')).toEqual([]);
   });
@@ -224,7 +229,7 @@ describe('listSessions', () => {
   it('lists only .json files, with the extension stripped', async () => {
     const sessionDir = join(dir, '.monomind', 'browser-sessions');
     await mkdir(sessionDir, { recursive: true });
-    const { writeFile } = await import('fs/promises');
+    const { writeFile } = await import('node:fs/promises');
     await writeFile(join(sessionDir, 'alpha.json'), '{}');
     await writeFile(join(sessionDir, 'beta.json'), '{}');
     await writeFile(join(sessionDir, 'notes.txt'), 'ignore me');
@@ -236,7 +241,14 @@ describe('listSessions', () => {
   it('saveSession writes into the session dir and loadSession reads it back', async () => {
     const mod = await withHome(dir);
     const saver = stubClient();
-    const filePath = await mod.saveSession(saver.client, 'S1', 'T1', 'my-session', 'https://x.test', 'T');
+    const filePath = await mod.saveSession(
+      saver.client,
+      'S1',
+      'T1',
+      'my-session',
+      'https://x.test',
+      'T',
+    );
     expect(filePath).toBe(join(dir, '.monomind', 'browser-sessions', 'my-session.json'));
     expect((await stat(filePath)).mode & 0o777).toBe(0o600);
     expect((await stat(join(dir, '.monomind', 'browser-sessions'))).mode & 0o777).toBe(0o700);