@hyperframes/engine 0.6.119 → 0.6.120

package/src/services/audioVolumeEnvelope.test.ts

@@ -1,176 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { applyVolumeEnvelopeToWav } from "./audioVolumeEnvelope.js";
-
-const SAMPLE_RATE = 48000;
-const CHANNELS = 2;
-
-/** Build a PCM s16le stereo WAV whose every sample equals `value`. */
-function writeConstantWav(path: string, frames: number, value: number): void {
-  const bytesPerSample = 2;
-  const dataSize = frames * CHANNELS * bytesPerSample;
-  const buffer = Buffer.alloc(44 + dataSize);
-  buffer.write("RIFF", 0, "ascii");
-  buffer.writeUInt32LE(36 + dataSize, 4);
-  buffer.write("WAVE", 8, "ascii");
-  buffer.write("fmt ", 12, "ascii");
-  buffer.writeUInt32LE(16, 16);
-  buffer.writeUInt16LE(1, 20); // PCM
-  buffer.writeUInt16LE(CHANNELS, 22);
-  buffer.writeUInt32LE(SAMPLE_RATE, 24);
-  buffer.writeUInt32LE(SAMPLE_RATE * CHANNELS * bytesPerSample, 28);
-  buffer.writeUInt16LE(CHANNELS * bytesPerSample, 32);
-  buffer.writeUInt16LE(16, 34);
-  buffer.write("data", 36, "ascii");
-  buffer.writeUInt32LE(dataSize, 40);
-  for (let i = 0; i < frames * CHANNELS; i += 1) buffer.writeInt16LE(value, 44 + i * 2);
-  writeFileSync(path, buffer);
-}
-
-function sampleAt(path: string, frame: number, channel = 0): number {
-  const buffer = readFileSync(path);
-  return buffer.readInt16LE(44 + (frame * CHANNELS + channel) * 2);
-}
-
-describe("applyVolumeEnvelopeToWav", () => {
-  const dirs: string[] = [];
-  const tmp = () => {
-    const d = mkdtempSync(join(tmpdir(), "hf-env-"));
-    dirs.push(d);
-    return d;
-  };
-  afterEach(() => {
-    for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });
-  });
-
-  it("applies a linear fade sample-accurately", () => {
-    const path = join(tmp(), "a.wav");
-    const frames = SAMPLE_RATE; // 1 second
-    writeConstantWav(path, frames, 10000);
-
-    // Fade 0 -> 1 over the full second.
-    const applied = applyVolumeEnvelopeToWav(
-      path,
-      [
-        { time: 0, volume: 0 },
-        { time: 1, volume: 1 },
-      ],
-      0,
-      0,
-    );
-    expect(applied).toBe(true);
-
-    expect(sampleAt(path, 0)).toBe(0); // gain 0
-    expect(sampleAt(path, frames / 2)).toBeCloseTo(5000, -2); // gain ~0.5
-    expect(sampleAt(path, frames - 1)).toBeGreaterThan(9900); // gain ~1
-  });
-
-  it("offsets keyframes by the track start (composition time -> track-relative)", () => {
-    const path = join(tmp(), "b.wav");
-    const frames = SAMPLE_RATE;
-    writeConstantWav(path, frames, 10000);
-
-    // Track starts at 5s; the fade runs from comp-time 5s..6s -> wav 0s..1s.
-    applyVolumeEnvelopeToWav(
-      path,
-      [
-        { time: 5, volume: 0 },
-        { time: 6, volume: 1 },
-      ],
-      5,
-      0,
-    );
-
-    expect(sampleAt(path, 0)).toBe(0);
-    expect(sampleAt(path, frames / 2)).toBeCloseTo(5000, -2);
-  });
-
-  it("holds base volume before the first keyframe and the last value after", () => {
-    const path = join(tmp(), "c.wav");
-    const frames = SAMPLE_RATE * 3; // 3 seconds
-    writeConstantWav(path, frames, 10000);
-
-    // Base 0.8 held until a fade-out begins at 2s.
-    applyVolumeEnvelopeToWav(
-      path,
-      [
-        { time: 2, volume: 0.8 },
-        { time: 3, volume: 0 },
-      ],
-      0,
-      0.8,
-    );
-
-    expect(sampleAt(path, SAMPLE_RATE)).toBeCloseTo(8000, -2); // 1s: base 0.8
-    expect(sampleAt(path, frames - 1)).toBeLessThan(200); // 3s: faded to ~0
-  });
-
-  it("handles thousands of keyframes without failing (no expression ceiling)", () => {
-    const path = join(tmp(), "d.wav");
-    const frames = SAMPLE_RATE * 2;
-    writeConstantWav(path, frames, 10000);
-
-    const keyframes = Array.from({ length: 5000 }, (_, i) => ({
-      time: (i / 4999) * 2,
-      volume: Math.abs(Math.sin(i / 50)),
-    }));
-    expect(applyVolumeEnvelopeToWav(path, keyframes, 0, 0)).toBe(true);
-  });
-
-  it("parses chunks in any order (data before fmt)", () => {
-    const path = join(tmp(), "order.wav");
-    const frames = 4;
-    const dataSize = frames * CHANNELS * 2;
-    // Lay the data chunk before fmt to exercise order-independent scanning.
-    const buffer = Buffer.alloc(12 + (8 + dataSize) + (8 + 16));
-    buffer.write("RIFF", 0, "ascii");
-    buffer.writeUInt32LE(buffer.length - 8, 4);
-    buffer.write("WAVE", 8, "ascii");
-    let o = 12;
-    buffer.write("data", o, "ascii");
-    buffer.writeUInt32LE(dataSize, o + 4);
-    for (let i = 0; i < frames * CHANNELS; i += 1) buffer.writeInt16LE(10000, o + 8 + i * 2);
-    o += 8 + dataSize;
-    buffer.write("fmt ", o, "ascii");
-    buffer.writeUInt32LE(16, o + 4);
-    buffer.writeUInt16LE(1, o + 8);
-    buffer.writeUInt16LE(CHANNELS, o + 10);
-    buffer.writeUInt32LE(SAMPLE_RATE, o + 12);
-    buffer.writeUInt16LE(16, o + 22);
-    writeFileSync(path, buffer);
-
-    expect(applyVolumeEnvelopeToWav(path, [{ time: 0, volume: 0 }], 0, 0)).toBe(true);
-    expect(readFileSync(path).readInt16LE(12 + 8)).toBe(0); // first sample muted
-  });
-
-  it("rejects non-16-bit PCM so the caller can fall back", () => {
-    const path = join(tmp(), "e.wav");
-    // 24-bit PCM header (bitsPerSample = 24); body contents are irrelevant.
-    const buffer = Buffer.alloc(44);
-    buffer.write("RIFF", 0, "ascii");
-    buffer.write("WAVE", 8, "ascii");
-    buffer.write("fmt ", 12, "ascii");
-    buffer.writeUInt32LE(16, 16);
-    buffer.writeUInt16LE(1, 20);
-    buffer.writeUInt16LE(CHANNELS, 22);
-    buffer.writeUInt32LE(SAMPLE_RATE, 24);
-    buffer.writeUInt16LE(24, 34);
-    buffer.write("data", 36, "ascii");
-    buffer.writeUInt32LE(0, 40);
-    writeFileSync(path, buffer);
-
-    expect(
-      applyVolumeEnvelopeToWav(
-        path,
-        [
-          { time: 0, volume: 0 },
-          { time: 1, volume: 1 },
-        ],
-        0,
-        0,
-      ),
-    ).toBe(false);
-  });
-});

package/src/services/audioVolumeEnvelope.ts

@@ -1,138 +0,0 @@
-/**
- * Sample-accurate volume automation.
- *
- * The audio mixer's primary path for time-varying volume bakes the envelope
- * directly into the prepared PCM rather than encoding it as an FFmpeg `volume`
- * expression. The expression approach nests one `if(lt(t,...))` per keyframe and
- * overflows FFmpeg's expression evaluator past ~95 levels (a dense GSAP fade
- * emits hundreds of keyframes), which fails the whole mix and drops the audio
- * track. Multiplying the samples in-house has no such ceiling, is exact at every
- * sample, and keeps the downstream ffmpeg `amix`/AAC encode untouched — so the
- * output (and the golden baselines) only change where a fade is actually applied.
- *
- * The prepared tracks are always `pcm_s16le`, 48 kHz, stereo (see
- * `prepareAudioTrack` / `extractAudioFromVideo`). Anything else is rejected so
- * the caller can fall back to the expression path rather than corrupting audio.
- */
-
-import { readFileSync, renameSync, writeFileSync } from "fs";
-import { randomBytes } from "crypto";
-import type { AudioVolumeKeyframe } from "./audioMixer.types.js";
-import { normaliseEnvelope } from "@hyperframes/core/media-volume-envelope";
-
-const PCM_FORMAT = 1; // WAVE_FORMAT_PCM
-const SUPPORTED_BITS = 16;
-
-interface WavLayout {
-  numChannels: number;
-  sampleRate: number;
-  dataOffset: number;
-  dataSize: number;
-}
-
-/**
- * Locate the `fmt ` and `data` chunks and validate the format we know how to edit.
- *
- * Scans every chunk rather than assuming an ordering: the loop always advances
- * past a chunk's body (using its declared size), so `data` may precede `fmt `
- * and trailing chunks (LIST/fact/etc.) are skipped harmlessly. Returns null on
- * anything unexpected so the caller falls back to the expression path.
- */
-function parseWavLayout(buffer: Buffer): WavLayout | null {
-  if (buffer.length < 12 || buffer.toString("ascii", 0, 4) !== "RIFF") return null;
-  if (buffer.toString("ascii", 8, 12) !== "WAVE") return null;
-
-  let offset = 12;
-  let fmt: { numChannels: number; sampleRate: number; bitsPerSample: number } | null = null;
-  let data: { offset: number; size: number } | null = null;
-
-  while (offset + 8 <= buffer.length) {
-    const chunkId = buffer.toString("ascii", offset, offset + 4);
-    const chunkSize = buffer.readUInt32LE(offset + 4);
-    const body = offset + 8;
-    if (chunkId === "fmt " && body + 16 <= buffer.length) {
-      if (buffer.readUInt16LE(body) !== PCM_FORMAT) return null;
-      fmt = {
-        numChannels: buffer.readUInt16LE(body + 2),
-        sampleRate: buffer.readUInt32LE(body + 4),
-        bitsPerSample: buffer.readUInt16LE(body + 14),
-      };
-    } else if (chunkId === "data") {
-      data = { offset: body, size: Math.min(chunkSize, buffer.length - body) };
-    }
-    // Chunks are word-aligned: an odd size carries a trailing pad byte.
-    offset = body + chunkSize + (chunkSize % 2);
-  }
-
-  if (!fmt || !data) return null;
-  if (fmt.bitsPerSample !== SUPPORTED_BITS || fmt.numChannels < 1) return null;
-  return {
-    numChannels: fmt.numChannels,
-    sampleRate: fmt.sampleRate,
-    dataOffset: data.offset,
-    dataSize: data.size,
-  };
-}
-
-/**
- * Multiply a prepared WAV's samples by a time-varying gain envelope in place.
- *
- * @returns `true` if the envelope was applied; `false` if the file isn't the
- *   expected 16-bit PCM (caller should fall back to the expression path).
- */
-export function applyVolumeEnvelopeToWav(
-  wavPath: string,
-  keyframes: AudioVolumeKeyframe[],
-  trackStart: number,
-  baseVolume: number,
-): boolean {
-  const envelope = normaliseEnvelope(keyframes, trackStart, baseVolume);
-  if (envelope.length === 0) return false;
-
-  try {
-    const buffer = readFileSync(wavPath);
-    const layout = parseWavLayout(buffer);
-    if (!layout) return false;
-
-    const { numChannels, sampleRate, dataOffset, dataSize } = layout;
-    const bytesPerSample = SUPPORTED_BITS / 8;
-    const frameBytes = numChannels * bytesPerSample;
-    const frameCount = Math.floor(dataSize / frameBytes);
-
-    // Maintain an incremental segment cursor so the per-frame envelope lookup
-    // is O(N+M) overall, not O(N×M). interpolateVolumeGain restarts from 0 on
-    // each call — fine for the preview path (one call per RAF tick) but not for
-    // the PCM path (one call per sample, 48k×duration frames total).
-    let segment = 0;
-    for (let frame = 0; frame < frameCount; frame += 1) {
-      const time = frame / sampleRate;
-      while (segment < envelope.length - 2 && time >= envelope[segment + 1]!.time) segment += 1;
-
-      const a = envelope[segment]!;
-      const b = envelope[segment + 1] ?? a;
-      const span = b.time - a.time;
-      const progress = span <= 0 ? 0 : Math.min(1, Math.max(0, (time - a.time) / span));
-      const gain = a.volume + (b.volume - a.volume) * progress;
-
-      const base = dataOffset + frame * frameBytes;
-      for (let channel = 0; channel < numChannels; channel += 1) {
-        const at = base + channel * bytesPerSample;
-        const scaled = Math.round(buffer.readInt16LE(at) * gain);
-        buffer.writeInt16LE(scaled < -32768 ? -32768 : scaled > 32767 ? 32767 : scaled, at);
-      }
-    }
-
-    // Write to a uniquely-named sibling then atomically rename over the
-    // original. The random name avoids following a pre-planted symlink at a
-    // predictable path, and the rename means a crash mid-write can't leave a
-    // truncated WAV for the downstream mix.
-    const tempPath = `${wavPath}.${randomBytes(6).toString("hex")}.tmp`;
-    writeFileSync(tempPath, buffer);
-    renameSync(tempPath, wavPath);
-    return true;
-  } catch {
-    // Any read/parse/write failure → leave the file untouched and let the
-    // caller fall back to the ffmpeg expression path rather than losing audio.
-    return false;
-  }
-}

package/src/services/browserManager.test.ts

@@ -1,330 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { Browser, PuppeteerNode } from "puppeteer-core";
-
-import {
-  _resetAutoBrowserGpuModeCacheForTests,
-  _resetBrowserPoolForTests,
-  _setPuppeteerForTests,
-  acquireBrowser,
-  buildChromeArgs,
-  drainBrowserPool,
-  forceReleaseBrowser,
-  releaseBrowser,
-  resolveHeadlessShellPath,
-  resolveBrowserGpuMode,
-} from "./browserManager.js";
-
-describe("buildChromeArgs browser GPU mode", () => {
-  const base = { width: 1920, height: 1080 };
-
-  it("uses SwiftShader software GL by default for reproducible local renders", () => {
-    const args = buildChromeArgs(base);
-    expect(args).toContain("--enable-features=CanvasDrawElement");
-    expect(args).not.toContain("--enable-unsafe-webgpu");
-    expect(args).toContain("--use-gl=angle");
-    expect(args).toContain("--use-angle=swiftshader");
-    expect(args).toContain("--enable-unsafe-swiftshader");
-    expect(args).not.toContain("--enable-gpu-rasterization");
-  });
-
-  it("uses Metal-backed ANGLE for hardware browser GPU mode on macOS", () => {
-    const args = buildChromeArgs({ ...base, platform: "darwin" }, { browserGpuMode: "hardware" });
-    expect(args).toContain("--enable-unsafe-webgpu");
-    expect(args).toContain("--use-gl=angle");
-    expect(args).toContain("--use-angle=metal");
-    expect(args).toContain("--enable-gpu-rasterization");
-    expect(args).not.toContain("--use-angle=swiftshader");
-  });
-
-  it("uses D3D11-backed ANGLE for hardware browser GPU mode on Windows", () => {
-    const args = buildChromeArgs({ ...base, platform: "win32" }, { browserGpuMode: "hardware" });
-    expect(args).toContain("--use-gl=angle");
-    expect(args).toContain("--use-angle=d3d11");
-    expect(args).toContain("--enable-gpu-rasterization");
-    expect(args).not.toContain("--use-angle=swiftshader");
-  });
-
-  it("uses ANGLE-EGL for hardware browser GPU mode on Linux", () => {
-    const args = buildChromeArgs({ ...base, platform: "linux" }, { browserGpuMode: "hardware" });
-    expect(args).toContain("--use-gl=angle");
-    expect(args).toContain("--use-angle=gl-egl");
-    expect(args).toContain("--enable-gpu-rasterization");
-    expect(args).toContain("--ignore-gpu-blocklist");
-    expect(args).toContain("--disable-software-rasterizer");
-    expect(args).not.toContain("--use-angle=swiftshader");
-  });
-
-  it("keeps --disable-gpu authoritative when requested", () => {
-    const args = buildChromeArgs(
-      { ...base, platform: "darwin" },
-      { browserGpuMode: "hardware", disableGpu: true },
-    );
-    expect(args).toContain("--disable-gpu");
-    expect(args).toContain("--use-angle=swiftshader");
-    expect(args).not.toContain("--use-angle=metal");
-  });
-});
-
-describe("resolveBrowserGpuMode", () => {
-  beforeEach(() => {
-    _resetAutoBrowserGpuModeCacheForTests();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    _resetAutoBrowserGpuModeCacheForTests();
-  });
-
-  it("passes 'software' through unchanged without probing", async () => {
-    const mode = await resolveBrowserGpuMode("software");
-    expect(mode).toBe("software");
-  });
-
-  it("passes 'hardware' through unchanged without probing", async () => {
-    const mode = await resolveBrowserGpuMode("hardware");
-    expect(mode).toBe("hardware");
-  });
-
-  it("falls back to 'software' when the probe browser cannot launch", async () => {
-    // No chromePath, env unset, and (in the test env) no system Chrome to find
-    // → puppeteer.launch will throw → caller catches → software fallback.
-    // Force a definitely-missing chrome binary so the launch path errors fast.
-    const mode = await resolveBrowserGpuMode("auto", {
-      chromePath: "/definitely/not/a/real/chrome/binary",
-      browserTimeout: 2000,
-    });
-    expect(mode).toBe("software");
-  });
-
-  it("caches the probe result across calls", async () => {
-    const first = await resolveBrowserGpuMode("auto", {
-      chromePath: "/definitely/not/a/real/chrome/binary",
-      browserTimeout: 2000,
-    });
-    // Second call uses cache — no new launch. Assert the same answer comes back
-    // even with a different chromePath that would have a different probe outcome.
-    const second = await resolveBrowserGpuMode("auto", {
-      chromePath: "/another/definitely/missing/path",
-      browserTimeout: 2000,
-    });
-    expect(first).toBe("software");
-    expect(second).toBe("software");
-    // Reset and re-probe to confirm the test-only reset works.
-    _resetAutoBrowserGpuModeCacheForTests();
-    const third = await resolveBrowserGpuMode("hardware");
-    expect(third).toBe("hardware");
-  });
-
-  it("deduplicates concurrent auto-mode probes by caching the in-flight Promise", async () => {
-    // Parallel coordinator fires N workers via Promise.all — without Promise-
-    // level caching, a `--workers 4` render against a no-GPU host would launch
-    // 4 simultaneous probe Chromes. Verify all concurrent callers get the
-    // exact same Promise reference (proving the probe runs once, not N times).
-    const p1 = resolveBrowserGpuMode("auto", {
-      chromePath: "/definitely/not/a/real/chrome/binary",
-      browserTimeout: 2000,
-    });
-    const p2 = resolveBrowserGpuMode("auto", {
-      chromePath: "/definitely/not/a/real/chrome/binary",
-      browserTimeout: 2000,
-    });
-    const p3 = resolveBrowserGpuMode("auto", {
-      chromePath: "/definitely/not/a/real/chrome/binary",
-      browserTimeout: 2000,
-    });
-    expect(p1).toBe(p2);
-    expect(p2).toBe(p3);
-    const results = await Promise.all([p1, p2, p3]);
-    expect(results).toEqual(["software", "software", "software"]);
-  });
-});
-
-describe("resolveHeadlessShellPath", () => {
-  const originalHeadlessShellPath = process.env.PRODUCER_HEADLESS_SHELL_PATH;
-
-  afterEach(() => {
-    if (originalHeadlessShellPath === undefined) delete process.env.PRODUCER_HEADLESS_SHELL_PATH;
-    else process.env.PRODUCER_HEADLESS_SHELL_PATH = originalHeadlessShellPath;
-  });
-
-  it("throws a clear error when PRODUCER_HEADLESS_SHELL_PATH points at a missing binary", () => {
-    process.env.PRODUCER_HEADLESS_SHELL_PATH = "/missing/chrome-headless-shell.exe";
-
-    expect(() => resolveHeadlessShellPath({})).toThrow(
-      /Chrome binary not found at PRODUCER_HEADLESS_SHELL_PATH/,
-    );
-  });
-});
-
-describe("forceReleaseBrowser", () => {
-  it("kills the browser process and disconnects", () => {
-    const killFn = vi.fn(() => true);
-    const disconnectFn = vi.fn();
-    const mockBrowser = {
-      process: () => ({ kill: killFn, killed: false }),
-      disconnect: disconnectFn,
-    } as any;
-
-    forceReleaseBrowser(mockBrowser);
-
-    expect(killFn).toHaveBeenCalledWith("SIGKILL");
-    expect(disconnectFn).toHaveBeenCalled();
-  });
-
-  it("tolerates an already-killed process", () => {
-    const killFn = vi.fn();
-    const disconnectFn = vi.fn();
-    const mockBrowser = {
-      process: () => ({ kill: killFn, killed: true }),
-      disconnect: disconnectFn,
-    } as any;
-
-    forceReleaseBrowser(mockBrowser);
-
-    expect(killFn).not.toHaveBeenCalled();
-    expect(disconnectFn).toHaveBeenCalled();
-  });
-});
-
-describe("browser pool", () => {
-  function makeMockBrowser(): Browser {
-    return {
-      connected: true,
-      newPage: vi.fn(),
-      version: vi.fn().mockResolvedValue("HeadlessChrome/131.0.0.0"),
-      close: vi.fn().mockResolvedValue(undefined),
-      disconnect: vi.fn(),
-      process: () => ({ kill: vi.fn(), killed: false }),
-    } as unknown as Browser;
-  }
-
-  // forceScreenshot: true bypasses the BeginFrame probe path, which on Linux
-  // CI would trigger a second ppt.launch() when the mock's newPage() doesn't
-  // return a real page and the probe falls back to screenshot mode.
-  const poolCfg = { enableBrowserPool: true, forceScreenshot: true } as const;
-
-  let launchFn: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    _resetBrowserPoolForTests();
-    const mockBrowser = makeMockBrowser();
-    launchFn = vi.fn().mockResolvedValue(mockBrowser);
-    _setPuppeteerForTests({ launch: launchFn } as unknown as PuppeteerNode);
-  });
-
-  afterEach(async () => {
-    await drainBrowserPool();
-    _setPuppeteerForTests(undefined);
-  });
-
-  it("sequential acquires with pool enabled return the same browser", async () => {
-    const first = await acquireBrowser(["--no-sandbox"], poolCfg);
-    const second = await acquireBrowser(["--no-sandbox"], poolCfg);
-
-    expect(first.browser).toBe(second.browser);
-    expect(launchFn).toHaveBeenCalledTimes(1);
-
-    await releaseBrowser(first.browser, poolCfg);
-    await releaseBrowser(second.browser, poolCfg);
-  });
-
-  it("concurrent acquires via Promise.all trigger exactly one launch", async () => {
-    const [a, b, c] = await Promise.all([
-      acquireBrowser(["--no-sandbox"], poolCfg),
-      acquireBrowser(["--no-sandbox"], poolCfg),
-      acquireBrowser(["--no-sandbox"], poolCfg),
-    ]);
-
-    expect(launchFn).toHaveBeenCalledTimes(1);
-    expect(a.browser).toBe(b.browser);
-    expect(b.browser).toBe(c.browser);
-
-    await releaseBrowser(a.browser, poolCfg);
-    await releaseBrowser(b.browser, poolCfg);
-    await releaseBrowser(c.browser, poolCfg);
-  });
-
-  it("pool recovers from a disconnected browser", async () => {
-    const first = await acquireBrowser(["--no-sandbox"], poolCfg);
-    await releaseBrowser(first.browser, poolCfg);
-
-    // Simulate Chrome crash
-    (first.browser as unknown as { connected: boolean }).connected = false;
-
-    const freshBrowser = makeMockBrowser();
-    launchFn.mockResolvedValue(freshBrowser);
-
-    const second = await acquireBrowser(["--no-sandbox"], poolCfg);
-    expect(second.browser).toBe(freshBrowser);
-    expect(second.browser).not.toBe(first.browser);
-    expect(launchFn).toHaveBeenCalledTimes(2);
-
-    await releaseBrowser(second.browser, poolCfg);
-  });
-
-  it("release at refCount 0 closes the browser", async () => {
-    const result = await acquireBrowser(["--no-sandbox"], poolCfg);
-    const closeFn = result.browser.close as ReturnType<typeof vi.fn>;
-
-    await releaseBrowser(result.browser, poolCfg);
-    expect(closeFn).toHaveBeenCalledTimes(1);
-  });
-
-  it("pool returns a separate browser when forceScreenshot mismatches pooled mode", async () => {
-    const first = await acquireBrowser(["--no-sandbox"], poolCfg);
-    expect(first.captureMode).toBe("screenshot");
-
-    // Second acquire with same forceScreenshot — same mode, should reuse
-    const second = await acquireBrowser(["--no-sandbox"], poolCfg);
-    expect(second.browser).toBe(first.browser);
-    expect(launchFn).toHaveBeenCalledTimes(1);
-
-    await releaseBrowser(first.browser, poolCfg);
-    await releaseBrowser(second.browser, poolCfg);
-  });
-
-  it("forceReleaseBrowser does not kill Chrome when other sessions hold refs", async () => {
-    const result = await acquireBrowser(["--no-sandbox"], poolCfg);
-    // Acquire a second ref
-    const second = await acquireBrowser(["--no-sandbox"], poolCfg);
-
-    const disconnectFn = result.browser.disconnect as ReturnType<typeof vi.fn>;
-    forceReleaseBrowser(result.browser);
-
-    // Should NOT have disconnected — other session still holds a ref
-    expect(disconnectFn).not.toHaveBeenCalled();
-
-    // Release the remaining ref normally
-    await releaseBrowser(second.browser, poolCfg);
-  });
-
-  it("drainBrowserPool is safe to call when no browser is pooled", async () => {
-    await drainBrowserPool();
-  });
-
-  it("drainBrowserPool awaits in-flight launch before closing", async () => {
-    let resolveDeferred!: (browser: Browser) => void;
-    const deferred = new Promise<Browser>((resolve) => {
-      resolveDeferred = resolve;
-    });
-    launchFn.mockReturnValue(deferred);
-
-    // Start acquire — it will be pending
-    const acquirePromise = acquireBrowser(["--no-sandbox"], poolCfg);
-
-    // Drain while launch is in-flight
-    const drainPromise = drainBrowserPool();
-
-    // Resolve the pending launch
-    const mockBrowser = makeMockBrowser();
-    resolveDeferred(mockBrowser);
-
-    await drainPromise;
-    const closeFn = mockBrowser.close as ReturnType<typeof vi.fn>;
-    expect(closeFn).toHaveBeenCalled();
-
-    // The acquire should still resolve (the launch completed before drain closed it)
-    await acquirePromise.catch(() => {});
-  });
-});