@deepseek-insight/dsi 0.8.2 → 0.8.3

package/build/server/chunks/chunks/{registry.js-BC-TNdmn.js → registry.js-C2MdrfNv.js}

@@ -21,6 +21,10 @@ var BrowserRelay = class {
 	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
@@ -48,6 +52,33 @@ var BrowserRelay = class {
 			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
@@ -149,6 +180,31 @@ function sweepOrphanProfiles(keep) {
 		});
 	} 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
@@ -299,8 +355,111 @@ var BrowserRegistry = class {
 		}, Math.min(idleMs / 2, 3e4));
 		s.reaperTimer.unref?.();
 	}
+	/** The ACTIVE tab's relay — what the stream route binds (ADR-0040 D2). */
 	relay(id) {
-		return this.peek(id).relay;
+		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();
@@ -323,12 +482,13 @@ var BrowserRegistry = class {
 				"--disable-renderer-backgrounding",
 				"--disable-background-timer-throttling",
 				"--autoplay-policy=no-user-gesture-required",
-				"--window-position=-32000,-32000"
+				"--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: {
-				width: 1920,
-				height: 1080
-			},
+			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"
@@ -343,6 +503,17 @@ var BrowserRegistry = class {
 		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);
@@ -365,8 +536,13 @@ var BrowserRegistry = class {
 		const entry = {
 			id,
 			context,
-			cdp,
-			relay,
+			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,
@@ -382,15 +558,17 @@ var BrowserRegistry = class {
 		};
 		state().entries.set(id, entry);
 		if (options.spawnMcp ?? true) {
-			if (process.env.DSI_MCP_IN_PROCESS === "1") 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);
+			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,
@@ -462,7 +640,8 @@ var BrowserRegistry = class {
 			errs.push(e);
 		}
 		try {
-			entry.relay.stop();
+			for (const h of entry.tabs.values()) h.relay.stop();
+			entry.tabs.clear();
 		} catch (e) {
 			errs.push(e);
 		}
@@ -488,13 +667,13 @@ var BrowserRegistry = class {
 	/** 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(e, capMs = 3e3) {
+	async waitLoad(h, capMs = 3e3) {
 		await new Promise((res) => {
 			const on = (p) => {
-				e.cdp.off("Page.loadEventFired", on);
+				h.cdp.off("Page.loadEventFired", on);
 				res();
 			};
-			e.cdp.on("Page.loadEventFired", on);
+			h.cdp.on("Page.loadEventFired", on);
 			setTimeout(res, capMs);
 		});
 	}
@@ -502,37 +681,66 @@ var BrowserRegistry = class {
 	*  damage is the only reliable way to make screencast emit a frame. */
 	async navigate(id, url, opts) {
 		const e = this.peek(id);
-		await e.cdp.send("Page.enable").catch(() => void 0);
+		const h = await this.handleOf(e, opts?.targetId);
+		await h.cdp.send("Page.enable").catch(() => void 0);
 		if (opts?.waitLoad) {
-			const loaded = this.waitLoad(e);
-			await e.cdp.send("Page.navigate", { url });
+			const loaded = this.waitLoad(h);
+			await h.cdp.send("Page.navigate", { url });
 			await loaded;
 			return;
 		}
-		await e.cdp.send("Page.navigate", { url });
+		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) {
+	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);
-		await e.cdp.send("Page.enable").catch(() => void 0);
-		await e.cdp.send("Emulation.setDeviceMetricsOverride", {
+		e.viewport = {
 			width: w,
-			height: h,
-			deviceScaleFactor: 0,
-			mobile: false
+			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) {
+	async navInfo(id, targetId) {
 		const e = this.peek(id);
-		await e.cdp.send("Page.enable").catch(() => void 0);
-		const hist = await e.cdp.send("Page.getNavigationHistory", {});
+		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
@@ -540,30 +748,32 @@ var BrowserRegistry = class {
 	}
 	/** Reload the session's active page (ADR-0031 D4): Page.reload keeps
 	*  the history entry, unlike re-navigating the current URL. */
-	async reload(id) {
+	async reload(id, targetId) {
 		const e = this.peek(id);
-		await e.cdp.send("Page.enable").catch(() => void 0);
-		const loaded = this.waitLoad(e);
-		await e.cdp.send("Page.reload", {});
+		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);
+		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) {
+	async pageHistory(id, dir, targetId) {
 		const e = this.peek(id);
-		await e.cdp.send("Page.enable").catch(() => void 0);
-		const hist = await e.cdp.send("Page.getNavigationHistory", {});
+		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(e);
-		await e.cdp.send("Page.navigateToHistoryEntry", { entryId: hist.entries[target].id });
+		const loaded = this.waitLoad(h);
+		await h.cdp.send("Page.navigateToHistoryEntry", { entryId: hist.entries[target].id });
 		await loaded;
 		return {
-			...await this.pageInfo(id),
+			...await this.pageInfo(id, targetId),
 			currentIndex: target,
 			entryCount: hist.entries.length
 		};
@@ -589,9 +799,10 @@ var BrowserRegistry = class {
 	*  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) {
+	async pageInfo(id, targetId) {
 		const e = this.peek(id);
-		const raw = await this.evaluateCapped(e.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);
+		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)",
@@ -603,14 +814,141 @@ var BrowserRegistry = class {
 		};
 		return JSON.parse(raw);
 	}
-	dispatch(id, input) {
+	/** 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");
-		return e.relay.dispatch(input);
+		await (await this.handleOf(e, targetId)).relay.dispatch(input);
 	}
 };
 var browserRegistry = new BrowserRegistry();
 
 export { BrowserRegistryRefusal as B, browserRegistry as b };
-//# sourceMappingURL=registry.js-BC-TNdmn.js.map
+//# sourceMappingURL=registry.js-C2MdrfNv.js.map

package/build/server/chunks/chunks/{state.js-Dki_Bq11.js → state.js-BSiAgink.js}

@@ -1,6 +1,6 @@
 import { i as index_server_exports } from './index-server.js-DmIEbDVz.js';
 import './shared.js-HQ0rfhm4.js';
-import './internal2.js-DFG0wDsP.js';
+import './internal2.js-Ba5p8uFM.js';
 import './exports.js-DH_tjtdv.js';
 import { U as snapshot, g as getContext, n as noop } from './server.js-B1bDXhHu.js';
 import { U as UI_LOCALES } from './config.js-vThvQeMn.js';
@@ -304,4 +304,4 @@ var page = {
 };
 
 export { afterNavigate as a, backtoworkspace2 as b, currentLocale as c, dshunreachable1 as d, replaceState as e, page as p, reapednote1 as r, sessionnotfound2 as s, t, unexpectederror1 as u };
-//# sourceMappingURL=state.js-Dki_Bq11.js.map
+//# sourceMappingURL=state.js-BSiAgink.js.map

package/build/server/chunks/chunks/{watcher.js-f54CFvdI.js → watcher.js-BVKnoQUw.js}

@@ -1,7 +1,7 @@
 import { c as readA2aConfig } from './insight-config.js-Dp_2gB5J.js';
 import { i as insertWaiting, o as openA2aDb, s as settleRow, p as pruneTerminalBefore, l as listWaiting } from './db.js-DQm6CZ_r.js';
 import { g as getDshConnection } from './dsh-connection.js-BgeraFA2.js';
-import { a as entryForEvent, h as historyToEvents } from './dsh-events.js-CGuF_had.js';
+import { a as entryForEvent, h as historyToEvents } from './dsh-events.js-BUkLR6ZV.js';
 
 //#region src/lib/server/a2a/matcher.ts
 /**
@@ -470,4 +470,4 @@ function registerWatch(row) {
 }
 
 export { configureWatcher as c, ensureStarted as e, registerWatch as r };
-//# sourceMappingURL=watcher.js-f54CFvdI.js.map
+//# sourceMappingURL=watcher.js-BVKnoQUw.js.map

package/build/server/chunks/entries/endpoints/api/a2a/{_server.ts.js-DN0zl7cz.js → _server.ts.js-3kQCQuHT.js}

@@ -1,5 +1,5 @@
 import { a as listRecent } from '../../../../chunks/db.js-DQm6CZ_r.js';
-import { e as ensureStarted } from '../../../../chunks/watcher.js-f54CFvdI.js';
+import { e as ensureStarted } from '../../../../chunks/watcher.js-BVKnoQUw.js';
 import { j as json } from '../../../../chunks/utils.js-CAdNO8Tu.js';
 import '../../../../chunks/insight-config.js-Dp_2gB5J.js';
 import '../../../../chunks/config.js-vThvQeMn.js';
@@ -11,7 +11,7 @@ import 'yaml';
 import '../../../../chunks/settings-home2.js-f75-B6RI.js';
 import 'node:sqlite';
 import '../../../../chunks/dsh-connection.js-BgeraFA2.js';
-import '../../../../chunks/dsh-events.js-CGuF_had.js';
+import '../../../../chunks/dsh-events.js-BUkLR6ZV.js';
 import '../../../../chunks/merge.js-yMwW440S.js';
 import '../../../../chunks/shared.js-HQ0rfhm4.js';
 import '../../../../chunks/uneval.js-BJ9Qq2SF.js';
@@ -61,4 +61,4 @@ var GET = ({ url }) => {
 };
 
 export { GET };
-//# sourceMappingURL=_server.ts.js-DN0zl7cz.js.map
+//# sourceMappingURL=_server.ts.js-3kQCQuHT.js.map

package/build/server/chunks/entries/endpoints/api/a2a/register/{_server.ts.js-C3byr74D.js → _server.ts.js-BUBTCLFn.js}

@@ -1,6 +1,6 @@
 import { c as readA2aConfig } from '../../../../../chunks/insight-config.js-Dp_2gB5J.js';
 import { g as getDshConnection } from '../../../../../chunks/dsh-connection.js-BgeraFA2.js';
-import { c as configureWatcher, r as registerWatch } from '../../../../../chunks/watcher.js-f54CFvdI.js';
+import { c as configureWatcher, r as registerWatch } from '../../../../../chunks/watcher.js-BVKnoQUw.js';
 import { m as mintA2aId } from '../../../../../chunks/a2a-protocol.js-C77mVg2Q.js';
 import { j as json } from '../../../../../chunks/utils.js-CAdNO8Tu.js';
 import '../../../../../chunks/config.js-vThvQeMn.js';
@@ -12,7 +12,7 @@ import 'yaml';
 import '../../../../../chunks/settings-home2.js-f75-B6RI.js';
 import '../../../../../chunks/db.js-DQm6CZ_r.js';
 import 'node:sqlite';
-import '../../../../../chunks/dsh-events.js-CGuF_had.js';
+import '../../../../../chunks/dsh-events.js-BUkLR6ZV.js';
 import '../../../../../chunks/merge.js-yMwW440S.js';
 import '../../../../../chunks/shared.js-HQ0rfhm4.js';
 import '../../../../../chunks/uneval.js-BJ9Qq2SF.js';
@@ -99,4 +99,4 @@ var POST = async ({ request }) => {
 };
 
 export { POST };
-//# sourceMappingURL=_server.ts.js-C3byr74D.js.map
+//# sourceMappingURL=_server.ts.js-BUBTCLFn.js.map