@amg555/frameforge-mcp 2.7.6 → 2.7.8

package/.agent/skills/gstack-browse/test/media-extract-unit.test.ts

@@ -1,294 +0,0 @@
-/**
- * Unit tests for browse/src/media-extract.ts — the media-discovery logic
- * shared by the `media` and `scrape` commands.
- *
- * All of extractMedia's logic lives inside the page.evaluate() callback.
- * Playwright serializes that callback to the browser, but the function itself
- * is pure over the DOM globals it touches (`document`, `getComputedStyle`),
- * so instead of exporting internals or launching a browser these tests pass a
- * fake target whose evaluate() invokes the real callback in-process against a
- * minimal mock DOM. No product code was modified.
- *
- * Globals are installed/restored inside each run (never at module scope) so
- * nothing leaks to sibling test files sharing this shard process.
- */
-import { describe, test, expect } from 'bun:test';
-import { extractMedia, type MediaResult } from '../src/media-extract';
-
-type Dom = Record<string, any[]>;
-
-/** querySelector/querySelectorAll over a selector → elements map. */
-function queryable(map: Dom) {
-  return {
-    querySelectorAll: (sel: string) => map[sel] ?? [],
-    querySelector: (sel: string) => (map[sel] ?? [])[0] ?? null,
-  };
-}
-
-const VISIBLE_RECT = { width: 100, height: 50, bottom: 400, right: 300 };
-const HIDDEN_RECT = { width: 0, height: 0, bottom: 0, right: 0 };
-
-function imgEl(overrides: Record<string, unknown> = {}, attrs: Record<string, string> = {}, rect = VISIBLE_RECT) {
-  return {
-    src: '', srcset: '', currentSrc: '', alt: '',
-    width: 0, height: 0, naturalWidth: 0, naturalHeight: 0, loading: '',
-    getAttribute: (name: string) => attrs[name] ?? null,
-    getBoundingClientRect: () => rect,
-    ...overrides,
-  };
-}
-
-function videoEl(overrides: Record<string, unknown> = {}, sources: Array<{ src?: string; type?: string }> = []) {
-  return {
-    src: '', currentSrc: '', poster: '',
-    videoWidth: 0, width: 0, videoHeight: 0, height: 0, duration: 0,
-    querySelectorAll: (sel: string) => (sel === 'source' ? sources : []),
-    ...overrides,
-  };
-}
-
-function audioEl(overrides: Record<string, unknown> = {}, source: { src?: string; type?: string } | null = null) {
-  return {
-    src: '', currentSrc: '', duration: 0,
-    querySelector: (sel: string) => (sel === 'source' ? source : null),
-    ...overrides,
-  };
-}
-
-/** An element visible only to the background-image pass (`*` + getComputedStyle). */
-function bgEl(backgroundImage: string, opts: { tagName?: string; id?: string; className?: unknown } = {}) {
-  return {
-    tagName: opts.tagName ?? 'DIV',
-    id: opts.id ?? '',
-    className: opts.className ?? '',
-    __backgroundImage: backgroundImage,
-  };
-}
-
-/**
- * Run the REAL extractMedia against a mock document. The fake target's
- * evaluate() calls the callback with its argument, exactly as Playwright does
- * in the browser — resolving `document`/`getComputedStyle` to our shims.
- */
-async function extract(
-  dom: Dom,
-  options?: Parameters<typeof extractMedia>[1],
-): Promise<MediaResult> {
-  const g = globalThis as any;
-  const savedDocument = g.document;
-  const savedGcs = g.getComputedStyle;
-  g.document = queryable(dom);
-  g.getComputedStyle = (el: any) => ({ backgroundImage: el.__backgroundImage ?? 'none' });
-  try {
-    const target = { evaluate: (fn: any, arg: any) => Promise.resolve(fn(arg)) } as any;
-    return await extractMedia(target, options);
-  } finally {
-    g.document = savedDocument;
-    g.getComputedStyle = savedGcs;
-  }
-}
-
-describe('extractMedia: images', () => {
-  test('collects attributes, dimensions, and the lazy-load data-src fallback chain', async () => {
-    const result = await extract({
-      img: [
-        imgEl({
-          src: 'https://cdn.example.com/hero.jpg',
-          srcset: 'hero-2x.jpg 2x',
-          currentSrc: 'https://cdn.example.com/hero-2x.jpg',
-          alt: 'Hero',
-          width: 640, height: 480, naturalWidth: 1280, naturalHeight: 960,
-          loading: 'lazy',
-        }, { 'data-lazy-src': 'lazy.jpg' }),
-      ],
-    });
-    expect(result.images).toHaveLength(1);
-    const img = result.images[0];
-    expect(img.index).toBe(0);
-    expect(img.src).toBe('https://cdn.example.com/hero.jpg');
-    expect(img.srcset).toBe('hero-2x.jpg 2x');
-    expect(img.currentSrc).toBe('https://cdn.example.com/hero-2x.jpg');
-    expect(img.alt).toBe('Hero');
-    expect(img.naturalWidth).toBe(1280);
-    expect(img.loading).toBe('lazy');
-    // No data-src → falls through to data-lazy-src.
-    expect(img.dataSrc).toBe('lazy.jpg');
-    expect(img.visible).toBe(true);
-    expect(result.total).toBe(1);
-  });
-
-  test('data-src wins over the later fallbacks, data-original is last', async () => {
-    const first = await extract({ img: [imgEl({}, { 'data-src': 'a.jpg', 'data-lazy-src': 'b.jpg', 'data-original': 'c.jpg' })] });
-    expect(first.images[0].dataSrc).toBe('a.jpg');
-    const last = await extract({ img: [imgEl({}, { 'data-original': 'c.jpg' })] });
-    expect(last.images[0].dataSrc).toBe('c.jpg');
-    const none = await extract({ img: [imgEl()] });
-    expect(none.images[0].dataSrc).toBe('');
-  });
-
-  test('a zero-size or fully offscreen rect marks the image not visible', async () => {
-    const result = await extract({
-      img: [
-        imgEl({}, {}, HIDDEN_RECT),
-        // Above/left of the viewport: bottom and right are negative.
-        imgEl({}, {}, { width: 10, height: 10, bottom: -5, right: -5 }),
-        imgEl({}, {}, VISIBLE_RECT),
-      ],
-    });
-    expect(result.images.map(index => index.visible)).toEqual([false, false, true]);
-  });
-});
-
-describe('extractMedia: videos', () => {
-  test('detects HLS from either the mime type or an .m3u8 source URL', async () => {
-    const result = await extract({
-      video: [
-        videoEl({}, [{ src: 'https://v.example.com/stream.m3u8', type: '' }]),
-        videoEl({}, [{ src: 'https://v.example.com/stream', type: 'application/x-mpegURL' }]),
-        videoEl({ src: 'plain.mp4' }, [{ src: 'plain.mp4', type: 'video/mp4' }]),
-      ],
-    });
-    expect(result.videos.map(v => v.isHLS)).toEqual([true, true, false]);
-    expect(result.videos[2].type).toBe('video/mp4');
-  });
-
-  test('detects DASH from either the mime type or an .mpd source URL', async () => {
-    const result = await extract({
-      video: [
-        videoEl({}, [{ src: 'https://v.example.com/manifest.mpd', type: '' }]),
-        videoEl({}, [{ src: 'https://v.example.com/manifest', type: 'application/dash+xml' }]),
-      ],
-    });
-    expect(result.videos.map(v => v.isDASH)).toEqual([true, true]);
-  });
-
-  test('an Infinity duration (live stream) is reported as 0; intrinsic size beats attributes', async () => {
-    const result = await extract({
-      video: [videoEl({ duration: Infinity, videoWidth: 1920, width: 640, videoHeight: 1080, height: 360 })],
-    });
-    expect(result.videos[0].duration).toBe(0);
-    expect(result.videos[0].width).toBe(1920);
-    expect(result.videos[0].height).toBe(1080);
-  });
-
-  test('collects every <source> child with src and type', async () => {
-    const sources = [
-      { src: 'a.webm', type: 'video/webm' },
-      { src: 'a.mp4', type: 'video/mp4' },
-    ];
-    const result = await extract({ video: [videoEl({ poster: 'poster.jpg' }, sources)] });
-    expect(result.videos[0].sources).toEqual(sources);
-    expect(result.videos[0].poster).toBe('poster.jpg');
-    expect(result.videos[0].type).toBe('video/webm'); // first source's type
-  });
-});
-
-describe('extractMedia: audio', () => {
-  test('falls back to the <source> child when the element has no src, NaN duration → 0', async () => {
-    const result = await extract({
-      audio: [audioEl({ duration: NaN }, { src: 'track.ogg', type: 'audio/ogg' })],
-    });
-    expect(result.audio[0].src).toBe('track.ogg');
-    expect(result.audio[0].type).toBe('audio/ogg');
-    expect(result.audio[0].duration).toBe(0);
-  });
-
-  test('element src wins over the source child', async () => {
-    const result = await extract({
-      audio: [audioEl({ src: 'direct.mp3', duration: 12.5 }, { src: 'child.ogg', type: 'audio/ogg' })],
-    });
-    expect(result.audio[0].src).toBe('direct.mp3');
-    expect(result.audio[0].duration).toBe(12.5);
-  });
-});
-
-describe('extractMedia: CSS background images', () => {
-  test('parses url(...) in quoted and unquoted forms, skipping none and data: URIs', async () => {
-    const result = await extract({
-      '*': [
-        bgEl('url("https://cdn.example.com/bg.png")'),
-        bgEl("url('https://cdn.example.com/bg2.png')"),
-        bgEl('url(https://cdn.example.com/bg3.png)'),
-        bgEl('none'),
-        bgEl('url(data:image/png;base64,AAAA)'),
-      ],
-    });
-    expect(result.backgroundImages.map(b => b.url)).toEqual([
-      'https://cdn.example.com/bg.png',
-      'https://cdn.example.com/bg2.png',
-      'https://cdn.example.com/bg3.png',
-    ]);
-    expect(result.backgroundImages.map(b => b.index)).toEqual([0, 1, 2]);
-  });
-
-  test('builds a tag#id.class selector; a non-string className (SVG) contributes no class part', async () => {
-    const result = await extract({
-      '*': [
-        bgEl('url(a.png)', { tagName: 'SECTION', id: 'hero', className: ' banner  large ' }),
-        bgEl('url(b.png)', { tagName: 'SVG', className: { baseVal: 'svg-class' } }),
-      ],
-    });
-    expect(result.backgroundImages[0].selector).toBe('section#hero.banner.large');
-    expect(result.backgroundImages[0].element).toBe('section');
-    expect(result.backgroundImages[1].selector).toBe('svg');
-  });
-
-  test('caps background-image extraction at 500 elements', async () => {
-    const many = Array.from({ length: 520 }, (_, i) => bgEl(`url(bg-${i}.png)`));
-    const result = await extract({ '*': many });
-    expect(result.backgroundImages).toHaveLength(500);
-    expect(result.backgroundImages[499].url).toBe('bg-499.png');
-    expect(result.total).toBe(500);
-  });
-});
-
-describe('extractMedia: filter and scope options', () => {
-  const FULL_DOM: Dom = {
-    img: [imgEl({ src: 'i.png' })],
-    video: [videoEl({ src: 'v.mp4' })],
-    audio: [audioEl({ src: 'a.mp3' })],
-    '*': [bgEl('url(bg.png)')],
-  };
-
-  test('no filter returns every category and total sums them', async () => {
-    const result = await extract(FULL_DOM);
-    expect(result.images).toHaveLength(1);
-    expect(result.videos).toHaveLength(1);
-    expect(result.audio).toHaveLength(1);
-    expect(result.backgroundImages).toHaveLength(1);
-    expect(result.total).toBe(4);
-  });
-
-  test("filter: 'videos' excludes images, audio, and background images", async () => {
-    const result = await extract(FULL_DOM, { filter: 'videos' });
-    expect(result.videos).toHaveLength(1);
-    expect(result.images).toEqual([]);
-    expect(result.audio).toEqual([]);
-    expect(result.backgroundImages).toEqual([]);
-    expect(result.total).toBe(1);
-  });
-
-  test("filter: 'images' includes background images (they are image media)", async () => {
-    const result = await extract(FULL_DOM, { filter: 'images' });
-    expect(result.images).toHaveLength(1);
-    expect(result.backgroundImages).toHaveLength(1);
-    expect(result.videos).toEqual([]);
-    expect(result.audio).toEqual([]);
-    expect(result.total).toBe(2);
-  });
-
-  test('a selector scopes extraction to the matching subtree', async () => {
-    const scoped = {
-      ...queryable({ img: [imgEl({ src: 'scoped.png' })] }),
-    };
-    const result = await extract({ img: [imgEl({ src: 'global.png' })], '#gallery': [scoped] }, { selector: '#gallery' });
-    expect(result.images).toHaveLength(1);
-    expect(result.images[0].src).toBe('scoped.png');
-  });
-
-  test('a selector matching nothing falls back to the whole document', async () => {
-    const result = await extract({ img: [imgEl({ src: 'global.png' })] }, { selector: '#missing' });
-    expect(result.images).toHaveLength(1);
-    expect(result.images[0].src).toBe('global.png');
-  });
-});

package/.agent/skills/gstack-browse/test/memory-command.test.ts

@@ -1,219 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { formatBytes, type MemorySnapshot, type MemoryStructureStats } from '../src/memory-snapshot';
-
-// Unit coverage for the $B memory diagnostic surface — formatter, byte
-// renderer, and the structures-stats aggregator. The integration path
-// ($B memory through the BrowserManager → CDP) requires a real headless
-// Chromium and is covered indirectly by browse-basic in the eval suite.
-// These tests pin the renderer logic in isolation so format regressions
-// (rounded GB drift, missing "and N more" tail, snapshot.notes ordering)
-// surface immediately.
-
-// ─── formatBytes() ─────────────────────────────────────────────
-
-describe('formatBytes', () => {
-  test('1. < 1 KB renders as bytes', () => {
-    expect(formatBytes(0)).toBe('0 B');
-    expect(formatBytes(1)).toBe('1 B');
-    expect(formatBytes(1023)).toBe('1023 B');
-  });
-
-  test('2. KB tier (1024 ... 1024^2-1)', () => {
-    expect(formatBytes(1024)).toBe('1.0 KB');
-    expect(formatBytes(1536)).toBe('1.5 KB');
-    expect(formatBytes(1024 * 1024 - 1)).toMatch(/^1024\.0 KB$|^1023\.\d KB$/);
-  });
-
-  test('3. MB tier', () => {
-    expect(formatBytes(1024 * 1024)).toBe('1.0 MB');
-    expect(formatBytes(312 * 1024 * 1024)).toBe('312.0 MB');
-  });
-
-  test('4. GB tier renders with 2 decimals', () => {
-    expect(formatBytes(1024 * 1024 * 1024)).toBe('1.00 GB');
-    expect(formatBytes(1.4 * 1024 * 1024 * 1024)).toMatch(/^1\.40 GB$/);
-    // 160.61 GB — the friend's OOM number from the original screenshot.
-    // Verify the renderer doesn't blow up at the actual leak scale.
-    const big = 160.61 * 1024 * 1024 * 1024;
-    expect(formatBytes(big)).toMatch(/^160\.6\d GB$/);
-  });
-
-  test('5. negative input behavior — coerces to bytes path (best-effort, do not throw)', () => {
-    // Diagnostic should never crash on a weird CDP reading; render
-    // something reasonable.
-    expect(() => formatBytes(-1)).not.toThrow();
-  });
-});
-
-// ─── handleMemoryCommand text + json output ────────────────────
-
-// Build a minimal MemorySnapshot fixture exercising every render branch.
-// This is what bm.getMemorySnapshot would return; we stub the BrowserManager
-// so the test never spins up real Chromium.
-function makeStructureStats(): MemoryStructureStats {
-  return {
-    modificationHistory: { current: 42, cap: 200, evicted: 0 },
-    activitySubscribers: 1,
-    inspectorSubscribers: 0,
-    consoleBufferLen: 1842,
-    networkBufferLen: 12000,
-    dialogBufferLen: 3,
-    captureBufferBytes: 0,
-  };
-}
-
-function makeSnapshot(overrides: Partial<MemorySnapshot> = {}): MemorySnapshot {
-  return {
-    bunServer: {
-      rss: 312 * 1024 * 1024,
-      heapUsed: 84 * 1024 * 1024,
-      heapTotal: 120 * 1024 * 1024,
-      external: 21 * 1024 * 1024,
-    },
-    tabs: [],
-    processes: null,
-    structures: makeStructureStats(),
-    capturedAt: 1700000000000,
-    notes: [],
-    ...overrides,
-  };
-}
-
-// Mock BrowserManager surface for handleMemoryCommand. Only
-// getMemorySnapshot is touched.
-function makeFakeBm(snapshot: MemorySnapshot) {
-  return {
-    getMemorySnapshot: async (structures: MemoryStructureStats) => ({
-      ...snapshot,
-      structures,
-    }),
-  } as unknown as import('../src/browser-manager').BrowserManager;
-}
-
-describe('handleMemoryCommand', () => {
-  test('6. --json mode emits parseable JSON with bunServer + structures', async () => {
-    const { handleMemoryCommand } = await import('../src/memory-command');
-    const snapshot = makeSnapshot();
-    const result = await handleMemoryCommand(['--json'], makeFakeBm(snapshot));
-    const parsed = JSON.parse(result);
-    expect(parsed.bunServer.rss).toBe(312 * 1024 * 1024);
-    expect(parsed.structures).toBeDefined();
-    expect(parsed.structures.modificationHistory.cap).toBe(200);
-  });
-
-  test('7. text mode renders Bun server line with RSS + heap', async () => {
-    const { handleMemoryCommand } = await import('../src/memory-command');
-    const result = await handleMemoryCommand([], makeFakeBm(makeSnapshot()));
-    expect(result).toContain('Bun server:');
-    expect(result).toContain('312.0 MB');
-    expect(result).toContain('84.0 MB');
-  });
-
-  test('8. text mode renders "no tabs tracked" when tabs array is empty', async () => {
-    const { handleMemoryCommand } = await import('../src/memory-command');
-    const result = await handleMemoryCommand([], makeFakeBm(makeSnapshot({ tabs: [] })));
-    expect(result).toContain('Renderers:');
-    expect(result).toContain('(no tabs tracked)');
-  });
-
-  test('9. text mode shows top 10 tabs + "...and N more" tail when > 10', async () => {
-    const { handleMemoryCommand } = await import('../src/memory-command');
-    const tabs = Array.from({ length: 15 }, (_, i) => ({
-      id: i,
-      url: `https://example.com/tab${i}`,
-      title: `Tab ${i}`,
-      jsHeapUsed: (15 - i) * 50 * 1024 * 1024, // descending so sort matters
-      jsHeapTotal: (15 - i) * 60 * 1024 * 1024,
-      documents: 1,
-      nodes: 100,
-      listeners: 10,
-    }));
-    const result = await handleMemoryCommand([], makeFakeBm(makeSnapshot({ tabs })));
-    expect(result).toContain('Renderers:         15 tabs');
-    expect(result).toContain('and 5 more');
-    // Sorted by JS heap descending — tab 0 (largest) should appear before tab 9
-    expect(result.indexOf('tab #0 —')).toBeLessThan(result.indexOf('tab #9 —'));
-  });
-
-  test('10. text mode renders Chromium processes grouped by type', async () => {
-    const { handleMemoryCommand } = await import('../src/memory-command');
-    const snapshot = makeSnapshot({
-      processes: [
-        { id: 1, type: 'browser', cpuTime: 1.5 },
-        { id: 2, type: 'renderer', cpuTime: 3.2 },
-        { id: 3, type: 'renderer', cpuTime: 2.1 },
-        { id: 4, type: 'gpu', cpuTime: 0.5 },
-      ],
-    });
-    const result = await handleMemoryCommand([], makeFakeBm(snapshot));
-    expect(result).toContain('Chromium processes: 4 total');
-    expect(result).toContain('renderer=2');
-    expect(result).toContain('browser=1');
-    expect(result).toContain('gpu=1');
-  });
-
-  test('11. text mode renders "unavailable" line when processes is null', async () => {
-    const { handleMemoryCommand } = await import('../src/memory-command');
-    const result = await handleMemoryCommand([], makeFakeBm(makeSnapshot({ processes: null })));
-    expect(result).toContain('Chromium processes: (unavailable — see notes)');
-  });
-
-  test('13. text mode renders modificationHistory line shape', async () => {
-    const { handleMemoryCommand } = await import('../src/memory-command');
-    const result = await handleMemoryCommand([], makeFakeBm(makeSnapshot()));
-    // collectStructureStats reads live module state; values may be 0 in
-    // the test env. Verify the LINE SHAPE rather than specific numbers.
-    expect(result).toMatch(/modificationHistory:\s+\d+ \/ \d+ entries/);
-  });
-
-  test('14. text mode prints notes section when notes are present', async () => {
-    const { handleMemoryCommand } = await import('../src/memory-command');
-    const snapshot = makeSnapshot({
-      notes: ['Per-Chromium-process RSS not collected — CDP limitation.'],
-    });
-    const result = await handleMemoryCommand([], makeFakeBm(snapshot));
-    expect(result).toContain('Notes:');
-    expect(result).toContain('CDP limitation.');
-  });
-
-  test('15. text mode omits notes section when notes is empty', async () => {
-    const { handleMemoryCommand } = await import('../src/memory-command');
-    const result = await handleMemoryCommand([], makeFakeBm(makeSnapshot({ notes: [] })));
-    expect(result).not.toContain('Notes:');
-  });
-
-  test('16. text mode truncates long tab URLs with ellipsis', async () => {
-    const { handleMemoryCommand } = await import('../src/memory-command');
-    const longUrl = 'https://example.com/' + 'a'.repeat(120);
-    const tabs = [{
-      id: 1,
-      url: longUrl,
-      title: 'long',
-      jsHeapUsed: 1024,
-      jsHeapTotal: 2048,
-      documents: 1,
-      nodes: 10,
-      listeners: 1,
-    }];
-    const result = await handleMemoryCommand([], makeFakeBm(makeSnapshot({ tabs })));
-    expect(result).toContain('...');
-    // The truncated URL appears, the full URL does not
-    expect(result.includes(longUrl)).toBe(false);
-  });
-});
-
-// ─── buildMemorySnapshotJson — server-endpoint entry ──────────
-
-describe('buildMemorySnapshotJson', () => {
-  test('17. returns the snapshot with structures populated', async () => {
-    const { buildMemorySnapshotJson } = await import('../src/memory-command');
-    const snapshot = makeSnapshot();
-    const result = await buildMemorySnapshotJson(makeFakeBm(snapshot));
-    expect(result.bunServer.rss).toBe(snapshot.bunServer.rss);
-    expect(result.structures.modificationHistory.cap).toBe(200);
-    // structures is populated from live module accessors, not from the
-    // fixture. Just assert the shape is right.
-    expect(typeof result.structures.consoleBufferLen).toBe('number');
-    expect(typeof result.structures.networkBufferLen).toBe('number');
-  });
-});

package/.agent/skills/gstack-browse/test/memory-leak-reproducer.test.ts

@@ -1,133 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { BrowserManager } from '../src/browser-manager';
-import { networkBuffer } from '../src/buffers';
-
-// Reproducer for the body-materialization leak fixed in the D10
-// USE_CDP_EVENT_BATCHED commit. Pre-fix, the wirePageEvents
-// `requestfinished` listener called `await res.body()` just to read
-// `.length`, allocating the full response body into a Bun Buffer on
-// every request — multi-GB/hour of churn on long-lived headed
-// Chromium with media-heavy pages.
-//
-// What this test pins:
-//   - The handler calls Playwright's structured req.sizes() API
-//     (which pulls from Network.loadingFinished without
-//     materializing the body).
-//   - The handler NEVER calls res.body(), even though a fake response
-//     exposes the method.
-//   - networkBuffer entries are still populated with the right size.
-//
-// What this test does NOT cover:
-//   - A real Chromium burst measuring peak Bun RSS during concurrent
-//     fetches. That's a periodic-tier test (browse/test/
-//     memory-leak-reproducer-e2e.test.ts, deferred — see TODOS).
-//   - Per-tab JS heap growth on the Chromium side. Outside Bun's
-//     visibility entirely.
-//
-// Wall clock target: < 1 second. Gate tier.
-
-interface CallCounters {
-  sizes: number;
-  body: number;
-}
-
-function makeFakeReq(url: string, responseBodySize: number, counters: CallCounters) {
-  return {
-    url: () => url,
-    sizes: async () => {
-      counters.sizes++;
-      return {
-        requestBodySize: 0,
-        requestHeadersSize: 100,
-        responseBodySize,
-        responseHeadersSize: 200,
-      };
-    },
-    method: () => 'GET',
-    response: async () => ({
-      url: () => url,
-      status: () => 200,
-      body: async () => {
-        // If THIS runs, the leak is back. Allocate a real Buffer so a
-        // future reviewer reading the failing assertion sees what
-        // pre-fix code was doing on every request.
-        counters.body++;
-        return Buffer.alloc(responseBodySize);
-      },
-    }),
-  };
-}
-
-interface ListenerMap {
-  [event: string]: Array<(arg: unknown) => void>;
-}
-
-function makeFakePage() {
-  const listeners: ListenerMap = {};
-  return {
-    on(event: string, fn: (arg: unknown) => void): void {
-      (listeners[event] ||= []).push(fn);
-    },
-    emit(event: string, arg: unknown): void {
-      for (const fn of listeners[event] || []) fn(arg);
-    },
-    listenerCount(event: string): number {
-      return (listeners[event] || []).length;
-    },
-  };
-}
-
-describe('memory-leak reproducer: requestfinished does not materialize bodies', () => {
-  test('burst of 200 requestfinished events calls req.sizes() but never res.body()', async () => {
-    const bm = new BrowserManager();
-    const page = makeFakePage();
-
-    // wirePageEvents is private — access via the same indexed pattern the
-    // tab-guardrail test uses to drive private methods.
-    const wirePageEvents = (
-      bm as unknown as { wirePageEvents: (p: unknown) => void }
-    ).wirePageEvents.bind(bm);
-    wirePageEvents(page);
-
-    // Seed networkBuffer with 200 request entries via the existing
-    // page.on('request') handler so the requestfinished backward-scan
-    // has something to match against.
-    const startLen = networkBuffer.length;
-    for (let i = 0; i < 200; i++) {
-      page.emit('request', {
-        url: () => `https://example.invalid/asset/${i}`,
-        method: () => 'GET',
-        isNavigationRequest: () => false,
-      });
-    }
-
-    // Fire 200 requestfinished events concurrently. Each notional response
-    // is 1 MB — pre-fix this would allocate 200 MB of Buffer. With the fix,
-    // not one byte of body content is allocated.
-    const counters: CallCounters = { sizes: 0, body: 0 };
-    const reqs = Array.from({ length: 200 }, (_, i) =>
-      makeFakeReq(`https://example.invalid/asset/${i}`, 1024 * 1024, counters),
-    );
-    for (const req of reqs) page.emit('requestfinished', req);
-
-    // Drain the async handler chain — wirePageEvents.requestfinished is
-    // async; each emit kicks off a microtask that awaits req.sizes().
-    await new Promise((r) => setTimeout(r, 50));
-    // One more tick in case of cascading microtasks.
-    await new Promise((r) => setTimeout(r, 0));
-
-    // Every event hit req.sizes().
-    expect(counters.sizes).toBeGreaterThanOrEqual(200);
-    // The actual leak fix: res.body() is NEVER called.
-    expect(counters.body).toBe(0);
-    // And the size data still made it into networkBuffer.
-    const populated = Array.from({ length: networkBuffer.length }, (_, i) =>
-      networkBuffer.get(i),
-    )
-      .filter((e) => e && e.url?.startsWith('https://example.invalid/asset/'))
-      .filter((e) => typeof e?.size === 'number' && e.size > 0).length;
-    expect(populated).toBeGreaterThanOrEqual(200);
-    // Sanity: the seed didn't double-count from a previous run.
-    expect(networkBuffer.length).toBeGreaterThan(startLen);
-  });
-});