@bivy/bivy 0.17.3-staging.2 → 0.17.3-staging.21

package/dist/apps/registry.js

@@ -3,9 +3,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { randomBytes } from "node:crypto";
+import { EventEmitter } from "node:events";
 const MAX_BYTES = 25 * 1024 * 1024;
 const MAX_TOTAL_BYTES = 100 * 1024 * 1024;
 const MAX_FILES = 2000;
+const sameFiles = (a, b) => a.size === b.size && [...a].every(([key, data]) => b.get(key)?.equals(data));
 /** Snapshot, not a live filesystem server: symlinks and hidden files are never published. */
 function snapshot(workspace, directory) {
     const base = fs.realpathSync(workspace);
@@ -72,15 +74,70 @@ function snapshot(workspace, directory) {
         throw new Error("Static directory needs an index.html entry point.");
     return { kind: "static", files, bytes };
 }
-/** Deliberately ephemeral: restart invalidates apps rather than trusting reused local ports. */
-export class AppRegistry {
+function command(spec, workspace, label) {
+    const value = spec;
+    if (typeof value?.command !== "string" || !value.command.trim() || value.command.length > 1000 || value.command.includes("\u0000"))
+        throw new Error(`${label} requires an executable command.`);
+    if (value.args !== undefined && (!Array.isArray(value.args) || value.args.length > 100 || value.args.some((arg) => typeof arg !== "string" || arg.length > 4000 || arg.includes("\u0000"))))
+        throw new Error(`Invalid ${label.toLowerCase()} arguments.`);
+    return { command: value.command, args: [...(value.args ?? [])], workspace: fs.realpathSync(workspace) };
+}
+/** Apps persist (with their IDs) when given a file, so chat launchers and
+ * preview addresses survive restarts. Views whose server Bivy doesn't own —
+ * a service without `start` — are not restored: a reused local port could
+ * belong to anything by then. Detection offers them again. */
+export class AppRegistry extends EventEmitter {
     reservedPorts;
+    file;
     apps = new Map();
     views = new Map();
-    constructor(reservedPorts = []) {
+    persisted = new Map();
+    constructor(reservedPorts = [], file) {
+        super();
         this.reservedPorts = reservedPorts;
+        this.file = file;
+        this.setMaxListeners(0);
+        this.restore();
+    }
+    restore() {
+        if (!this.file)
+            return;
+        let records = [];
+        try {
+            records = JSON.parse(fs.readFileSync(this.file, "utf8"));
+        }
+        catch {
+            return;
+        }
+        for (const record of Array.isArray(records) ? records : []) {
+            const keep = record.manifest?.views?.map((spec, i) => ({ spec, id: record.viewIds?.[i] }))
+                .filter(({ spec, id }) => typeof id === "string" && !(spec?.kind === "web" && spec.source?.kind === "service" && !spec.source.start)) ?? [];
+            if (!keep.length)
+                continue;
+            // A workspace that moved or a build that vanished drops that app, not the rest.
+            try {
+                this.publish(record.sessionId, record.workspace, { ...record.manifest, views: keep.map((k) => k.spec) }, { id: record.id, viewIds: keep.map((k) => k.id), createdAt: record.createdAt });
+            }
+            catch { /* skipped */ }
+        }
+        this.save();
+    }
+    save() {
+        if (!this.file)
+            return;
+        const tmp = `${this.file}.${process.pid}.tmp`;
+        try {
+            fs.writeFileSync(tmp, JSON.stringify([...this.persisted.values()]), { mode: 0o600 });
+            fs.renameSync(tmp, this.file);
+        }
+        catch {
+            try {
+                fs.rmSync(tmp, { force: true });
+            }
+            catch { /* ignore */ }
+        }
     }
-    publish(sessionId, workspace, input) {
+    publish(sessionId, workspace, input, restore) {
         const name = (value) => {
             if (typeof value !== "string" || !value.trim() || value.length > 100)
                 throw new Error("App and view names must contain 1–100 characters.");
@@ -90,54 +147,99 @@ export class AppRegistry {
             throw new Error("Expected manifest version 1 with 1–8 views.");
         if (this.apps.size >= 50)
             throw new Error("Remove an app before publishing more (limit: 50).");
-        const app = { id: randomBytes(16).toString("hex"), sessionId, name: name(input.name), views: [], createdAt: Date.now() };
+        const id = (i) => (i === undefined ? restore?.id : restore?.viewIds[i]) ?? randomBytes(16).toString("hex");
+        const app = { id: id(), sessionId, name: name(input.name), views: [], createdAt: restore?.createdAt ?? Date.now() };
         const entries = [];
         let total = [...this.views.values()].reduce((sum, item) => sum + (item.target.kind === "static" ? item.target.bytes : 0), 0);
-        for (const spec of input.views) {
-            const base = { id: randomBytes(16).toString("hex"), name: name(spec?.name) };
+        for (const [index, spec] of input.views.entries()) {
+            const base = { id: id(index), name: name(spec?.name) };
             let target;
             let view;
+            let source;
             if (spec.kind === "web" && spec.source?.kind === "service") {
                 const port = spec.source.port;
                 if (!Number.isInteger(port) || port < 1024 || port > 65535 || this.reservedPorts.includes(port))
                     throw new Error("Choose a non-reserved local service port between 1024 and 65535.");
-                target = { kind: "service", port };
-                view = { ...base, kind: "web", source: "service" };
+                const start = spec.source.start === undefined ? undefined : command(spec.source.start, workspace, "Service start");
+                target = { kind: "service", port, start };
+                view = { ...base, kind: "web", source: "service", ...(start ? { managed: true } : {}) };
             }
             else if (spec.kind === "web" && spec.source?.kind === "static") {
                 if (typeof spec.source.directory !== "string" || !spec.source.directory)
                     throw new Error("Static directory is required.");
                 target = snapshot(workspace, spec.source.directory);
-                if (target.kind === "static")
-                    total += target.bytes;
+                source = { workspace, directory: spec.source.directory };
+                total += target.bytes;
                 if (total > MAX_TOTAL_BYTES)
                     throw new Error("Static apps exceed the node's 100 MiB snapshot budget.");
                 view = { ...base, kind: "web", source: "static" };
             }
             else if (spec.kind === "terminal") {
-                if (typeof spec.command !== "string" || !spec.command.trim() || spec.command.length > 1000 || spec.command.includes("\u0000"))
-                    throw new Error("Terminal view requires an executable command.");
-                if (spec.args !== undefined && (!Array.isArray(spec.args) || spec.args.length > 100 || spec.args.some((arg) => typeof arg !== "string" || arg.length > 4000 || arg.includes("\u0000"))))
-                    throw new Error("Invalid terminal arguments.");
-                const args = [...(spec.args ?? [])];
-                target = { kind: "terminal", command: spec.command, args, workspace: fs.realpathSync(workspace) };
-                view = { ...base, kind: "terminal", command: spec.command, args };
+                target = { kind: "terminal", ...command(spec, workspace, "Terminal view") };
+                view = { ...base, kind: "terminal", command: target.command, args: target.args };
+            }
+            else if (spec.kind === "display") {
+                // Shown through the web preview: Bivy's viewer streams the display.
+                target = { kind: "display", ...command(spec, workspace, "Display view"), restartOnChange: spec.restartOnChange === true };
+                view = { ...base, kind: "web", source: "display", managed: true };
             }
             else
-                throw new Error("Unsupported app view. This machine supports web and terminal views.");
+                throw new Error("Unsupported app view. Supported views: web, terminal and display.");
             app.views.push(view);
-            entries.push({ app, view, target });
+            entries.push({ app, view, target, revision: 0, source });
         }
         // Commit all views together: a bad later view cannot leave a partial app.
         this.apps.set(app.id, app);
         for (const entry of entries)
             this.views.set(entry.view.id, entry);
+        this.persisted.set(app.id, { sessionId, workspace, manifest: structuredClone(input), id: app.id, viewIds: app.views.map((v) => v.id), createdAt: app.createdAt });
+        if (!restore)
+            this.save();
         return structuredClone(app);
     }
     list(sessionId) {
-        return structuredClone([...this.apps.values()].filter((app) => app.sessionId === sessionId));
+        return structuredClone([...this.apps.values()].filter((app) => sessionId === undefined || app.sessionId === sessionId));
     }
     getView(id) { return this.views.get(id); }
+    /** An agent turn changed files: re-take changed static snapshots and bump
+     * every affected web view (emits `revision`). Returns the bumped view IDs. */
+    touch(sessionId) {
+        const bumped = [];
+        let total = [...this.views.values()].reduce((sum, item) => sum + (item.target.kind === "static" ? item.target.bytes : 0), 0);
+        for (const entry of this.views.values()) {
+            // A display streams live pixels: only one that restarts on changes has a new revision.
+            if (entry.app.sessionId !== sessionId || entry.view.kind !== "web" || (entry.target.kind === "display" && !entry.target.restartOnChange))
+                continue;
+            if (entry.target.kind === "static") {
+                if (!entry.source)
+                    continue;
+                let next;
+                // A broken build keeps the last good snapshot rather than blanking the preview.
+                try {
+                    next = snapshot(entry.source.workspace, entry.source.directory);
+                }
+                catch {
+                    continue;
+                }
+                if (sameFiles(entry.target.files, next.files) || total - entry.target.bytes + next.bytes > MAX_TOTAL_BYTES)
+                    continue;
+                total += next.bytes - entry.target.bytes;
+                entry.target = next;
+            }
+            entry.revision++;
+            bumped.push(entry.view.id);
+            this.emit("revision", entry.view.id);
+        }
+        return bumped;
+    }
+    /** Ports a session already previews, and ports no app may claim. */
+    claimedPorts(sessionId) {
+        const ports = new Set(this.reservedPorts);
+        for (const { app, target } of this.views.values())
+            if (app.sessionId === sessionId && target.kind === "service")
+                ports.add(target.port);
+        return ports;
+    }
     require(sessionId, id) {
         const app = this.apps.get(id);
         if (!app || app.sessionId !== sessionId)
@@ -156,5 +258,7 @@ export class AppRegistry {
         for (const view of app.views)
             this.views.delete(view.id);
         this.apps.delete(id);
+        this.persisted.delete(id);
+        this.save();
     }
 }

package/dist/apps/remote-preview.js

@@ -8,14 +8,16 @@ import { PreviewStream } from "./preview-stream.js";
 export class RemotePreview {
     registry;
     returnOrigins;
+    signIn;
     gateway;
     origin;
     relayUrl;
     online = false;
     sockets = new Set();
-    constructor(registry, returnOrigins) {
+    constructor(registry, returnOrigins, signIn) {
         this.registry = registry;
         this.returnOrigins = returnOrigins;
+        this.signIn = signIn;
     }
     get available() { return this.online && Boolean(this.gateway); }
     ready(origin, relayUrl) {
@@ -28,7 +30,7 @@ export class RemotePreview {
             return;
         if (this.origin !== template) {
             this.gateway?.close();
-            this.gateway = new AppGateway(this.registry, template, this.returnOrigins);
+            this.gateway = new AppGateway(this.registry, template, this.returnOrigins, this.signIn);
             this.origin = template;
         }
         this.relayUrl = relayUrl.replace(/\/$/, "") + "/preview/stream";
@@ -65,6 +67,12 @@ export class RemotePreview {
         return this.gateway.share(id);
     }
     revoke(id) { this.gateway?.revoke(id); }
+    address(id) { return this.available ? this.gateway.address(id) : undefined; }
+    openDirect(id) {
+        if (!this.available)
+            throw new Error("Preview delivery is unavailable. Reconnect the machine and try again.");
+        return this.gateway.openDirect(id);
+    }
     disconnect() {
         this.online = false;
         for (const ws of this.sockets)

package/dist/apps/rfb.js

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import net from "node:net";
+import { deflateSync } from "node:zlib";
+/** Reads exact byte counts from a stream. */
+class Reader {
+    buffer = Buffer.alloc(0);
+    waiting;
+    failure;
+    reject;
+    constructor(socket) {
+        socket.on("data", (chunk) => { this.buffer = Buffer.concat([this.buffer, chunk]); this.pump(); });
+        const fail = (error) => { this.failure = error; this.reject?.(error); };
+        socket.on("error", fail);
+        socket.on("close", () => fail(new Error("The display closed the connection.")));
+    }
+    read(n) {
+        return new Promise((resolve, reject) => {
+            if (this.failure && this.buffer.length < n) {
+                reject(this.failure);
+                return;
+            }
+            this.waiting = { n, resolve };
+            this.reject = reject;
+            this.pump();
+        });
+    }
+    pump() {
+        if (!this.waiting || this.buffer.length < this.waiting.n)
+            return;
+        const { n, resolve } = this.waiting;
+        this.waiting = undefined;
+        const out = this.buffer.subarray(0, n);
+        this.buffer = this.buffer.subarray(n);
+        resolve(out);
+    }
+}
+/** One full frame from a VNC server (security type None), as packed RGB. Joins
+ * as a shared client, so open viewers stay connected. */
+export async function captureFrame(socketPath, timeoutMs = 10_000) {
+    const socket = net.connect(socketPath);
+    const timer = setTimeout(() => socket.destroy(new Error("The display didn't answer in time.")), timeoutMs);
+    try {
+        const reader = new Reader(socket);
+        const version = (await reader.read(12)).toString("latin1");
+        if (!/^RFB 003\.\d{3}\n$/.test(version))
+            throw new Error("Not a VNC display.");
+        socket.write("RFB 003.008\n");
+        const types = await reader.read((await reader.read(1))[0]);
+        if (!types.includes(1))
+            throw new Error("The display requires a password.");
+        socket.write(Buffer.from([1]));
+        if ((await reader.read(4)).readUInt32BE(0) !== 0)
+            throw new Error("The display refused the connection.");
+        socket.write(Buffer.from([1]));
+        const init = await reader.read(24);
+        const width = init.readUInt16BE(0), height = init.readUInt16BE(2);
+        await reader.read(init.readUInt32BE(20)); // desktop name
+        // 32 bpp true colour, little-endian, red at bit 16: bytes arrive B, G, R, X.
+        const format = Buffer.from([0, 0, 0, 0, 32, 24, 0, 1, 0, 255, 0, 255, 0, 255, 16, 8, 0, 0, 0, 0]);
+        const encodings = Buffer.from([2, 0, 0, 1, 0, 0, 0, 0]); // Raw only
+        const request = Buffer.alloc(10);
+        request[0] = 3;
+        request.writeUInt16BE(width, 6);
+        request.writeUInt16BE(height, 8);
+        socket.write(Buffer.concat([format, encodings, request]));
+        const rgb = Buffer.alloc(width * height * 3);
+        for (;;) {
+            const type = (await reader.read(1))[0];
+            if (type === 2)
+                continue; // bell
+            if (type === 3) {
+                const head = await reader.read(7);
+                await reader.read(head.readUInt32BE(3));
+                continue;
+            } // clipboard
+            if (type !== 0)
+                throw new Error("Unexpected message from the display.");
+            const rects = (await reader.read(3)).readUInt16BE(1);
+            for (let r = 0; r < rects; r++) {
+                const head = await reader.read(12);
+                const x = head.readUInt16BE(0), y = head.readUInt16BE(2), w = head.readUInt16BE(4), h = head.readUInt16BE(6);
+                if (head.readInt32BE(8) !== 0)
+                    throw new Error("Unexpected encoding from the display.");
+                const pixels = await reader.read(w * h * 4);
+                for (let row = 0; row < h; row++)
+                    for (let col = 0; col < w; col++) {
+                        if (x + col >= width || y + row >= height)
+                            continue;
+                        const from = (row * w + col) * 4, to = ((y + row) * width + x + col) * 3;
+                        rgb[to] = pixels[from + 2];
+                        rgb[to + 1] = pixels[from + 1];
+                        rgb[to + 2] = pixels[from];
+                    }
+            }
+            return { width, height, rgb };
+        }
+    }
+    finally {
+        clearTimeout(timer);
+        socket.destroy();
+    }
+}
+const CRC = Array.from({ length: 256 }, (_, n) => { let c = n; for (let k = 0; k < 8; k++)
+    c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; return c >>> 0; });
+function crc32(data) { let c = 0xffffffff; for (const byte of data)
+    c = CRC[(c ^ byte) & 0xff] ^ (c >>> 8); return (c ^ 0xffffffff) >>> 0; }
+function chunk(type, data) {
+    const head = Buffer.alloc(8);
+    head.writeUInt32BE(data.length, 0);
+    head.write(type, 4, "latin1");
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), data])));
+    return Buffer.concat([head, data, crc]);
+}
+export function encodePng(width, height, rgb) {
+    const header = Buffer.alloc(13);
+    header.writeUInt32BE(width, 0);
+    header.writeUInt32BE(height, 4);
+    header[8] = 8;
+    header[9] = 2; // 8-bit RGB
+    const rows = Buffer.alloc((width * 3 + 1) * height);
+    for (let y = 0; y < height; y++)
+        rgb.copy(rows, y * (width * 3 + 1) + 1, y * width * 3, (y + 1) * width * 3);
+    return Buffer.concat([Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]), chunk("IHDR", header), chunk("IDAT", deflateSync(rows)), chunk("IEND", Buffer.alloc(0))]);
+}

package/dist/apps/screenshot.js

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import http from "node:http";
+import { once } from "node:events";
+import { spawn, execFileSync } from "node:child_process";
+import { WebSocket } from "ws";
+import { captureFrame, encodePng } from "./rfb.js";
+/** Browsers tried in order; BIVY_CHROME overrides. Any Chromium works. */
+const CANDIDATES = [
+    "google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge",
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+];
+export function findChrome(env = process.env) {
+    if (env.BIVY_CHROME)
+        return fs.existsSync(env.BIVY_CHROME) ? env.BIVY_CHROME : undefined;
+    for (const candidate of CANDIDATES) {
+        if (candidate.startsWith("/")) {
+            if (fs.existsSync(candidate))
+                return candidate;
+            continue;
+        }
+        try {
+            return execFileSync("which", [candidate], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || undefined;
+        }
+        catch { /* next */ }
+    }
+    // A Playwright install (common on dev machines) ships a headless shell.
+    const cache = path.join(os.homedir(), ".cache", "ms-playwright");
+    for (const dir of fs.existsSync(cache) ? fs.readdirSync(cache).sort().reverse() : []) {
+        for (const bin of ["chrome-headless-shell-linux64/chrome-headless-shell", "chrome-linux/chrome"]) {
+            const file = path.join(cache, dir, bin);
+            if (dir.startsWith("chromium") && fs.existsSync(file))
+                return file;
+        }
+    }
+    return undefined;
+}
+/** Serves a static snapshot on loopback for the duration of a shot. */
+async function serveSnapshot(files) {
+    const server = http.createServer((req, res) => {
+        let file = decodeURIComponent((req.url ?? "/").split("?")[0]);
+        if (file.endsWith("/"))
+            file += "index.html";
+        const data = files.get(file) ?? (path.extname(file) ? undefined : files.get("/index.html"));
+        if (!data) {
+            res.writeHead(404);
+            res.end();
+            return;
+        }
+        res.end(data);
+    });
+    server.listen(0, "127.0.0.1");
+    await once(server, "listening");
+    return { origin: `http://127.0.0.1:${server.address().port}`, close: () => { server.close(); server.closeAllConnections(); } };
+}
+/** Minimal CDP client over one browser-level WebSocket (flattened sessions). */
+class Cdp {
+    ws;
+    next = 0;
+    pending = new Map();
+    listeners = new Set();
+    constructor(ws) {
+        this.ws = ws;
+        ws.on("message", (raw) => {
+            const msg = JSON.parse(raw.toString());
+            if (msg.id !== undefined) {
+                const call = this.pending.get(msg.id);
+                this.pending.delete(msg.id);
+                if (msg.error)
+                    call?.reject(new Error(msg.error.message));
+                else
+                    call?.resolve(msg.result);
+            }
+            else
+                for (const fn of this.listeners)
+                    fn(msg.method, msg.params, msg.sessionId);
+        });
+    }
+    send(method, params = {}, sessionId) {
+        const id = ++this.next;
+        return new Promise((resolve, reject) => { this.pending.set(id, { resolve, reject }); this.ws.send(JSON.stringify({ id, method, params, sessionId })); });
+    }
+    once(method, sessionId, ms) {
+        return new Promise((resolve) => {
+            const fn = (m, _p, s) => { if (m === method && s === sessionId)
+                finish(); };
+            const finish = () => { clearTimeout(timer); this.listeners.delete(fn); resolve(); };
+            const timer = setTimeout(finish, ms);
+            this.listeners.add(fn);
+        });
+    }
+}
+/** Screenshots web views with one headless browser, one shot at a time, so
+ * small machines cope. Service views are loaded straight from loopback;
+ * static views from a throwaway loopback server. Desktop apps are read from
+ * their display, at its current size, without a browser. Files are PNGs in `outDir`. */
+export async function takeShots(views, request, outDir, chrome = findChrome()) {
+    fs.mkdirSync(outDir, { recursive: true });
+    const shots = [];
+    for (const entry of views) {
+        if (entry.target.kind !== "display" || !entry.display)
+            continue;
+        const frame = await captureFrame(entry.display);
+        const file = path.join(outDir, `${entry.view.id.slice(0, 8)}-${frame.width}-native.png`);
+        fs.writeFileSync(file, encodePng(frame.width, frame.height, frame.rgb));
+        shots.push({ viewId: entry.view.id, view: entry.view.name, width: frame.width, theme: "native", file });
+    }
+    views = views.filter((entry) => entry.target.kind === "service" || entry.target.kind === "static");
+    if (!views.length)
+        return shots;
+    if (!chrome)
+        throw new Error("No Chrome or Chromium found on this machine. Install one, or set BIVY_CHROME to its path.");
+    const profile = fs.mkdtempSync(path.join(os.tmpdir(), "bivy-shot-"));
+    const servers = [];
+    let ws;
+    let browser;
+    const deadline = setTimeout(() => browser?.kill("SIGKILL"), 120_000);
+    // Chromium's sandbox is unavailable as root and where AppArmor blocks user
+    // namespaces (Ubuntu 23.10+). The pages are the session's own apps, already
+    // running as this user, so retrying without it doesn't widen what they can do.
+    const launch = (sandbox) => new Promise((resolve, reject) => {
+        const args = ["--headless=new", "--remote-debugging-port=0", `--user-data-dir=${profile}`, "--no-first-run", "--no-default-browser-check", "--disable-gpu", "--hide-scrollbars", "--mute-audio", ...(sandbox ? [] : ["--no-sandbox"]), "about:blank"];
+        const child = spawn(chrome, args, { stdio: ["ignore", "ignore", "pipe"] });
+        browser = child;
+        let text = "";
+        const timer = setTimeout(() => reject(new Error("The browser didn't start in time.")), 20_000);
+        child.stderr.on("data", (chunk) => { text += chunk; const m = /DevTools listening on (ws:\/\/\S+)/.exec(text); if (m) {
+            clearTimeout(timer);
+            resolve(m[1]);
+        } });
+        child.once("exit", () => { clearTimeout(timer); reject(Object.assign(new Error("The browser exited before it was ready."), { noSandbox: /No usable sandbox|--no-sandbox/i.test(text) })); });
+    });
+    try {
+        const endpoint = await launch(process.getuid?.() !== 0).catch((error) => {
+            if (error.noSandbox)
+                return launch(false);
+            throw error;
+        });
+        ws = new WebSocket(endpoint, { perMessageDeflate: false, maxPayload: 256 * 1024 * 1024 });
+        await once(ws, "open");
+        const cdp = new Cdp(ws);
+        const { targetId } = await cdp.send("Target.createTarget", { url: "about:blank" });
+        const { sessionId } = await cdp.send("Target.attachToTarget", { targetId, flatten: true });
+        await cdp.send("Page.enable", {}, sessionId);
+        for (const entry of views) {
+            let origin;
+            if (entry.target.kind === "service")
+                origin = `http://127.0.0.1:${entry.target.port}`;
+            else if (entry.target.kind === "static") {
+                const server = await serveSnapshot(entry.target.files);
+                servers.push(server);
+                origin = server.origin;
+            }
+            else
+                continue;
+            for (const width of request.widths)
+                for (const theme of request.themes) {
+                    const mobile = width < 600;
+                    await cdp.send("Emulation.setDeviceMetricsOverride", { width, height: mobile ? 844 : 800, deviceScaleFactor: mobile ? 2 : 1, mobile }, sessionId);
+                    await cdp.send("Emulation.setEmulatedMedia", { features: [{ name: "prefers-color-scheme", value: theme }] }, sessionId);
+                    const loaded = cdp.once("Page.loadEventFired", sessionId, 15_000);
+                    await cdp.send("Page.navigate", { url: origin + request.path }, sessionId);
+                    await loaded;
+                    await new Promise((r) => setTimeout(r, 400)); // let fonts and first effects settle
+                    const { data } = await cdp.send("Page.captureScreenshot", { format: "png" }, sessionId);
+                    const file = path.join(outDir, `${entry.view.id.slice(0, 8)}-${width}-${theme}.png`);
+                    fs.writeFileSync(file, Buffer.from(data, "base64"));
+                    shots.push({ viewId: entry.view.id, view: entry.view.name, width, theme, file });
+                }
+        }
+        return shots;
+    }
+    finally {
+        clearTimeout(deadline);
+        ws?.terminate();
+        for (const server of servers)
+            server.close();
+        // Wait for the browser to exit before removing its profile: a killed
+        // Chrome can still be writing into it. Cleanup never fails a shot.
+        if (browser && browser.exitCode === null && browser.signalCode === null) {
+            const exited = once(browser, "exit").catch(() => { });
+            browser.kill("SIGKILL");
+            await exited;
+        }
+        try {
+            fs.rmSync(profile, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+        }
+        catch { /* temp dir; the OS reclaims it */ }
+    }
+}