@deepseek-insight/dsi 0.8.5 → 0.9.0

package/build/server/chunks/chunks/{registry.js-syaTZ_-A.js → registry.js-CWnRQ4vx.js}

@@ -1,4 +1,4 @@
-import { d as readBrowserConfig } from './insight-config.js-Db5fe5Df.js';
+import { d as readBrowserConfig } from './insight-config.js-C5-Rhh5A.js';
 import { mkdirSync, rmSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
@@ -157,6 +157,29 @@ var BrowserRelay = class {
 	}
 };
 Number(process.env.DSI_MCP_PORT ?? 9515);
+/** Layout-scale zoom (ADR-0041 amendment, 2026-10-31): the zoom knob is
+*  LAYOUT SCALE — the emulated viewport is the panel box divided by the
+*  zoom, and the mirror's contain-fit does the visual shrinking. The page
+*  keeps ONE coordinate space (no CSS zoom), so every consumer's own
+*  geometry math — YouTube's seek preview included — stays truthful.
+*  Rejected: documentElement CSS zoom (the 2026-10-28..31 implementation) —
+*  Chromium hit-testing stayed correct but the PAGE's own width perception
+*  split in two, and YouTube's player computed seek previews at exactly
+*  the zoom factor off (54:58 vs 1:08:44 at 0.8). */
+function layoutViewport(width, height, zoom) {
+	const z = zoom > 0 ? zoom : 1;
+	return {
+		width: Math.max(200, Math.min(8192, Math.round(width / z))),
+		height: Math.max(120, Math.min(8192, Math.round(height / z)))
+	};
+}
+/** Live zoom slider (2026-10-28): the slider's wire bounds — null when the
+*  value is not a finite number in 0.5..1.25 (the route answers 400). */
+function clampZoom(z) {
+	if (typeof z !== "number" || !Number.isFinite(z)) return null;
+	if (z < .5 || z > 1.25) return null;
+	return z;
+}
 /** 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). */
@@ -164,6 +187,100 @@ function reaperEligible(e, idleMs, now) {
 	if (e.streamSubscribers > 0) return false;
 	return now - e.lastMcpActivity >= idleMs;
 }
+/** Mint the next ordinal for targetId (idempotent: an already-minted
+*  targetId returns its existing ordinal — lazy attach and heal re-enter). */
+function mintTabId(entry, targetId) {
+	const tabIds = entry.tabIds ??= /* @__PURE__ */ new Map();
+	for (const [ord, tid] of tabIds) if (tid === targetId) return ord;
+	entry.nextTabId ??= 1;
+	const ord = entry.nextTabId;
+	entry.nextTabId = ord + 1;
+	entry.tabIds.set(ord, targetId);
+	return ord;
+}
+/** ADR-0040 Amendment 4 (D-A5): the OWNER hand claims a newborn. Called
+*  from the entry's own context 'page' listener — a claimed targetId is
+*  owner-born no matter what the browser-level watcher saw first. Pure. */
+function claimOwnerBirth(entry, targetId) {
+	(entry.ownBirths ??= /* @__PURE__ */ new Set()).add(targetId);
+}
+/** ADR-0040 Amendment 4 (D-A6): a GUEST birth is a citizen without the
+*  throne — mint an ordinal, append tabOrder (lands LAST), and NEVER move
+*  the active pointer (appear without stealing focus). Guards: closed
+*  sessions refuse; a target the entry already knows (or the owner hand
+*  claimed) is a no-op. Pure. Returns true when the guest was admitted. */
+function admitGuestBirth(e, targetId) {
+	if (e.closed) return false;
+	if (e.ownBirths?.has(targetId)) return false;
+	if (e.tabOrder.includes(targetId) || e.tabs.has(targetId)) return false;
+	e.tabOrder.push(targetId);
+	mintTabId(e, targetId);
+	return true;
+}
+/** Retire a closed tab: drop both map sides. The ordinal itself is gone —
+*  mintTabId never hands it out again. */
+function retireTabId(entry, targetId) {
+	if (!entry.tabIds) return;
+	for (const [ord, tid] of entry.tabIds) if (tid === targetId) {
+		entry.tabIds.delete(ord);
+		return;
+	}
+}
+/** HEAL PRESERVES ORDINALS: healHandles swaps a dead CDP handle for a
+*  fresh session — the tab's ordinal must survive with its value
+*  rewritten to the new targetId. An unknown page (first sight during
+*  heal) falls back to a fresh mint. */
+function healPreserveOrdinal(entry, oldTargetId, newTargetId) {
+	const tabIds = entry.tabIds ??= /* @__PURE__ */ new Map();
+	for (const [ord, tid] of tabIds) if (tid === oldTargetId) {
+		entry.tabIds.set(ord, newTargetId);
+		return ord;
+	}
+	return mintTabId(entry, newTargetId);
+}
+/** Resolve a tab reference — ordinal (number / numeric string), the
+*  'active' pointer, or a raw targetId — to { targetId, tabId }. A
+*  retired or unknown ordinal is an EXPLICIT error: no silent
+*  nearest-match (glass-tab-ids global constraint). */
+function resolveTab(entry, ref) {
+	if (ref === "active") {
+		if (!entry.activeTargetId) return {
+			ok: false,
+			error: "no active tab"
+		};
+		for (const [ord, tid] of entry.tabIds ?? []) if (tid === entry.activeTargetId) return {
+			ok: true,
+			targetId: tid,
+			tabId: ord
+		};
+		return {
+			ok: false,
+			error: "active tab has no ordinal: " + entry.activeTargetId
+		};
+	}
+	if (typeof ref === "number" || /^\d+$/.test(ref)) {
+		const ord = Number(ref);
+		const tid = entry.tabIds?.get(ord);
+		if (tid === void 0) return {
+			ok: false,
+			error: "unknown or retired tab ordinal: " + ord
+		};
+		return {
+			ok: true,
+			targetId: tid,
+			tabId: ord
+		};
+	}
+	for (const [ord, tid] of entry.tabIds ?? []) if (tid === ref) return {
+		ok: true,
+		targetId: tid,
+		tabId: ord
+	};
+	return {
+		ok: false,
+		error: "unknown tab: " + ref
+	};
+}
 var BrowserRegistryRefusal = class extends Error {
 	code;
 	constructor(code, message) {
@@ -190,10 +307,52 @@ function state() {
 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
-		});
+		for (const name of readdirSync(root)) {
+			if (keep.has(name)) continue;
+			if (!process.env.VITEST) killOrphanChrome(name, {
+				listPids: () => spawnSync("ps", ["axo", "pid=,command="], {
+					encoding: "utf8",
+					timeout: 5e3
+				}).stdout ?? "",
+				killPid: (pid, sig) => process.kill(pid, sig)
+			});
+			rmSync(join(root, name), {
+				recursive: true,
+				force: true
+			});
+		}
+	} catch {}
+}
+/** Ghost Glass Fix 3 (RCA 2026-10-31 Bug 3): PURE matcher — which process
+*  rows hold a Chrome --user-data-dir that ENDS at the swept profile name?
+*  The name must terminate the dir (path separator before it, end/space
+*  after it), so a PREFIX-sharing sibling profile never matches. */
+function orphanChromePids(psOutput, profileName) {
+	const needle = "--user-data-dir=";
+	const pids = [];
+	for (const line of psOutput.split("\n")) {
+		const at = line.indexOf(needle);
+		if (at === -1) continue;
+		const rest = line.slice(at + 16);
+		const end = rest.search(/[\s"']/);
+		if (!(end === -1 ? rest : rest.slice(0, end)).replace(/\/+$/, "").endsWith("/" + profileName)) continue;
+		const pid = Number.parseInt(line.trimStart(), 10);
+		if (Number.isFinite(pid)) pids.push(pid);
+	}
+	return pids;
+}
+/** Ghost Glass Fix 3: the sweep kill arm with the OS injected — SIGKILL
+*  every holder of the profile dir. Best-effort both ways: a failed ps
+*  listing or an already-dead pid (ESRCH) never blocks the dir sweep. */
+function killOrphanChrome(profileName, deps) {
+	let out;
+	try {
+		out = deps.listPids();
+	} catch {
+		return;
+	}
+	for (const pid of orphanChromePids(out, profileName)) try {
+		deps.killPid(pid, "SIGKILL");
 	} catch {}
 }
 /** Brain re-homing (BUGFIX 2026-10-25): release the stable brain port
@@ -313,6 +472,7 @@ var BrowserRegistry = class {
 			pid: e.pid,
 			profileDir: e.profileDir,
 			createdAt: e.createdAt,
+			ownerSessionId: e.ownerSessionId ?? null,
 			mcp: e.mcpChild ? "child" : e.mcpInProcess ? "in-process" : "none",
 			mcpHealth: e.mcpHealth,
 			mcpError: e.mcpError
@@ -366,7 +526,7 @@ var BrowserRegistry = class {
 			const now = Date.now();
 			for (const e of state().entries.values()) {
 				if (!reaperEligible(e, idleMs, now)) continue;
-				this.close(e.id).catch(() => void 0);
+				this.close(e.id, "reaped").catch(() => void 0);
 			}
 		}, Math.min(idleMs / 2, 3e4));
 		s.reaperTimer.unref?.();
@@ -381,6 +541,21 @@ var BrowserRegistry = class {
 	/** D5 amendment 2026-10-27: watch the active pointer. The stream route
 	*  re-binds its relay on every fire so a brain-driven activate (creation
 	*  auto-focus) repoints the MIRROR, not just the strip highlight. */
+	/** Ghost Glass Fix 2 (RCA 2026-10-31): the death handshake's registry
+	*  side. Subscribers hear ONE reason ('closed' human, 'reaped' reaper);
+	*  subscribing to an already-dead id hears the truth immediately instead
+	*  of polling a ghost. Same shape as onActiveChange. */
+	onDeath(id, cb) {
+		const e = state().entries.get(id);
+		if (!e || e.closed) {
+			cb("closed");
+			return () => void 0;
+		}
+		(e.deathListeners ??= /* @__PURE__ */ new Set()).add(cb);
+		return () => {
+			e.deathListeners?.delete(cb);
+		};
+	}
 	onActiveChange(id, cb) {
 		const e = this.peek(id);
 		(e.activeListeners ??= /* @__PURE__ */ new Set()).add(cb);
@@ -423,7 +598,11 @@ var BrowserRegistry = class {
 					relay: handle.relay,
 					page
 				}).catch(() => void 0);
-				e.tabs.set(tid, handle);
+				const ord = mintTabId(e, tid);
+				e.tabs.set(tid, {
+					...handle,
+					tabId: ord
+				});
 				(e.tabOrder ??= []).push(tid);
 				if (tid === key) break;
 			}
@@ -463,8 +642,10 @@ var BrowserRegistry = class {
 				old.relay.stop();
 				await old.cdp.detach().catch(() => void 0);
 				const cfg = readBrowserConfig();
+				const ord = healPreserveOrdinal(e, tid, tid);
 				e.tabs.set(tid, {
 					targetId: tid,
+					tabId: ord,
 					cdp: scdp,
 					relay: new BrowserRelay(scdp, cfg.screencastQuality, cfg.screencastMaxFps),
 					page
@@ -476,17 +657,73 @@ var BrowserRegistry = class {
 	}
 	/** 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). */
+	*  2026-10-24). Mirror-lifecycle (ADR "The Mirror Must Face a Living
+	*  Tab", D1/D2): enumeration ADOPTS unknown live pages (mint + lazy
+	*  seam — survivors' ordinals never move) and RE-POINTS the active
+	*  pointer when its target is gone, re-seeding the mirror through
+	*  activate's idiom — the panel never faces a corpse (the 2026-10-28
+	*  frozen-frame bug). */
 	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 [];
-		let infos = ((await src.send("Target.getTargets").catch(() => null))?.targetInfos ?? []).filter((t) => t.type === "page");
-		if (infos.length === 0 && e.context.pages().length > 0) {
+		const pickSrc = () => (e.activeTargetId ? e.tabs.get(e.activeTargetId) : null)?.cdp ?? [...e.tabs.values()][0]?.cdp ?? null;
+		const readTargets = async (h) => {
+			return (await h.send("Target.getTargets").catch(() => null))?.targetInfos ?? null;
+		};
+		let src = pickSrc();
+		let infos = (src ? await readTargets(src) : null) ?? [];
+		if (infos === null || infos.length === 0 && e.context.pages().length > 0) {
 			await this.healHandles(e);
-			infos = ((await ((e.activeTargetId ? e.tabs.get(e.activeTargetId) : null)?.cdp ?? [...e.tabs.values()][0]?.cdp)?.send("Target.getTargets").catch(() => null))?.targetInfos ?? []).filter((t) => t.type === "page");
+			src = pickSrc();
+			infos = (src ? await readTargets(src) : null) ?? [];
 		}
-		return infos.map((t) => ({
+		let pages = infos.filter((t) => t.type === "page");
+		if (pages.length === 0 && e.context.pages().length > 0) {
+			const probed = [];
+			for (const page of e.context.pages()) try {
+				const scdp = await e.context.newCDPSession(page);
+				const info = await scdp.send("Target.getTargetInfo");
+				await scdp.detach().catch(() => void 0);
+				if (info.targetInfo?.targetId) probed.push({
+					targetId: info.targetInfo.targetId,
+					type: "page",
+					url: info.targetInfo.url ?? page.url(),
+					title: info.targetInfo.title ?? ""
+				});
+			} catch {
+				continue;
+			}
+			pages = probed;
+		}
+		const known = new Set(e.tabs.keys());
+		const unknown = pages.filter((t) => !known.has(t.targetId));
+		if (unknown.length > 0) {
+			const cfg = readBrowserConfig();
+			for (const page of e.context.pages()) {
+				let tid = null;
+				let scdp = null;
+				try {
+					scdp = await e.context.newCDPSession(page);
+					tid = (await scdp.send("Target.getTargetInfo")).targetInfo?.targetId ?? null;
+				} catch {
+					continue;
+				}
+				if (!tid || !unknown.some((u) => u.targetId === tid)) {
+					await scdp.detach().catch(() => void 0);
+					continue;
+				}
+				const ord = mintTabId(e, tid);
+				if (!e.tabOrder.includes(tid)) e.tabOrder.push(tid);
+				e.tabs.set(tid, {
+					targetId: tid,
+					tabId: ord,
+					cdp: scdp,
+					relay: new BrowserRelay(scdp, cfg.screencastQuality, cfg.screencastMaxFps),
+					page
+				});
+			}
+		}
+		const out = pages.map((t) => ({
+			tabId: mintTabId(e, t.targetId),
 			targetId: t.targetId,
 			url: t.url,
 			title: t.title,
@@ -497,6 +734,14 @@ var BrowserRegistry = class {
 			const ib = order.indexOf(b.targetId);
 			return (ia === -1 ? Infinity : ia) - (ib === -1 ? Infinity : ib);
 		});
+		if (e.activeTargetId && !out.some((r) => r.targetId === e.activeTargetId)) {
+			const survivor = out[0]?.targetId ?? null;
+			if (survivor) {
+				await this.activate(id, survivor).catch(() => void 0);
+				for (const r of out) r.active = r.targetId === e.activeTargetId;
+			} else e.activeTargetId = null;
+		}
+		return out;
 	}
 	/** 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 —
@@ -549,22 +794,25 @@ var BrowserRegistry = class {
 		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 ignoreDefaultArgs = [
+			"--enable-automation",
+			"--mute-audio",
+			"--hide-scrollbars"
+		];
 		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",
+				"--remote-debugging-port=" + port,
 				"--disable-dev-shm-usage",
-				"--disable-backgrounding-occluded-windows",
 				"--disable-renderer-backgrounding",
 				"--disable-background-timer-throttling",
+				"--disable-backgrounding-occluded-windows",
+				"--disable-blink-features=AutomationControlled",
+				"--disable-features=IsolateOrigins,site-per-process",
 				"--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 ? {
@@ -590,12 +838,19 @@ var BrowserRegistry = class {
 		try {
 			activeTargetId = (await cdp.send("Target.getTargetInfo")).targetInfo?.targetId ?? null;
 		} catch {}
-		if (activeTargetId) tabs.set(activeTargetId, {
-			targetId: activeTargetId,
-			cdp,
-			relay,
-			page: context.pages()[0]
-		});
+		const tabIds = /* @__PURE__ */ new Map();
+		let nextTabId = 1;
+		if (activeTargetId) {
+			tabIds.set(1, activeTargetId);
+			nextTabId = 2;
+			tabs.set(activeTargetId, {
+				targetId: activeTargetId,
+				tabId: 1,
+				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);
@@ -613,6 +868,20 @@ var BrowserRegistry = class {
 				metadata: { seeded: true }
 			});
 		}
+		if (options.headless ?? cfg.headless) {
+			const birth = context.pages()[0];
+			if (birth && typeof birth.evaluate === "function") {
+				if (await birth.evaluate(() => {
+					const d = document.createElement("div");
+					d.style.cssText = "position:fixed;left:-100px;top:0;width:50px;height:50px;overflow:auto";
+					d.innerHTML = "<div style=\"width:200px;height:200px\"></div>";
+					document.body.appendChild(d);
+					const f = d.offsetHeight - d.clientHeight;
+					d.remove();
+					return f;
+				}).catch(() => null) === 0) throw new Error("glass scrollbar gate: bar footprint is 0 in a headless launch — --hide-scrollbars leaked past ignoreDefaultArgs (RCA 2026-10-28)");
+			}
+		}
 		const brainPort = Number(process.env.DSI_MCP_PORT ?? cfg.brainPort);
 		if (cfg.enabled) this.ensureReaper(cfg.idleMs);
 		const entry = {
@@ -621,10 +890,13 @@ var BrowserRegistry = class {
 			tabs,
 			activeTargetId,
 			tabOrder: activeTargetId ? [activeTargetId] : [],
+			tabIds,
+			nextTabId,
 			viewport: {
 				width: Math.max(200, Math.min(1920, options.width ?? 730)),
 				height: Math.max(120, Math.min(1080, options.height ?? 830))
 			},
+			zoom: cfg.contentZoom,
 			headless: options.headless ?? cfg.headless,
 			port,
 			pid,
@@ -637,6 +909,8 @@ var BrowserRegistry = class {
 			mcpHealth: "up",
 			mcpError: null,
 			closed: false,
+			ownerSessionId: options.ownerSessionId ?? null,
+			ownBirths: /* @__PURE__ */ new Set(),
 			createdAt: (/* @__PURE__ */ new Date()).toISOString()
 		};
 		state().entries.set(id, entry);
@@ -651,12 +925,36 @@ var BrowserRegistry = class {
 						const tid = info?.targetInfo?.targetId;
 						if (!tid) continue;
 						if (!entry.tabOrder.includes(tid)) entry.tabOrder.push(tid);
-						if (entry.activeTargetId !== tid && !entry.closed) await this.activate(id, tid);
+						mintTabId(entry, tid);
+						claimOwnerBirth(entry, tid);
+						if (entry.activeTargetId !== tid && !entry.closed && !entry.tabs.has(tid)) await this.activate(id, tid);
 						return;
 					} catch {}
 				}
 			})();
 		});
+		try {
+			const browser = context.browser?.();
+			if (browser && typeof browser.newBrowserCDPSession === "function") {
+				const bcdp = await browser.newBrowserCDPSession();
+				entry.browserCdp = bcdp;
+				await bcdp.send("Target.setDiscoverTargets", { discover: true }).catch(() => void 0);
+				bcdp.on("Target.targetCreated", (evt) => {
+					const tid = evt?.targetInfo?.targetId;
+					if (!tid || evt.targetInfo?.type !== "page") return;
+					if (entry.tabOrder.includes(tid) || entry.tabs.has(tid)) return;
+					(async () => {
+						for (let g = 0; g < 10; g += 1) {
+							await new Promise((r) => setTimeout(r, 300));
+							if (entry.closed) return;
+							if (entry.ownBirths?.has(tid)) return;
+							if (entry.tabOrder.includes(tid) || entry.tabs.has(tid)) return;
+						}
+						admitGuestBirth(entry, tid);
+					})();
+				});
+			}
+		} catch {}
 		if (!entry.headless) {
 			await this.applyPanelViewport(entry, {
 				cdp,
@@ -694,6 +992,7 @@ var BrowserRegistry = class {
 			pid,
 			profileDir,
 			createdAt: entry.createdAt,
+			ownerSessionId: entry.ownerSessionId,
 			mcp: entry.mcpChild ? "child" : entry.mcpInProcess ? "in-process" : "none",
 			mcpHealth: entry.mcpHealth,
 			mcpError: entry.mcpError
@@ -723,7 +1022,7 @@ var BrowserRegistry = class {
 		});
 	}
 	/** D8 owner-release. Idempotent: closing a closed id resolves cleanly. */
-	async close(id) {
+	async close(id, reason = "closed") {
 		const entry = state().entries.get(id);
 		if (!entry) return {
 			ok: true,
@@ -738,6 +1037,10 @@ var BrowserRegistry = class {
 		}
 		entry.closed = true;
 		state().closed.add(id);
+		for (const cb of entry.deathListeners ?? []) try {
+			cb(reason);
+		} catch {}
+		await entry.browserCdp?.detach().catch(() => void 0);
 		if (state().closed.size > 256) state().closed.delete(state().closed.values().next().value);
 		const errs = [];
 		if (entry.mcpInProcess) try {
@@ -835,6 +1138,20 @@ var BrowserRegistry = class {
 		await this.applyPanelViewport(e, handle);
 		await this.repairSurfaceAfterResize(e, handle, prevSeq).catch(() => void 0);
 	}
+	/** Layout-scale zoom (ADR-0041 amendment, 2026-10-31): store the session
+	*  scale and re-apply the panel viewport — the emulation is box/zoom, so
+	*  the slider's LIVE effect rides the resize. Bad input (clampZoom null)
+	*  KEEPS the current zoom and returns silently: unreachable from the wire
+	*  (the route's clampZoom already answered 400) — documented keep. */
+	async setZoom(id, zoom) {
+		const e = this.peek(id);
+		if (e.closed) throw new BrowserRegistryRefusal("CLOSED", "session is closing");
+		const clamped = clampZoom(zoom);
+		if (clamped === null) return;
+		e.zoom = clamped;
+		const handle = await this.handleOf(e);
+		await this.applyPanelViewport(e, handle);
+	}
 	/** The window id, retried — Target.getWindowForTarget on a Playwright
 	*  page session races out on a COLD headed launch (measured in the
 	*  surface-lag test: both resizes skipped, the birth window kept its
@@ -869,10 +1186,15 @@ var BrowserRegistry = class {
 	*  the ring, and seed() refuses to cover one). Capped throughout —
 	*  nothing here may hang the verb (the 2.5s rule). */
 	async repairSurfaceAfterResize(e, handle, prevSeq) {
-		const want = {
+		const want0 = {
 			w: e.viewport.width,
 			h: e.viewport.height
 		};
+		const lvw = layoutViewport(want0.w, want0.h, e.zoom ?? readBrowserConfig().contentZoom);
+		const want = {
+			w: lvw.width,
+			h: lvw.height
+		};
 		const dimsOf = (f) => {
 			if (!f) return null;
 			const md = f.metadata;
@@ -911,13 +1233,10 @@ var BrowserRegistry = class {
 				const timeout = new Promise((res) => setTimeout(() => res(fb), 2500));
 				return await Promise.race([p.catch(() => fb), timeout]);
 			};
-			const anyCdpH = handle.cdp;
-			await raceH(anyCdpH.send("Emulation.setDeviceMetricsOverride", {
+			if (handle.page) await raceH(handle.page.setViewportSize({
 				width: want.w,
-				height: want.h,
-				deviceScaleFactor: 1,
-				mobile: false
-			}).then(() => null), null);
+				height: want.h
+			}).catch(() => void 0).then(() => null), null);
 			await new Promise((r) => setTimeout(r, 400));
 			const shotH = await raceH(handle.cdp.send("Page.captureScreenshot", {
 				format: "jpeg",
@@ -958,10 +1277,11 @@ var BrowserRegistry = class {
 						format: "jpeg",
 						quality: 60
 					}), null);
-					const d = shot?.data ? dimsOf({
+					let d = shot?.data ? dimsOf({
 						jpeg: shot.data,
 						metadata: {}
 					}) : null;
+					if (!d) d = dimsOf(handle.relay.latestFrame());
 					if (d && Math.abs(d.w - want.w) < 3 && Math.abs(d.h - want.h) < 3) {
 						console.log("[surface] iter", i, "converged: capture", d.w + "x" + d.h, "chrome", cw + "/" + ch);
 						e.chrome = {
@@ -1095,6 +1415,44 @@ var BrowserRegistry = class {
 			entryCount: hist.entries.length
 		};
 	}
+	/** The FULL navigation history of one tab (long-press dropdown,
+	*  operator-approved 2026-10-28): the attached CDP session's
+	*  Page.getNavigationHistory, entries as { index, url, title } — index
+	*  is the LIST position the UI filters by, id is the CDP entryId the
+	*  travel verb needs. Read-only; the same handleOf refusals as navInfo. */
+	async navEntries(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,
+			entries: hist.entries.map((en, index) => ({
+				index,
+				url: en.url,
+				title: en.title
+			}))
+		};
+	}
+	/** TRUE history travel (long-press dropdown, operator-approved
+	*  2026-10-28): Page.navigateToHistoryEntry to the entry AT the list
+	*  position — never a fresh navigate, which would append a new entry
+	*  and desync the dropdown from Chrome's own back/forward list. A
+	*  position outside the list is an explicit refusal. */
+	async historyTravel(id, index, 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", {});
+		if (!Number.isInteger(index) || index < 0 || index >= hist.entries.length) throw new BrowserRegistryRefusal("NO_TARGET", "HISTORY_INDEX — no entry at index " + index + " of " + hist.entries.length);
+		const loaded = this.waitLoad(h);
+		await h.cdp.send("Page.navigateToHistoryEntry", { entryId: hist.entries[index].id });
+		await loaded;
+		return {
+			currentIndex: index,
+			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) {
@@ -1206,12 +1564,15 @@ var BrowserRegistry = class {
 			waitLoad: true,
 			targetId
 		});
+		const tabId = mintTabId(e, targetId);
 		if (opts?.activate ?? true) return {
 			...await this.activate(id, targetId),
-			targetId
+			targetId,
+			tabId
 		};
 		const h = e.tabs.get(targetId);
 		return {
+			tabId,
 			targetId,
 			seq: h?.relay.latestFrame()?.seq ?? 0,
 			jpeg: h?.relay.latestFrame()?.jpeg ?? null,
@@ -1235,16 +1596,23 @@ var BrowserRegistry = class {
 	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))]);
-			await handle.cdp.send("Emulation.setDeviceMetricsOverride", {
-				width: e.viewport.width,
-				height: e.viewport.height,
-				deviceScaleFactor: 1,
-				mobile: false
+			const lv = layoutViewport(e.viewport.width, e.viewport.height, e.zoom ?? readBrowserConfig().contentZoom);
+			const resized = handle.page.setViewportSize({
+				width: lv.width,
+				height: lv.height
 			}).catch(() => void 0);
+			await Promise.race([resized, new Promise((res) => setTimeout(res, 2500))]);
+			await Promise.race([resized, new Promise((res) => setTimeout(res, 5e3))]);
+			try {
+				const cdp = await handle.page.context().newCDPSession(handle.page);
+				const dprEval = await Promise.race([handle.page.evaluate("devicePixelRatio").catch(() => 1), new Promise((res) => setTimeout(() => res(1), 500))]);
+				await cdp.send("Emulation.setDeviceMetricsOverride", {
+					width: lv.width,
+					height: lv.height,
+					deviceScaleFactor: typeof dprEval === "number" && dprEval > 0 ? dprEval : 1,
+					mobile: false
+				}).catch(() => void 0);
+			} catch {}
 			return;
 		}
 		const race = async (p, fb) => await Promise.race([p.catch(() => fb), new Promise((res) => setTimeout(() => res(fb), 2500))]);
@@ -1267,11 +1635,12 @@ var BrowserRegistry = class {
 		const anyCdp2 = handle.cdp;
 		const win = await this.windowIdOf(anyCdp2, race);
 		if (win && win.windowId) {
+			const lv = layoutViewport(e.viewport.width, e.viewport.height, e.zoom ?? readBrowserConfig().contentZoom);
 			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),
+					width: Math.max(200, lv.width + chromeW),
+					height: Math.max(120, lv.height + chromeH),
 					windowState: "normal"
 				}
 			}), null);
@@ -1280,7 +1649,7 @@ var BrowserRegistry = class {
 				h: chromeH
 			};
 			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);
+			console.log("[window] resized ->", JSON.stringify(check && check.bounds ? check.bounds : check), "want", lv.width + chromeW, "x", lv.height + chromeH);
 		} else console.log("[window] no windowId — resize skipped (raced out)");
 		await race(anyCdp2.send("Emulation.clearDeviceMetricsOverride"), null);
 	}
@@ -1289,14 +1658,23 @@ var BrowserRegistry = class {
 	*  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) {
+	async closeTab(id, ref) {
 		const e = this.peek(id);
 		if (e.closed) throw new BrowserRegistryRefusal("CLOSED", "session is closing");
+		let targetId = ref;
+		if (typeof ref === "number" || /^\d+$/.test(ref)) {
+			const r = resolveTab(e, ref);
+			if (!r.ok) throw new BrowserRegistryRefusal("NO_TARGET", r.error);
+			targetId = r.targetId;
+		}
 		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);
+		retireTabId(e, targetId);
+		const ordIdx = (e.tabOrder ?? []).indexOf(targetId);
+		if (ordIdx !== -1) e.tabOrder.splice(ordIdx, 1);
 		await victim.cdp.send("Target.closeTarget", { targetId }).catch(() => void 0);
 		await victim.cdp.detach().catch(() => void 0);
 		if (e.activeTargetId === targetId) {
@@ -1319,5 +1697,5 @@ var BrowserRegistry = class {
 };
 var browserRegistry = new BrowserRegistry();
 
-export { BrowserRegistryRefusal as B, browserRegistry as b };
-//# sourceMappingURL=registry.js-syaTZ_-A.js.map
+export { BrowserRegistryRefusal as B, browserRegistry as b, clampZoom as c };
+//# sourceMappingURL=registry.js-CWnRQ4vx.js.map