@deepseek-insight/dsi 0.8.3 → 0.8.5

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

@@ -1,4 +1,4 @@
-import { d as readBrowserConfig } from './insight-config.js-Dp_2gB5J.js';
+import { d as readBrowserConfig } from './insight-config.js-Db5fe5Df.js';
 import { mkdirSync, rmSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
@@ -95,6 +95,22 @@ var BrowserRelay = class {
 		};
 		for (const sub of this.subscribers) sub(this.latest);
 	}
+	/** Navigate reseed (ADR-0039 follow-up, 2026-10-25): unlike seed(), this
+	*  REPLACES an existing frame. A discrete navigation under a paced
+	*  screencast (everyNthFrame > 2, headless) composites too few frames for
+	*  Chrome to emit anything — and the ring still holds the OPENER's
+	*  synthesized frame, which seed() refuses to advance past, so the glass
+	*  would freeze on the old face forever. A navigation is a real face
+	*  change: it must land even over a synthesized frame. */
+	reseed(frame) {
+		if (!this.cdp) throw new RelayClosedError();
+		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;
@@ -362,6 +378,16 @@ var BrowserRegistry = class {
 		if (!h) throw new BrowserRegistryRefusal("CLOSED", "no active tab handle");
 		return h.relay;
 	}
+	/** 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. */
+	onActiveChange(id, cb) {
+		const e = this.peek(id);
+		(e.activeListeners ??= /* @__PURE__ */ new Set()).add(cb);
+		return () => {
+			e.activeListeners?.delete(cb);
+		};
+	}
 	/** 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
@@ -398,6 +424,7 @@ var BrowserRegistry = class {
 					page
 				}).catch(() => void 0);
 				e.tabs.set(tid, handle);
+				(e.tabOrder ??= []).push(tid);
 				if (tid === key) break;
 			}
 		}
@@ -405,6 +432,48 @@ var BrowserRegistry = class {
 		if (!h) throw new BrowserRegistryRefusal("NO_TARGET", "no such tab: " + key);
 		return h;
 	}
+	/** BUG 2026-10-27 (brain churn leaves stale handles): the registry's
+	*  cached CDP sessions can DIE while the pages live on (brain re-home,
+	*  MCP client reconnect) — listTabs then answers empty, every verb
+	*  NO_TARGETs, and the mirror starves on one frozen frame. Heal: re-probe
+	*  every live page with a FRESH CDP session, replace dead handles, and
+	*  remap the pointer when its target is gone. Called from listTabs when
+	*  enumeration comes back empty — the panel's 2s poll then heals the
+	*  whole session without operator action. */
+	async healHandles(e) {
+		for (const page of e.context.pages()) {
+			let scdp = null;
+			let tid = null;
+			try {
+				scdp = await e.context.newCDPSession(page);
+				tid = (await scdp.send("Target.getTargetInfo")).targetInfo?.targetId ?? null;
+			} catch {
+				continue;
+			}
+			if (!tid || !scdp) {
+				await scdp?.detach().catch(() => void 0);
+				continue;
+			}
+			const old = e.tabs.get(tid);
+			if (old) {
+				if (!await old.cdp.send("Target.getTargetInfo").then(() => false).catch(() => true)) {
+					await scdp.detach().catch(() => void 0);
+					continue;
+				}
+				old.relay.stop();
+				await old.cdp.detach().catch(() => void 0);
+				const cfg = readBrowserConfig();
+				e.tabs.set(tid, {
+					targetId: tid,
+					cdp: scdp,
+					relay: new BrowserRelay(scdp, cfg.screencastQuality, cfg.screencastMaxFps),
+					page
+				});
+				if (!e.tabOrder.includes(tid)) e.tabOrder.push(tid);
+			} else await scdp.detach().catch(() => void 0);
+		}
+		if (e.activeTargetId && !e.tabs.has(e.activeTargetId)) e.activeTargetId = [...e.tabs.keys()][0] ?? null;
+	}
 	/** 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). */
@@ -412,12 +481,22 @@ var BrowserRegistry = class {
 		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) => ({
+		let infos = ((await src.send("Target.getTargets").catch(() => null))?.targetInfos ?? []).filter((t) => t.type === "page");
+		if (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");
+		}
+		return infos.map((t) => ({
 			targetId: t.targetId,
 			url: t.url,
 			title: t.title,
 			active: t.targetId === e.activeTargetId
-		}));
+		})).sort((a, b) => {
+			const order = e.tabOrder ?? [];
+			const ia = order.indexOf(a.targetId);
+			const ib = order.indexOf(b.targetId);
+			return (ia === -1 ? Infinity : ia) - (ib === -1 ? Infinity : ib);
+		});
 	}
 	/** 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 —
@@ -446,6 +525,9 @@ var BrowserRegistry = class {
 			});
 		}
 		e.activeTargetId = targetId;
+		for (const l of e.activeListeners ?? []) try {
+			l(targetId);
+		} catch {}
 		let url = "";
 		let title = "";
 		try {
@@ -538,6 +620,7 @@ var BrowserRegistry = class {
 			context,
 			tabs,
 			activeTargetId,
+			tabOrder: activeTargetId ? [activeTargetId] : [],
 			viewport: {
 				width: Math.max(200, Math.min(1920, options.width ?? 730)),
 				height: Math.max(120, Math.min(1080, options.height ?? 830))
@@ -557,6 +640,41 @@ var BrowserRegistry = class {
 			createdAt: (/* @__PURE__ */ new Date()).toISOString()
 		};
 		state().entries.set(id, entry);
+		if (typeof context.on === "function") context.on("page", (page) => {
+			(async () => {
+				for (let i = 0; i < 10; i += 1) {
+					await new Promise((r) => setTimeout(r, 300));
+					try {
+						const scdp = await context.newCDPSession(page);
+						const info = await scdp.send("Target.getTargetInfo").catch(() => null);
+						await scdp.detach().catch(() => void 0);
+						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);
+						return;
+					} catch {}
+				}
+			})();
+		});
+		if (!entry.headless) {
+			await this.applyPanelViewport(entry, {
+				cdp,
+				relay
+			}).catch(() => void 0);
+			const birthShot = await cdp.send("Page.captureScreenshot", {
+				format: "jpeg",
+				quality: cfg.screencastQuality
+			}).catch(() => null);
+			if (birthShot?.data) relay.reseed({
+				seq: 0,
+				jpeg: birthShot.data,
+				metadata: {
+					seeded: true,
+					birth: true
+				}
+			});
+		}
 		if (options.spawnMcp ?? true) {
 			if (process.env.DSI_MCP_IN_PROCESS === "1") {
 				evictBrainPort(brainPort, id);
@@ -678,18 +796,25 @@ var BrowserRegistry = class {
 		});
 	}
 	/** Navigate the session's active page — public because causing page
-	*  damage is the only reliable way to make screencast emit a frame. */
+	*  damage is the only reliable way to make screencast emit a frame.
+	*  BUGFIX (ADR-0039 follow-up, 2026-10-25): at a paced cadence finer than
+	*  everyNthFrame=2 (e.g. the operator's live screencastMaxFps: 10 →
+	*  everyNthFrame 3), a HEADLESS single-damage navigate composites only
+	*  1–2 frames and Chrome emits NOTHING — the glass froze on the old face
+	*  after every header navigate. A bounded no-frame grace re-fires the
+	*  deterministic captureScreenshot seed (the activate()/resize idiom):
+	*  pacing still governs LIVE video; a discrete navigation always lands. */
 	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);
+		const prevSeq = h.relay.latestFrame()?.seq ?? -1;
 		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 });
+		} else await h.cdp.send("Page.navigate", { url });
+		this.seedAfterNavigate(h, prevSeq).catch(() => void 0);
 	}
 	/** Match the page viewport to the panel's glass box (ADR-0031
 	*  amendment 2): the screencast frame then equals the panel size, so
@@ -708,16 +833,240 @@ var BrowserRegistry = class {
 		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) {
+		await this.repairSurfaceAfterResize(e, handle, prevSeq).catch(() => void 0);
+	}
+	/** 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
+	*  size). Three bounded tries; the caller's race caps still apply. */
+	async windowIdOf(anyCdp, race, targetId) {
+		for (let i = 0; i < 3; i += 1) {
+			const t = await race(anyCdp.send("Target.getWindowForTarget"), null);
+			if (t && t.windowId) return t;
+			const b = await race(anyCdp.send("Browser.getWindowForTarget", targetId ? { targetId } : {}), null);
+			if (b && b.windowId) return b;
+			await new Promise((r) => setTimeout(r, 500));
+		}
+		return null;
+	}
+	/** ADR-0041 D3 + the surface-lag repair (BUG 2026-10-26): a resize must
+	*  REPAINT at the REQUESTED size, not just emit SOME fresh frame. Two
+	*  failure shapes live here:
+	*  1. the SILENT page — the screencast speaks only on change, so a
+	*     static page never repaints (the 2026-10-25 black bands);
+	*  2. the STALE SURFACE — a headed off-screen window takes the new
+	*     RENDERER size but macOS never reallocates the compositor surface:
+	*     every frame (even captureScreenshot) keeps arriving at the OLD
+	*     height, and the panel letterboxes it (the operator's top/bottom
+	*     bands at every height grow). Measured: 53 frames over 6s all at
+	*     the old 832 while innerHeight was 919; captureScreenshot agreed
+	*     with the stale surface. A window-state BOUNCE (minimize ->
+	*     normal — invisible at -32000,-32000) forces the window server to
+	*     reallocate; frames then arrive at the requested size.
+	*  Ladder: grace for a frame whose JPEG dims MATCH the request ->
+	*  bounce (headed only) -> second grace -> deterministic
+	*  captureScreenshot reseed (reseed: a stale REAL frame may sit atop
+	*  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 = {
+			w: e.viewport.width,
+			h: e.viewport.height
+		};
+		const dimsOf = (f) => {
+			if (!f) return null;
+			const md = f.metadata;
+			const mw = Number(md?.deviceWidth);
+			const mh = Number(md?.deviceHeight);
+			if (Number.isFinite(mw) && Number.isFinite(mh) && mw > 0 && mh > 0) return {
+				w: mw,
+				h: mh
+			};
+			const b = Buffer.from(f.jpeg, "base64");
+			let i = 2;
+			while (i < b.length - 9) {
+				if (b[i] !== 255) {
+					i += 1;
+					continue;
+				}
+				const marker = b[i + 1];
+				if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) return {
+					h: b.readUInt16BE(i + 5),
+					w: b.readUInt16BE(i + 7)
+				};
+				i += Math.max(2, b.readUInt16BE(i + 2));
+			}
+			return null;
+		};
+		const matched = () => {
+			const f = handle.relay.latestFrame();
+			if (!f || f.seq === prevSeq) return false;
+			const d = dimsOf(f);
+			return d !== null && Math.abs(d.w - want.w) < 3 && Math.abs(d.h - want.h) < 3;
+		};
+		for (let i = 0; i < 10 && !matched(); i += 1) await new Promise((r) => setTimeout(r, 100));
+		if (matched()) return;
+		if (e.headless) {
+			const raceH = async (p, fb) => {
+				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", {
+				width: want.w,
+				height: want.h,
+				deviceScaleFactor: 1,
+				mobile: false
+			}).then(() => null), null);
+			await new Promise((r) => setTimeout(r, 400));
+			const shotH = await raceH(handle.cdp.send("Page.captureScreenshot", {
+				format: "jpeg",
+				quality: readBrowserConfig().screencastQuality
+			}).catch(() => null), null);
+			if (shotH?.data) handle.relay.reseed({
+				seq: 0,
+				jpeg: shotH.data,
+				metadata: {
+					seeded: true,
+					resize: true
+				}
+			});
+			return;
+		}
+		if (!e.headless) {
+			const race = async (p, fb) => {
+				const timeout = new Promise((res) => setTimeout(() => res(fb), 2500));
+				return await Promise.race([p.catch(() => fb), timeout]);
+			};
+			const anyCdp = handle.cdp;
+			const win = await this.windowIdOf(anyCdp, race, e.activeTargetId ?? void 0);
+			if (win?.windowId) {
+				let cw = e.chrome?.w ?? 0;
+				let ch = e.chrome?.h ?? 0;
+				console.log("[surface] ladder start want", want.w + "x" + want.h, "learned chrome", cw + "/" + ch);
+				for (let i = 0; i < 3; i += 1) {
+					await race(anyCdp.send("Browser.setWindowBounds", {
+						windowId: win.windowId,
+						bounds: {
+							width: Math.max(200, want.w + cw),
+							height: Math.max(120, want.h + ch),
+							windowState: "normal"
+						}
+					}), null);
+					await new Promise((r) => setTimeout(r, 350));
+					const shot = await race(anyCdp.send("Page.captureScreenshot", {
+						format: "jpeg",
+						quality: 60
+					}), null);
+					const d = shot?.data ? dimsOf({
+						jpeg: shot.data,
+						metadata: {}
+					}) : null;
+					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 = {
+							w: cw,
+							h: ch
+						};
+						if (shot?.data) handle.relay.reseed({
+							seq: 0,
+							jpeg: shot.data,
+							metadata: {
+								seeded: true,
+								resize: true
+							}
+						});
+						return;
+					}
+					console.log("[surface] iter", i, "miss: capture", d ? d.w + "x" + d.h : "null", "at bounds", want.w + cw + "x" + (want.h + ch));
+					if (!d) continue;
+					const cur = await race(anyCdp.send("Browser.getWindowForTarget", { targetId: e.activeTargetId }), null);
+					if (cur?.bounds?.width && cur?.bounds?.height) {
+						cw = Math.max(0, cur.bounds.width - d.w);
+						ch = Math.max(0, cur.bounds.height - d.h);
+					} else {
+						cw += Math.max(0, want.w - d.w);
+						ch += Math.max(0, want.h - d.h);
+					}
+				}
+				e.chrome = {
+					w: cw,
+					h: ch
+				};
+				await race(anyCdp.send("Browser.setWindowBounds", {
+					windowId: win.windowId,
+					bounds: { windowState: "minimized" }
+				}), null);
+				await race(anyCdp.send("Browser.setWindowBounds", {
+					windowId: win.windowId,
+					bounds: { windowState: "normal" }
+				}), null);
+				await race(anyCdp.send("Browser.setWindowBounds", {
+					windowId: win.windowId,
+					bounds: {
+						width: Math.max(200, want.w + cw),
+						height: Math.max(120, want.h + ch),
+						windowState: "normal"
+					}
+				}), null);
+				await new Promise((r) => setTimeout(r, 300));
+				for (let i = 0; i < 10 && !matched(); i += 1) await new Promise((r) => setTimeout(r, 100));
+				if (matched()) return;
+				const parked = {
+					width: Math.max(200, want.w + cw),
+					height: Math.max(120, want.h + ch),
+					windowState: "normal"
+				};
+				await race(anyCdp.send("Browser.setWindowBounds", {
+					windowId: win.windowId,
+					bounds: {
+						...parked,
+						left: 10,
+						top: 10
+					}
+				}), null);
+				await new Promise((r) => setTimeout(r, 400));
+				await race(anyCdp.send("Browser.setWindowBounds", {
+					windowId: win.windowId,
+					bounds: {
+						...parked,
+						left: -32e3,
+						top: -32e3
+					}
+				}), null);
+				await new Promise((r) => setTimeout(r, 300));
+				for (let i = 0; i < 10 && !matched(); i += 1) await new Promise((r) => setTimeout(r, 100));
+				if (matched()) return;
+				console.log("[surface] ladder exhausted: bounce+flash ran, stream frames still", (() => {
+					const d = dimsOf(handle.relay.latestFrame());
+					return d ? d.w + "x" + d.h : "unknown";
+				})());
+			}
+		}
+		const cfg = readBrowserConfig();
+		const shot = await handle.cdp.send("Page.captureScreenshot", {
+			format: "jpeg",
+			quality: cfg.screencastQuality
+		}).catch(() => null);
+		const fd = shot?.data ? dimsOf({
+			jpeg: shot.data,
+			metadata: {}
+		}) : null;
+		console.log("[surface] final reseed capture:", fd ? fd.w + "x" + fd.h : "null", "want", want.w + "x" + want.h);
+		if (shot?.data) handle.relay.reseed({
+			seq: 0,
+			jpeg: shot.data,
+			metadata: {
+				seeded: true,
+				resize: true
+			}
+		});
+	}
+	/** The navigate path's seed arm (ADR-0039 follow-up): same bounded grace,
+	*  but the synthesized replacement must land OVER the opener's synthesized
+	*  frame — seed() refuses that, reseed() is the honest verb (the mirror
+	*  froze on the old face after every paced navigate otherwise). */
+	async seedAfterNavigate(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();
@@ -725,12 +1074,12 @@ var BrowserRegistry = class {
 			format: "jpeg",
 			quality: cfg.screencastQuality
 		}).catch(() => null);
-		if (shot?.data) handle.relay.seed({
+		if (shot?.data) handle.relay.reseed({
 			seq: 0,
 			jpeg: shot.data,
 			metadata: {
 				seeded: true,
-				resize: true
+				navigate: true
 			}
 		});
 	}
@@ -838,8 +1187,14 @@ var BrowserRegistry = class {
 			};
 		}
 	}
-	/** 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. */
+	/** Open a NEW tab in the glass and make it the active face. With a
+	*  `url`: the context-menu open-link/image path — create BLANK then
+	*  navigate through the verb seam (createTarget with a URL races its own
+	*  navigation and lands on chrome-error, observed 2026-10-25). WITHOUT a
+	*  url (ADR-0042 D2, the + chip): createTarget ONLY — the birth state
+	*  again, no navigation. Either way activate() applies the first-frame
+	*  contract (ADR-0040 D4 / ADR-0042 D4: grace, then a captureScreenshot
+	*  seed) and returns the boundary payload the caller paints. */
 	async openTab(id, url, opts) {
 		const e = this.peek(id);
 		if (e.closed) throw new BrowserRegistryRefusal("CLOSED", "session is closing");
@@ -847,22 +1202,21 @@ var BrowserRegistry = class {
 		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, {
+		if (url) await this.navigate(id, url, {
 			waitLoad: true,
 			targetId
 		});
-		if (opts?.activate ?? true) await this.activate(id, targetId);
+		if (opts?.activate ?? true) return {
+			...await this.activate(id, targetId),
+			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
+			url: url ?? "about:blank",
+			title: ""
 		};
 	}
 	/** Apply the remembered panel viewport by RESIZING THE WINDOW (round 10:
@@ -885,6 +1239,12 @@ var BrowserRegistry = class {
 				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
+			}).catch(() => void 0);
 			return;
 		}
 		const race = async (p, fb) => await Promise.race([p.catch(() => fb), new Promise((res) => setTimeout(() => res(fb), 2500))]);
@@ -893,14 +1253,19 @@ var BrowserRegistry = class {
 			expression: "JSON.stringify({ oh: window.outerHeight - window.innerHeight, ow: window.outerWidth - window.innerWidth })",
 			returnByValue: true
 		}), null);
-		let chromeH = 0, chromeW = 0;
+		let chromeH = e.chrome?.h ?? 0;
+		let chromeW = e.chrome?.w ?? 0;
 		try {
 			const d = JSON.parse(dims && dims.result && dims.result.value || "{}");
-			chromeH = Number(d.oh) || 0;
-			chromeW = Number(d.ow) || 0;
+			const oh = Number(d.oh) || 0;
+			const ow = Number(d.ow) || 0;
+			if (oh > 0 || ow > 0) {
+				chromeH = oh;
+				chromeW = ow;
+			}
 		} catch {}
 		const anyCdp2 = handle.cdp;
-		const win = await race(anyCdp2.send("Target.getWindowForTarget"), null);
+		const win = await this.windowIdOf(anyCdp2, race);
 		if (win && win.windowId) {
 			await race(anyCdp2.send("Browser.setWindowBounds", {
 				windowId: win.windowId,
@@ -910,6 +1275,10 @@ var BrowserRegistry = class {
 					windowState: "normal"
 				}
 			}), null);
+			if (chromeW > 0 || chromeH > 0) e.chrome = {
+				w: chromeW,
+				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);
 		} else console.log("[window] no windowId — resize skipped (raced out)");
@@ -951,4 +1320,4 @@ var BrowserRegistry = class {
 var browserRegistry = new BrowserRegistry();
 
 export { BrowserRegistryRefusal as B, browserRegistry as b };
-//# sourceMappingURL=registry.js-C2MdrfNv.js.map
+//# sourceMappingURL=registry.js-syaTZ_-A.js.map

package/build/server/chunks/chunks/{settings-document.js-Gw1puaik.js → settings-document.js-BHESJ7im.js}

@@ -1,4 +1,4 @@
-import { i as isConfigRecord } from './config.js-vThvQeMn.js';
+import { i as isConfigRecord } from './config.js-s6iKwHD7.js';
 import { existsSync, readFileSync, cpSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
@@ -159,4 +159,4 @@ function parseYamlSettings(text) {
 }
 
 export { SettingsParseError as S, ensureDsiHome as e, migrateLegacyDsiConfig as m, parseYamlSettings as p, readSettingsDocument as r, saveSettingsDocument as s };
-//# sourceMappingURL=settings-document.js-Gw1puaik.js.map
+//# sourceMappingURL=settings-document.js-BHESJ7im.js.map

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

@@ -1,9 +1,9 @@
 import { i as index_server_exports } from './index-server.js-DmIEbDVz.js';
 import './shared.js-HQ0rfhm4.js';
-import './internal2.js-Ba5p8uFM.js';
+import './internal2.js-CaZaz-a9.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';
+import { U as UI_LOCALES } from './config.js-s6iKwHD7.js';
 import { c as getLocale } from './runtime.js-CCJi3XaY.js';
 import './utils.js-CAdNO8Tu.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-BSiAgink.js.map
+//# sourceMappingURL=state.js-oYjf745s.js.map

package/build/server/chunks/chunks/{watcher.js-BVKnoQUw.js → watcher.js-Ci9jsM5l.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-BUkLR6ZV.js';
+import { c as readA2aConfig } from './insight-config.js-Db5fe5Df.js';
+import { i as insertWaiting, o as openA2aDb, s as settleRow, p as pruneTerminalBefore, l as listWaiting } from './db.js-CxxWK5sn.js';
+import { g as getDshConnection } from './dsh-connection.js-Chtudg1p.js';
+import { a as entryForEvent, h as historyToEvents } from './dsh-events.js-BUdvZQmd.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-BVKnoQUw.js.map
+//# sourceMappingURL=watcher.js-Ci9jsM5l.js.map

package/build/server/chunks/entries/endpoints/api/a2a/_id_/{_server.ts.js-BjzdVwdY.js → _server.ts.js-CHaYhzjy.js}

@@ -1,8 +1,8 @@
-import { g as getRow } from '../../../../../chunks/db.js-DQm6CZ_r.js';
+import { g as getRow } from '../../../../../chunks/db.js-CxxWK5sn.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';
-import '../../../../../chunks/settings-document.js-Gw1puaik.js';
+import '../../../../../chunks/insight-config.js-Db5fe5Df.js';
+import '../../../../../chunks/config.js-s6iKwHD7.js';
+import '../../../../../chunks/settings-document.js-BHESJ7im.js';
 import 'node:fs';
 import 'node:path';
 import 'node:os';
@@ -36,4 +36,4 @@ var GET = ({ params }) => {
 };
 
 export { GET };
-//# sourceMappingURL=_server.ts.js-BjzdVwdY.js.map
+//# sourceMappingURL=_server.ts.js-CHaYhzjy.js.map

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

@@ -1,17 +1,17 @@
-import { a as listRecent } from '../../../../chunks/db.js-DQm6CZ_r.js';
-import { e as ensureStarted } from '../../../../chunks/watcher.js-BVKnoQUw.js';
+import { a as listRecent } from '../../../../chunks/db.js-CxxWK5sn.js';
+import { e as ensureStarted } from '../../../../chunks/watcher.js-Ci9jsM5l.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';
-import '../../../../chunks/settings-document.js-Gw1puaik.js';
+import '../../../../chunks/insight-config.js-Db5fe5Df.js';
+import '../../../../chunks/config.js-s6iKwHD7.js';
+import '../../../../chunks/settings-document.js-BHESJ7im.js';
 import 'node:fs';
 import 'node:path';
 import 'node:os';
 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-BUkLR6ZV.js';
+import '../../../../chunks/dsh-connection.js-Chtudg1p.js';
+import '../../../../chunks/dsh-events.js-BUdvZQmd.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-3kQCQuHT.js.map
+//# sourceMappingURL=_server.ts.js-CdyqA85c.js.map