@deepseek-insight/dsi 0.8.1 → 0.8.3

package/build/server/chunks/chunks/registry.js-C2MdrfNv.js

@@ -0,0 +1,954 @@
+import { d as readBrowserConfig } from './insight-config.js-Dp_2gB5J.js';
+import { mkdirSync, rmSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { chromium } from 'playwright-core';
+
+//#region src/lib/server/browser/relay.ts
+var RelayClosedError = class extends Error {
+	constructor() {
+		super("relay is closed");
+		this.name = "RelayClosedError";
+	}
+};
+var BrowserRelay = class {
+	quality;
+	maxFps;
+	cdp;
+	subscribers = /* @__PURE__ */ new Set();
+	seq = 0;
+	latest = null;
+	chain = Promise.resolve();
+	started = false;
+	/** ADR-0040 D1: an INACTIVE tab's screencast is suspended (no Chrome-side
+	*  encode, no wire cost) while the relay — ring, seq, subscribers — lives
+	*  on, so re-activation resumes instead of rebuilding. */
+	paused = false;
+	/** JPEG quality 0..100 — from BrowserConfig.screencastQuality
+	*  (default 90; yaml `browser.screencast:` override, amendment 3).
+	*  maxFps — ADR-0039 D1: target fps intent; start() derives CDP's
+	*  everyNthFrame from a nominal 30 Hz paint clock (clamp ≥1). */
+	constructor(cdp, quality = 90, maxFps = 15) {
+		this.quality = quality;
+		this.maxFps = maxFps;
+		this.cdp = cdp;
+	}
+	async start() {
+		if (!this.cdp || this.started) throw new RelayClosedError();
+		this.cdp.on("Page.screencastFrame", (ev) => {
+			this.seq += 1;
+			this.latest = {
+				seq: this.seq,
+				jpeg: ev.data,
+				metadata: ev.metadata
+			};
+			for (const sub of this.subscribers) sub(this.latest);
+			this.cdp?.send("Page.screencastFrameAck", { sessionId: ev.sessionId }).catch(() => void 0);
+		});
+		await this.cdp.send("Page.startScreencast", {
+			format: "jpeg",
+			quality: this.quality,
+			everyNthFrame: Math.max(1, Math.round(30 / this.maxFps))
+		});
+		this.started = true;
+		this.paused = false;
+	}
+	/** Suspend the screencast, keep the relay (ADR-0040 D1). Idempotent. */
+	async pause() {
+		if (!this.cdp || !this.started || this.paused) return;
+		this.paused = true;
+		await this.cdp.send("Page.stopScreencast").catch(() => void 0);
+	}
+	/** Re-start the screencast after a pause (same dials). Idempotent. */
+	async resume() {
+		if (!this.cdp || !this.started || !this.paused) return;
+		this.paused = false;
+		await this.cdp.send("Page.startScreencast", {
+			format: "jpeg",
+			quality: this.quality,
+			everyNthFrame: Math.max(1, Math.round(30 / this.maxFps))
+		}).catch(() => void 0);
+	}
+	/** Activation MUST stream (ADR-0040 D4): START a never-started (lazily
+	*  attached) relay, RESUME a paused one, no-op an already-streaming one.
+	*  BUGFIX 2026-10-24: activate() called resume() only — a lazily attached
+	*  tab (started=false) never began streaming and the mirror froze on its
+	*  seeded boundary frame (the operator's hung second YouTube tab). */
+	async ensureStreaming() {
+		if (!this.cdp) throw new RelayClosedError();
+		if (!this.started) return this.start();
+		if (this.paused) return this.resume();
+	}
+	/** Deterministic first-frame seed (RCA 2026-10-23 The First Frame That
+	*  Never Knocked): a starved screencast birth leaves the ring empty
+	*  FOREVER — screencast only speaks on paint damage. The opener synthesizes
+	*  the first frame via Page.captureScreenshot and seeds the ring here so
+	*  attachers get a frame immediately. Does not advance past a real frame. */
+	seed(frame) {
+		if (!this.cdp) throw new RelayClosedError();
+		if (this.latest) return;
+		this.seq += 1;
+		this.latest = {
+			...frame,
+			seq: this.seq
+		};
+		for (const sub of this.subscribers) sub(this.latest);
+	}
+	latestFrame() {
+		if (!this.cdp) throw new RelayClosedError();
+		return this.latest;
+	}
+	subscribe(fn) {
+		if (!this.cdp) throw new RelayClosedError();
+		this.subscribers.add(fn);
+		return () => this.subscribers.delete(fn);
+	}
+	/** Serialized dispatch — every input waits for the previous one. */
+	dispatch(input) {
+		if (!this.cdp) return Promise.reject(new RelayClosedError());
+		const run = async () => {
+			if (!this.cdp) throw new RelayClosedError();
+			if (input.kind === "mouse") await this.cdp.send("Input.dispatchMouseEvent", {
+				type: input.type,
+				x: input.x,
+				y: input.y,
+				button: input.button ?? "none",
+				clickCount: input.clickCount,
+				deltaX: input.deltaX,
+				deltaY: input.deltaY,
+				pointerType: "mouse"
+			});
+			else if (input.kind === "key") await this.cdp.send("Input.dispatchKeyEvent", {
+				type: input.type,
+				key: input.key,
+				code: input.code,
+				windowsVirtualKeyCode: input.windowsVirtualKeyCode,
+				text: input.text
+			});
+			else await this.cdp.send("Input.insertText", { text: input.text });
+		};
+		const next = this.chain.then(run, run);
+		this.chain = next.catch(() => void 0);
+		return next;
+	}
+	stop() {
+		const cdp = this.cdp;
+		this.cdp = null;
+		this.subscribers.clear();
+		this.latest = null;
+		if (cdp && this.started) cdp.send("Page.stopScreencast").catch(() => void 0);
+	}
+};
+Number(process.env.DSI_MCP_PORT ?? 9515);
+/** The reaper's ONLY test — pure: a session is reaper-eligible when nobody
+*  watches its stream AND its last MCP tool traffic is older than idleMs.
+*  An active agent (traffic younger than idleMs) is NEVER eligible (D2). */
+function reaperEligible(e, idleMs, now) {
+	if (e.streamSubscribers > 0) return false;
+	return now - e.lastMcpActivity >= idleMs;
+}
+var BrowserRegistryRefusal = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "BrowserRegistryRefusal";
+		this.code = code;
+	}
+};
+function state() {
+	const p = process;
+	if (!p.__DSI_BROWSER_STATE__) {
+		p.__DSI_BROWSER_STATE__ = {
+			entries: /* @__PURE__ */ new Map(),
+			closed: /* @__PURE__ */ new Set()
+		};
+		sweepOrphanProfiles(new Set([...p.__DSI_BROWSER_STATE__.entries.keys()].map((id) => id.slice(0, 8))));
+	}
+	return p.__DSI_BROWSER_STATE__;
+}
+/** Boot-time sweep of profile dirs left by sessions that died without a
+*  close (crash, kill -9, reaper miss). keep = prefixes of LIVE entries —
+*  a module hot reload re-runs state() init against a process-global map
+*  that may hold live sessions, and this sweep must never delete one. */
+function sweepOrphanProfiles(keep) {
+	try {
+		const root = readBrowserConfig().profileRoot;
+		for (const name of readdirSync(root)) if (!keep.has(name)) rmSync(join(root, name), {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+}
+/** Brain re-homing (BUGFIX 2026-10-25): release the stable brain port
+*  from any OTHER live session so the NEWEST glass binds it. The DSH
+*  preset's brain URL is static (9515) — without this, the agent keeps
+*  driving an older glass while the operator watches the new one. The
+*  evicted glass mirrors fine; its status strip honestly reports the
+*  brain down (ADR-0029 D7: the mirror never depends on the brain). */
+function evictBrainPort(brainPort, exceptId) {
+	for (const e of state().entries.values()) {
+		if (e.id === exceptId || !e.mcpInProcess || e.mcpInProcess.port !== brainPort) continue;
+		const brain = e.mcpInProcess;
+		(async () => {
+			try {
+				await new Promise((res) => {
+					brain.httpServer?.closeAllConnections?.();
+					brain.httpServer?.close?.(() => res());
+					setTimeout(res, 1500);
+				});
+				await brain.connection?.close?.();
+			} catch {}
+		})();
+		e.mcpInProcess = null;
+		e.mcpHealth = "down";
+		e.mcpError = "brain re-homed to a newer glass";
+	}
+}
+/** The in-process brain (D7): createConnection attached to the SAME headed
+*  browser via cdpEndpoint, served over a SIBLING http listener (SSE +
+*  messages endpoints) so a streamable-http MCP client (the DSH agent) can
+*  reach it without a child process. Port = session port + 100 (9501...):
+*  unique per session, out of the debug-port range. */
+async function startInProcessMcp(browserPort, brainPort, onTraffic) {
+	const [{ createConnection }, { StreamableHTTPServerTransport }, http] = await Promise.all([
+		import('@playwright/mcp'),
+		import('@modelcontextprotocol/sdk/server/streamableHttp.js'),
+		import('node:http')
+	]);
+	const connection = await createConnection({ browser: { cdpEndpoint: "http://127.0.0.1:" + browserPort } });
+	const transport = new StreamableHTTPServerTransport({
+		sessionIdGenerator: void 0,
+		enableJsonResponse: true
+	});
+	await connection.connect(transport);
+	const server = http.createServer(async (req, res) => {
+		if (new URL(req.url ?? "/", "http://127.0.0.1").pathname !== "/sse") {
+			res.statusCode = 404;
+			res.end();
+			return;
+		}
+		onTraffic?.();
+		try {
+			await transport.handleRequest(req, res);
+		} catch {
+			if (!res.writableEnded) res.end();
+		}
+	});
+	let port;
+	try {
+		port = await listen(server, brainPort);
+	} catch {
+		let lastErr = null;
+		port = 0;
+		for (let p = brainPort + 1; p <= brainPort + 60; p++) try {
+			port = await listen(server, p);
+			break;
+		} catch (e) {
+			lastErr = e;
+		}
+		if (port === 0) throw lastErr ?? /* @__PURE__ */ new Error("no free brain port in " + brainPort + "+ range");
+	}
+	return {
+		connection,
+		httpServer: server,
+		port
+	};
+}
+var listen = (server, port) => new Promise((res, rej) => {
+	const onError = () => {
+		server.off("listening", onListen);
+		rej(/* @__PURE__ */ new Error("EADDRINUSE " + port));
+	};
+	const onListen = () => {
+		server.off("error", onError);
+		const a = server.address();
+		res(typeof a === "object" && a ? a.port : port);
+	};
+	server.once("error", onError);
+	server.once("listening", onListen);
+	server.listen(port, "127.0.0.1");
+});
+function pidOfPort(port) {
+	const p = spawnSync("lsof", [
+		"-ti",
+		"tcp:" + port,
+		"-sTCP:LISTEN"
+	], { stdio: "pipe" });
+	return p.status === 0 ? Number(p.stdout.toString().trim().split("\n")[0]) : null;
+}
+function portFree(port) {
+	return spawnSync("lsof", [
+		"-ti",
+		"tcp:" + port,
+		"-sTCP:LISTEN"
+	], { stdio: "pipe" }).status !== 0;
+}
+function freePort(preferred) {
+	if (preferred && portFree(preferred)) return preferred;
+	for (let p = 9400; p < 9500; p++) if (portFree(p)) return p;
+	throw new Error("no free debug port in 9400..9499");
+}
+var BrowserRegistry = class {
+	list() {
+		return [...state().entries.values()].map((e) => ({
+			id: e.id,
+			port: e.port,
+			pid: e.pid,
+			profileDir: e.profileDir,
+			createdAt: e.createdAt,
+			mcp: e.mcpChild ? "child" : e.mcpInProcess ? "in-process" : "none",
+			mcpHealth: e.mcpHealth,
+			mcpError: e.mcpError
+		}));
+	}
+	peek(id) {
+		const e = state().entries.get(id);
+		if (!e) throw new BrowserRegistryRefusal("NO_SESSION", "no such browser session");
+		return e;
+	}
+	/** The brain's live SSE URL — the ACTUAL bound port (stable 9515 in the
+	*  common case, session-relative in the rare fallback). */
+	mcpBrainUrl(id) {
+		const e = this.peek(id);
+		return "http://127.0.0.1:" + (e.mcpInProcess?.port ?? e.brainPort) + "/sse";
+	}
+	/** True when the id was closed (tombstoned) — routes use it to answer
+	*  409 CLOSED instead of a misleading 404. */
+	isClosed(id) {
+		return state().closed.has(id);
+	}
+	/** Re-bind lookup (ADR-0030 D1): does this persisted id still own a live
+	*  session? Pure read — never creates, never throws. */
+	findLive(id) {
+		if (!id) return false;
+		return state().entries.has(id) && !state().closed.has(id);
+	}
+	/** Reaper inputs — the routes call these so the registry never imports a
+	*  route (the wiring-point rule stays one-directional). */
+	noteStreamOpen(id) {
+		const e = state().entries.get(id);
+		if (e) e.streamSubscribers += 1;
+	}
+	noteStreamClose(id) {
+		const e = state().entries.get(id);
+		if (e) e.streamSubscribers = Math.max(0, e.streamSubscribers - 1);
+	}
+	noteMcpTraffic(id) {
+		const e = state().entries.get(id);
+		if (e) e.lastMcpActivity = Date.now();
+	}
+	/** The idle reaper (ADR-0030 D2): a SAFETY NET, never the owner. A
+	*  session with zero stream subscribers and no MCP tool traffic for
+	*  `browser.idleMs` is closed through the SAME idempotent close(id) the
+	*  panel-close click uses. Headless-default makes this a correctness
+	*  requirement: an invisible browser must not outlive its last driver. */
+	ensureReaper(idleMs) {
+		const s = state();
+		if (s.reaperTimer) return;
+		s.reaperTimer = setInterval(() => {
+			const now = Date.now();
+			for (const e of state().entries.values()) {
+				if (!reaperEligible(e, idleMs, now)) continue;
+				this.close(e.id).catch(() => void 0);
+			}
+		}, Math.min(idleMs / 2, 3e4));
+		s.reaperTimer.unref?.();
+	}
+	/** The ACTIVE tab's relay — what the stream route binds (ADR-0040 D2). */
+	relay(id) {
+		const e = this.peek(id);
+		const h = e.activeTargetId ? e.tabs.get(e.activeTargetId) : null;
+		if (!h) throw new BrowserRegistryRefusal("CLOSED", "no active tab handle");
+		return h.relay;
+	}
+	/** Resolve a verb's target handle: explicit targetId, else the active tab
+	*  (ADR-0040 D3 — one verb seam, optional pointer). An ENUMERATED but
+	*  not-yet-attached target attaches lazily here — attach is not stream
+	*  (D1): verbs may reach any tab the strip can list. */
+	async handleOf(e, targetId) {
+		const key = targetId ?? e.activeTargetId ?? void 0;
+		if (!key) throw new BrowserRegistryRefusal("NO_TARGET", "no active tab");
+		const have = e.tabs.get(key);
+		if (have) return have;
+		for (let attempt = 0; attempt < 5 && !e.tabs.has(key); attempt += 1) {
+			if (attempt > 0) await new Promise((r) => setTimeout(r, 400));
+			for (const page of e.context.pages()) {
+				const scdp = await e.context.newCDPSession(page);
+				let tid = null;
+				try {
+					tid = (await scdp.send("Target.getTargetInfo")).targetInfo?.targetId ?? null;
+				} catch {}
+				if (!tid || e.tabs.has(tid)) {
+					await scdp.detach().catch(() => void 0);
+					continue;
+				}
+				const cfg = readBrowserConfig();
+				const handle = {
+					targetId: tid,
+					cdp: scdp,
+					relay: new BrowserRelay(scdp, cfg.screencastQuality, cfg.screencastMaxFps),
+					page
+				};
+				this.applyPanelViewport(e, handle).catch(() => void 0);
+				await scdp.send("Page.enable").catch(() => void 0);
+				await this.applyPanelViewport(e, {
+					cdp: scdp,
+					relay: handle.relay,
+					page
+				}).catch(() => void 0);
+				e.tabs.set(tid, handle);
+				if (tid === key) break;
+			}
+		}
+		const h = e.tabs.get(key);
+		if (!h) throw new BrowserRegistryRefusal("NO_TARGET", "no such tab: " + key);
+		return h;
+	}
+	/** Enumerate the context's page targets (ADR-0040 D5 feed) — type:page
+	*  only; iframes/omnibox/service workers are chrome noise (wire capture
+	*  2026-10-24). Read-only: never attaches, never streams (D1). */
+	async listTabs(id) {
+		const e = this.peek(id);
+		const src = (e.activeTargetId ? e.tabs.get(e.activeTargetId) : null)?.cdp ?? [...e.tabs.values()][0]?.cdp;
+		if (!src) return [];
+		return ((await src.send("Target.getTargets").catch(() => null))?.targetInfos ?? []).filter((t) => t.type === "page").map((t) => ({
+			targetId: t.targetId,
+			url: t.url,
+			title: t.title,
+			active: t.targetId === e.activeTargetId
+		}));
+	}
+	/** Attach (lazily), seed the first frame, re-apply the viewport, and move
+	*  the active pointer (ADR-0040 D1/D2/D4). The OLD active relay pauses —
+	*  only the active tab streams. Returns the boundary payload. */
+	async activate(id, targetId) {
+		const e = this.peek(id);
+		if (e.closed) throw new BrowserRegistryRefusal("CLOSED", "session is closing");
+		const h = await this.handleOf(e, targetId);
+		const old = e.activeTargetId ? e.tabs.get(e.activeTargetId) : null;
+		if (old && old.targetId !== targetId) await old.relay.pause().catch(() => void 0);
+		await h.cdp.send("Page.enable").catch(() => void 0);
+		await this.applyPanelViewport(e, h);
+		await h.cdp.send("Page.bringToFront").catch(() => void 0);
+		await h.relay.ensureStreaming().catch(() => void 0);
+		if (h.relay.latestFrame() === null) for (let i = 0; i < 10 && h.relay.latestFrame() === null; i += 1) await new Promise((r) => setTimeout(r, 100));
+		if (h.relay.latestFrame() === null) {
+			const cfg = readBrowserConfig();
+			const shot = await h.cdp.send("Page.captureScreenshot", {
+				format: "jpeg",
+				quality: cfg.screencastQuality
+			}).catch(() => null);
+			if (shot?.data) h.relay.seed({
+				seq: 0,
+				jpeg: shot.data,
+				metadata: { seeded: true }
+			});
+		}
+		e.activeTargetId = targetId;
+		let url = "";
+		let title = "";
+		try {
+			const pi = await this.pageInfo(id, targetId);
+			url = pi.url;
+			title = pi.title;
+		} catch {}
+		return {
+			targetId,
+			seq: h.relay.latestFrame()?.seq ?? 0,
+			jpeg: h.relay.latestFrame()?.jpeg ?? null,
+			url,
+			title
+		};
+	}
+	async open(options = {}) {
+		const cfg = readBrowserConfig();
+		const id = randomUUID();
+		const port = freePort(options.port);
+		const profileDir = join(cfg.profileRoot, id.slice(0, 8));
+		mkdirSync(profileDir, { recursive: true });
+		const ignoreDefaultArgs = ["--enable-automation", "--mute-audio"];
+		const launch = (useChrome) => chromium.launchPersistentContext(profileDir, {
+			...useChrome ? { channel: "chrome" } : {},
+			headless: options.headless ?? cfg.headless,
+			ignoreDefaultArgs,
+			args: [
+				"--remote-debugging-port=" + port,
+				"--no-first-run",
+				"--disable-blink-features=AutomationControlled",
+				"--disable-features=IsolateOrigins,site-per-process",
+				"--disable-dev-shm-usage",
+				"--disable-backgrounding-occluded-windows",
+				"--disable-renderer-backgrounding",
+				"--disable-background-timer-throttling",
+				"--autoplay-policy=no-user-gesture-required",
+				"--window-position=-32000,-32000",
+				"--window-size=" + (Math.max(200, Math.min(1920, options.width ?? 730)) + 6) + "," + (Math.max(120, Math.min(1080, options.height ?? 830)) + 70)
+			],
+			viewport: options.headless ?? cfg.headless ? {
+				width: Math.max(200, Math.min(1920, options.width ?? 730)),
+				height: Math.max(120, Math.min(1080, options.height ?? 830))
+			} : null,
+			userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+			timezoneId: "America/New_York",
+			locale: "en-US"
+		});
+		let context;
+		try {
+			context = await launch(true);
+		} catch (chromeErr) {
+			context = await launch(false);
+		}
+		context.browser();
+		const pid = pidOfPort(port);
+		const cdp = await context.newCDPSession(context.pages()[0] ?? await context.newPage());
+		const relay = new BrowserRelay(cdp, cfg.screencastQuality, cfg.screencastMaxFps);
+		const tabs = /* @__PURE__ */ new Map();
+		let activeTargetId = null;
+		try {
+			activeTargetId = (await cdp.send("Target.getTargetInfo")).targetInfo?.targetId ?? null;
+		} catch {}
+		if (activeTargetId) tabs.set(activeTargetId, {
+			targetId: activeTargetId,
+			cdp,
+			relay,
+			page: context.pages()[0]
+		});
+		await relay.start();
+		const start = options.url ?? "data:text/html,<title>Glass Browser</title><body style=\"font-family:system-ui;color:gray;display:grid;place-items:center;height:100vh;margin:0\">Glass Browser — waiting for the agent</body>";
+		await cdp.send("Page.enable").catch(() => void 0);
+		await cdp.send("Page.navigate", { url: start }).catch(() => void 0);
+		await new Promise((r) => setTimeout(r, 600));
+		if (relay.latestFrame() === null) for (let i = 0; i < 10 && relay.latestFrame() === null; i += 1) await new Promise((r) => setTimeout(r, 100));
+		if (relay.latestFrame() === null) {
+			const shot = await cdp.send("Page.captureScreenshot", {
+				format: "jpeg",
+				quality: cfg.screencastQuality
+			}).catch(() => null);
+			if (shot) relay.seed({
+				seq: 0,
+				jpeg: shot.data,
+				metadata: { seeded: true }
+			});
+		}
+		const brainPort = Number(process.env.DSI_MCP_PORT ?? cfg.brainPort);
+		if (cfg.enabled) this.ensureReaper(cfg.idleMs);
+		const entry = {
+			id,
+			context,
+			tabs,
+			activeTargetId,
+			viewport: {
+				width: Math.max(200, Math.min(1920, options.width ?? 730)),
+				height: Math.max(120, Math.min(1080, options.height ?? 830))
+			},
+			headless: options.headless ?? cfg.headless,
+			port,
+			pid,
+			profileDir,
+			brainPort,
+			streamSubscribers: 0,
+			lastMcpActivity: Date.now(),
+			mcpChild: null,
+			mcpInProcess: null,
+			mcpHealth: "up",
+			mcpError: null,
+			closed: false,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		state().entries.set(id, entry);
+		if (options.spawnMcp ?? true) {
+			if (process.env.DSI_MCP_IN_PROCESS === "1") {
+				evictBrainPort(brainPort, id);
+				try {
+					entry.mcpInProcess = await startInProcessMcp(entry.port, brainPort, () => {
+						entry.lastMcpActivity = Date.now();
+					});
+				} catch (e) {
+					entry.mcpHealth = "down";
+					entry.mcpError = e.message;
+				}
+			} else this.spawnMcpChild(entry, cfg.mcpPin);
+		}
+		return {
+			id,
+			port,
+			pid,
+			profileDir,
+			createdAt: entry.createdAt,
+			mcp: entry.mcpChild ? "child" : entry.mcpInProcess ? "in-process" : "none",
+			mcpHealth: entry.mcpHealth,
+			mcpError: entry.mcpError
+		};
+	}
+	/** Wave 3 (3.1) owns the real arg matrix; Wave 1 wires the spawn so close
+	*  ordering (mcp child → cdp → browser) is pinned from day one. */
+	spawnMcpChild(entry, mcpPin) {
+		const child = spawn("npx", [
+			"@playwright/mcp@" + mcpPin,
+			"--cdp-endpoint",
+			"http://127.0.0.1:" + entry.port
+		], {
+			stdio: "ignore",
+			detached: false
+		});
+		entry.mcpChild = child;
+		child.on("error", (e) => {
+			entry.mcpHealth = "down";
+			entry.mcpError = String(e);
+		});
+		child.on("exit", (code) => {
+			if (entry.mcpChild === child) {
+				entry.mcpHealth = "down";
+				entry.mcpError = "mcp child exited code " + code;
+			}
+		});
+	}
+	/** D8 owner-release. Idempotent: closing a closed id resolves cleanly. */
+	async close(id) {
+		const entry = state().entries.get(id);
+		if (!entry) return {
+			ok: true,
+			alreadyClosed: true
+		};
+		if (entry.closed) {
+			state().entries.delete(id);
+			return {
+				ok: true,
+				alreadyClosed: true
+			};
+		}
+		entry.closed = true;
+		state().closed.add(id);
+		if (state().closed.size > 256) state().closed.delete(state().closed.values().next().value);
+		const errs = [];
+		if (entry.mcpInProcess) try {
+			const brain = entry.mcpInProcess;
+			await new Promise((res) => {
+				brain.httpServer?.closeAllConnections?.();
+				brain.httpServer?.close?.(() => res());
+				setTimeout(res, 2e3);
+			});
+			await brain.connection?.close?.();
+			entry.mcpInProcess = null;
+		} catch (e) {
+			errs.push(e);
+		}
+		if (entry.mcpChild?.pid) try {
+			entry.mcpChild.kill("SIGTERM");
+		} catch (e) {
+			errs.push(e);
+		}
+		try {
+			for (const h of entry.tabs.values()) h.relay.stop();
+			entry.tabs.clear();
+		} catch (e) {
+			errs.push(e);
+		}
+		try {
+			await entry.context.close();
+		} catch (e) {
+			errs.push(e);
+		}
+		try {
+			rmSync(entry.profileDir, {
+				recursive: true,
+				force: true
+			});
+		} catch (e) {
+			errs.push(e);
+		}
+		state().entries.delete(id);
+		return {
+			ok: errs.length === 0,
+			alreadyClosed: false
+		};
+	}
+	/** Wait for the page's next load event, capped — the navigate idiom
+	*  (a send races the context teardown otherwise) shared by reload and
+	*  history travel (ADR-0031 D3/D4). */
+	async waitLoad(h, capMs = 3e3) {
+		await new Promise((res) => {
+			const on = (p) => {
+				h.cdp.off("Page.loadEventFired", on);
+				res();
+			};
+			h.cdp.on("Page.loadEventFired", on);
+			setTimeout(res, capMs);
+		});
+	}
+	/** Navigate the session's active page — public because causing page
+	*  damage is the only reliable way to make screencast emit a frame. */
+	async navigate(id, url, opts) {
+		const e = this.peek(id);
+		const h = await this.handleOf(e, opts?.targetId);
+		await h.cdp.send("Page.enable").catch(() => void 0);
+		if (opts?.waitLoad) {
+			const loaded = this.waitLoad(h);
+			await h.cdp.send("Page.navigate", { url });
+			await loaded;
+			return;
+		}
+		await h.cdp.send("Page.navigate", { url });
+	}
+	/** Match the page viewport to the panel's glass box (ADR-0031
+	*  amendment 2): the screencast frame then equals the panel size, so
+	*  the mirror shows content at native scale instead of zooming a
+	*  fixed default viewport. CDP-side clamps keep hostile sizes out. */
+	async setViewport(id, width, height, targetId) {
+		console.log("[viewport] set", id.slice(0, 8), width + "x" + height, "target", targetId ?? "active");
+		const w = Math.max(200, Math.min(8192, Math.round(width)));
+		const h = Math.max(120, Math.min(8192, Math.round(height)));
+		const e = this.peek(id);
+		e.viewport = {
+			width: w,
+			height: h
+		};
+		const handle = await this.handleOf(e, targetId);
+		await handle.cdp.send("Page.enable").catch(() => void 0);
+		const prevSeq = handle.relay.latestFrame()?.seq ?? -1;
+		await this.applyPanelViewport(e, handle);
+		await this.seedAfterResize(handle, prevSeq).catch(() => void 0);
+	}
+	/** ADR-0041 D3: a resize must REPAINT, not wait for the next page
+	*  change — the screencast speaks only on change, so a static page
+	*  keeps the old-aspect frame letterboxed on the panel forever (the
+	*  operator's black bands, 2026-10-25). Bounded grace for a FRESH
+	*  frame (seq past prevSeq); silence answers with the deterministic
+	*  captureScreenshot seed — activate()'s first-frame idiom re-fired
+	*  for the resize path. Never hangs the verb past the grace. */
+	async seedAfterResize(handle, prevSeq) {
+		for (let i = 0; i < 10 && (handle.relay.latestFrame()?.seq ?? -1) === prevSeq; i += 1) await new Promise((r) => setTimeout(r, 100));
+		if ((handle.relay.latestFrame()?.seq ?? -1) !== prevSeq) return;
+		const cfg = readBrowserConfig();
+		const shot = await handle.cdp.send("Page.captureScreenshot", {
+			format: "jpeg",
+			quality: cfg.screencastQuality
+		}).catch(() => null);
+		if (shot?.data) handle.relay.seed({
+			seq: 0,
+			jpeg: shot.data,
+			metadata: {
+				seeded: true,
+				resize: true
+			}
+		});
+	}
+	/** The history position (ADR-0031): every proxy-verb answer carries it
+	*  so the header's back/forward buttons stay honest at the ends. */
+	async navInfo(id, targetId) {
+		const e = this.peek(id);
+		const h = await this.handleOf(e, targetId);
+		await h.cdp.send("Page.enable").catch(() => void 0);
+		const hist = await h.cdp.send("Page.getNavigationHistory", {});
+		return {
+			currentIndex: hist.currentIndex,
+			entryCount: hist.entries.length
+		};
+	}
+	/** Reload the session's active page (ADR-0031 D4): Page.reload keeps
+	*  the history entry, unlike re-navigating the current URL. */
+	async reload(id, targetId) {
+		const e = this.peek(id);
+		const h = await this.handleOf(e, targetId);
+		await h.cdp.send("Page.enable").catch(() => void 0);
+		const loaded = this.waitLoad(h);
+		await h.cdp.send("Page.reload", {});
+		await loaded;
+		return this.pageInfo(id, targetId);
+	}
+	/** Travel the browser's OWN back/forward list (ADR-0031 D3):
+	*  Page.getNavigationHistory picks the entry, Page.navigateToHistoryEntry
+	*  is the browser's travel verb — never Runtime.evaluate('history.back()'),
+	*  which races the teardown and lies about the browser-level list.
+	*  Bounds refusals keep the header buttons honest at the list ends. */
+	async pageHistory(id, dir, targetId) {
+		const e = this.peek(id);
+		const h = await this.handleOf(e, targetId);
+		await h.cdp.send("Page.enable").catch(() => void 0);
+		const hist = await h.cdp.send("Page.getNavigationHistory", {});
+		const target = dir === "back" ? hist.currentIndex - 1 : hist.currentIndex + 1;
+		if (target < 0 || target >= hist.entries.length) throw new BrowserRegistryRefusal("CLOSED", "HISTORY_END — cannot go " + dir + " from index " + hist.currentIndex + " of " + hist.entries.length);
+		const loaded = this.waitLoad(h);
+		await h.cdp.send("Page.navigateToHistoryEntry", { entryId: hist.entries[target].id });
+		await loaded;
+		return {
+			...await this.pageInfo(id, targetId),
+			currentIndex: target,
+			entryCount: hist.entries.length
+		};
+	}
+	/** Race an evaluate against a cap — a hung evaluate must never wedge a
+	*  route (the navigate-hang finding, spec W2 2.3 debugging). */
+	async evaluateCapped(cdp, expr, capMs = 3e3) {
+		let timer;
+		const cap = new Promise((res) => {
+			timer = setTimeout(() => res(null), capMs);
+		});
+		try {
+			const res = await Promise.race([cdp.send("Runtime.evaluate", {
+				expression: expr,
+				returnByValue: true
+			}), cap]);
+			return res ? String(res.result?.value ?? "") : null;
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	}
+	/** The active page's url + title + inner viewport — the status strip's
+	*  location read, the e2e's DOM-truth channel (the glass proves clicks
+	*  by effects the page itself reports), and the viewport-follow witness
+	*  (innerWidth/innerHeight prove the emulation landed, amend 2). */
+	async pageInfo(id, targetId) {
+		const e = this.peek(id);
+		const h = await this.handleOf(e, targetId);
+		const raw = await this.evaluateCapped(h.cdp, "JSON.stringify({ url: location.href, title: document.title, dpr: window.devicePixelRatio, innerWidth: window.innerWidth, innerHeight: window.innerHeight, playerError: (document.querySelector(\".ytp-error-content-wrap-reason, .ytp-error-content, [role=alert]\")?.textContent || \"\").trim() || null, mediaErrorCode: (document.querySelector(\"video\")?.error?.code) ?? null })", 3e3);
+		if (raw === null) return {
+			url: "(busy)",
+			title: "(busy)",
+			dpr: 1,
+			innerWidth: 0,
+			innerHeight: 0,
+			playerError: null,
+			mediaErrorCode: null
+		};
+		return JSON.parse(raw);
+	}
+	/** The page element under viewport coords — the glass context menu's
+	*  data pass (BUGFIX 2026-10-25: Chrome's NATIVE right-click menu is
+	*  browser UI and never renders in the screencast, so DSI supplies its
+	*  own menu; this tells it what the right-click landed on). */
+	async elementAt(id, x, y, targetId) {
+		const e = this.peek(id);
+		const h = await this.handleOf(e, targetId);
+		const expr = "JSON.stringify((() => { const el = document.elementFromPoint(" + Number(x) + "," + Number(y) + "); if (!el) return { href: null, src: null, text: null }; const a = el.closest(\"a\"); const img = el.closest(\"img\"); return { href: a ? a.href : null, src: img ? (img.currentSrc || img.src) : null, text: (a && a.textContent || \"\").trim().slice(0, 80) || null }; })())";
+		const raw = await this.evaluateCapped(h.cdp, expr, 2e3);
+		if (raw === null) return {
+			href: null,
+			src: null,
+			text: null
+		};
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return {
+				href: null,
+				src: null,
+				text: null
+			};
+		}
+	}
+	/** Open a NEW tab in the glass at `url` and make it the active face
+	*  (the context menu's 'open in new tab' verbs). Returns the new tab. */
+	async openTab(id, url, opts) {
+		const e = this.peek(id);
+		if (e.closed) throw new BrowserRegistryRefusal("CLOSED", "session is closing");
+		const src = (e.activeTargetId ? e.tabs.get(e.activeTargetId) : null)?.cdp ?? [...e.tabs.values()][0]?.cdp;
+		if (!src) throw new BrowserRegistryRefusal("CLOSED", "no tab handle to create from");
+		const targetId = (await src.send("Target.createTarget", { url: "about:blank" }))?.targetId;
+		if (!targetId) throw new BrowserRegistryRefusal("NO_TARGET", "Target.createTarget returned no id");
+		await this.navigate(id, url, {
+			waitLoad: true,
+			targetId
+		});
+		if (opts?.activate ?? true) await this.activate(id, targetId);
+		const h = e.tabs.get(targetId);
+		const pi = await this.pageInfo(id, targetId).catch(() => ({
+			url,
+			title: ""
+		}));
+		return {
+			targetId,
+			seq: h?.relay.latestFrame()?.seq ?? 0,
+			jpeg: h?.relay.latestFrame()?.jpeg ?? null,
+			url: pi.url || url,
+			title: pi.title
+		};
+	}
+	/** Apply the remembered panel viewport by RESIZING THE WINDOW (round 10:
+	*  emulation-on-headed renders the page centered in the big off-screen
+	*  window — the small/cut-off mirror). Also clears any stale override. */
+	/** Resize the glass's WINDOW to the panel size and clear emulation.
+	*  ROUND 10 (the REAL small/cut-off root cause, headed-proven):
+	*  Emulation.setDeviceMetricsOverride on HEADED chrome renders the
+	*  emulated viewport CENTERED INSIDE the physical off-screen window
+	*  (black around it) and the screencast captures the whole window —
+	*  the mirror shows a tiny page. Resizing the WINDOW itself makes the
+	*  page fill it natively; the panel is the window's face (ADR-0029 D1).
+	*  Re-asserted on every attach/switch/setViewport (round 11: something
+	*  re-expands the window — the mirror shrinks again — so this is now
+	*  idempotent and called from all three paths). */
+	async applyPanelViewport(e, handle) {
+		await handle.cdp.send("Page.enable").catch(() => void 0);
+		if (e.headless && handle.page) {
+			await Promise.race([handle.page.setViewportSize({
+				width: e.viewport.width,
+				height: e.viewport.height
+			}).catch(() => void 0), new Promise((res) => setTimeout(res, 2500))]);
+			return;
+		}
+		const race = async (p, fb) => await Promise.race([p.catch(() => fb), new Promise((res) => setTimeout(() => res(fb), 2500))]);
+		const anyCdp = handle.cdp;
+		const dims = await race(anyCdp.send("Runtime.evaluate", {
+			expression: "JSON.stringify({ oh: window.outerHeight - window.innerHeight, ow: window.outerWidth - window.innerWidth })",
+			returnByValue: true
+		}), null);
+		let chromeH = 0, chromeW = 0;
+		try {
+			const d = JSON.parse(dims && dims.result && dims.result.value || "{}");
+			chromeH = Number(d.oh) || 0;
+			chromeW = Number(d.ow) || 0;
+		} catch {}
+		const anyCdp2 = handle.cdp;
+		const win = await race(anyCdp2.send("Target.getWindowForTarget"), null);
+		if (win && win.windowId) {
+			await race(anyCdp2.send("Browser.setWindowBounds", {
+				windowId: win.windowId,
+				bounds: {
+					width: Math.max(200, e.viewport.width + chromeW),
+					height: Math.max(120, e.viewport.height + chromeH),
+					windowState: "normal"
+				}
+			}), null);
+			const check = await race(anyCdp2.send("Browser.getWindowForTarget", { targetId: e.activeTargetId }), null);
+			console.log("[window] resized ->", JSON.stringify(check && check.bounds ? check.bounds : check), "want", e.viewport.width + chromeW, "x", e.viewport.height + chromeH);
+		} else console.log("[window] no windowId — resize skipped (raced out)");
+		await race(anyCdp2.send("Emulation.clearDeviceMetricsOverride"), null);
+	}
+	/** Close ONE tab (the strip X): Target.closeTarget, stop its relay,
+	*  drop the handle — and if it was the active face, the pointer moves
+	*  to the first surviving tab (re-activated, first-frame contract
+	*  re-fired). Closing the LAST tab is refused: the kill ladder owns
+	*  session death (the trash is the operator-facing kill). */
+	async closeTab(id, targetId) {
+		const e = this.peek(id);
+		if (e.closed) throw new BrowserRegistryRefusal("CLOSED", "session is closing");
+		if (e.tabs.size <= 1) throw new BrowserRegistryRefusal("NO_TARGET", "cannot close the last tab — use the trash to close the glass");
+		const victim = e.tabs.get(targetId);
+		if (!victim) throw new BrowserRegistryRefusal("NO_TARGET", "no such tab: " + targetId);
+		victim.relay.stop();
+		e.tabs.delete(targetId);
+		await victim.cdp.send("Target.closeTarget", { targetId }).catch(() => void 0);
+		await victim.cdp.detach().catch(() => void 0);
+		if (e.activeTargetId === targetId) {
+			const next = [...e.tabs.keys()][0] ?? null;
+			e.activeTargetId = next;
+			if (next) await this.activate(id, next).catch(() => void 0);
+			else e.activeTargetId = null;
+		}
+		return {
+			ok: true,
+			activeTargetId: e.activeTargetId
+		};
+	}
+	async dispatch(id, input, targetId) {
+		if (!state().entries.has(id) && state().closed.has(id)) throw new BrowserRegistryRefusal("CLOSED", "session was closed");
+		const e = this.peek(id);
+		if (e.closed) throw new BrowserRegistryRefusal("CLOSED", "session is closing");
+		await (await this.handleOf(e, targetId)).relay.dispatch(input);
+	}
+};
+var browserRegistry = new BrowserRegistry();
+
+export { BrowserRegistryRefusal as B, browserRegistry as b };
+//# sourceMappingURL=registry.js-C2MdrfNv.js.map