@deepseek-insight/dsi 0.6.21 → 0.8.0

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

@@ -0,0 +1,577 @@
+import { d as readBrowserConfig } from './insight-config.js-CaHHJpFK.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;
+	cdp;
+	subscribers = /* @__PURE__ */ new Set();
+	seq = 0;
+	latest = null;
+	chain = Promise.resolve();
+	started = false;
+	/** JPEG quality 0..100 — from BrowserConfig.screencastQuality
+	*  (default 90; yaml `browser.screencast:` override, amendment 3). */
+	constructor(cdp, quality = 90) {
+		this.quality = quality;
+		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: 1
+		});
+		this.started = true;
+	}
+	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 {}
+}
+/** 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?.();
+	}
+	relay(id) {
+		return this.peek(id).relay;
+	}
+	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-backgrounding-occluded-windows",
+				"--disable-renderer-backgrounding",
+				"--disable-background-timer-throttling",
+				"--disable-blink-features=AutomationControlled",
+				"--autoplay-policy=no-user-gesture-required",
+				"--window-position=-32000,-32000"
+			],
+			viewport: null
+		});
+		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);
+		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));
+		const brainPort = Number(process.env.DSI_MCP_PORT ?? cfg.brainPort);
+		if (cfg.enabled) this.ensureReaper(cfg.idleMs);
+		const entry = {
+			id,
+			context,
+			cdp,
+			relay,
+			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") 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 {
+			entry.relay.stop();
+		} 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(e, capMs = 3e3) {
+		await new Promise((res) => {
+			const on = (p) => {
+				e.cdp.off("Page.loadEventFired", on);
+				res();
+			};
+			e.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);
+		await e.cdp.send("Page.enable").catch(() => void 0);
+		if (opts?.waitLoad) {
+			const loaded = this.waitLoad(e);
+			await e.cdp.send("Page.navigate", { url });
+			await loaded;
+			return;
+		}
+		await e.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) {
+		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", {
+			width: w,
+			height: h,
+			deviceScaleFactor: 0,
+			mobile: false
+		});
+	}
+	/** 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) {
+		const e = this.peek(id);
+		await e.cdp.send("Page.enable").catch(() => void 0);
+		const hist = await e.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) {
+		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", {});
+		await loaded;
+		return this.pageInfo(id);
+	}
+	/** 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) {
+		const e = this.peek(id);
+		await e.cdp.send("Page.enable").catch(() => void 0);
+		const hist = await e.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 });
+		await loaded;
+		return {
+			...await this.pageInfo(id),
+			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) {
+		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);
+		if (raw === null) return {
+			url: "(busy)",
+			title: "(busy)",
+			dpr: 1,
+			innerWidth: 0,
+			innerHeight: 0,
+			playerError: null,
+			mediaErrorCode: null
+		};
+		return JSON.parse(raw);
+	}
+	dispatch(id, input) {
+		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);
+	}
+};
+var browserRegistry = new BrowserRegistry();
+
+export { BrowserRegistryRefusal as B, browserRegistry as b };
+//# sourceMappingURL=registry.js-BTiJ1Kaj.js.map

package/build/server/chunks/chunks/{registry.js-G1hzOje_.js → registry2.js-D3Pr1Rv9.js}

@@ -1,8 +1,8 @@
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { mkdir, rm, open } from 'node:fs/promises';
 import { spawnSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
+import { mkdir, rm, open } from 'node:fs/promises';
 import { EventEmitter } from 'node:events';
 import * as nodePty from 'node-pty';
 
@@ -542,4 +542,4 @@ var TerminalRegistry = class {
 var terminalRegistry = new TerminalRegistry();
 
 export { TerminalRegistryRefusal as T, TerminalSendRefusal as a, terminalRegistry as t };
-//# sourceMappingURL=registry.js-G1hzOje_.js.map
+//# sourceMappingURL=registry2.js-D3Pr1Rv9.js.map

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

@@ -1,4 +1,4 @@
-import { i as isConfigRecord } from './config.js-B0w1-uCA.js';
+import { i as isConfigRecord } from './config.js-vThvQeMn.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-BRTO59Al.js.map
+//# sourceMappingURL=settings-document.js-Gw1puaik.js.map

package/build/server/chunks/chunks/{state.js-ez_uUx9I.js → state.js-D3ob-Gqa.js}

@@ -1,9 +1,9 @@
 import { i as index_server_exports } from './index-server.js-CV2lq-ha.js';
 import './shared.js-HQ0rfhm4.js';
-import './internal2.js-Bcxjr5x2.js';
+import './internal2.js-BtL7AFjQ.js';
 import './exports.js-DH_tjtdv.js';
 import { U as snapshot, g as getContext, n as noop } from './server.js-DqHGsQU2.js';
-import { U as UI_LOCALES } from './config.js-B0w1-uCA.js';
+import { U as UI_LOCALES } from './config.js-vThvQeMn.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-ez_uUx9I.js.map
+//# sourceMappingURL=state.js-D3ob-Gqa.js.map

package/build/server/chunks/chunks/{watcher.js-Dogr6xsl.js → watcher.js-DcT3cS4v.js}

@@ -1,6 +1,6 @@
-import { c as readA2aConfig } from './insight-config.js-CA-iT3lB.js';
-import { i as insertWaiting, o as openA2aDb, s as settleRow, p as pruneTerminalBefore, l as listWaiting } from './db.js-DRhjT6xK.js';
-import { g as getDshConnection } from './dsh-connection.js-DL5qjlq2.js';
+import { c as readA2aConfig } from './insight-config.js-CaHHJpFK.js';
+import { i as insertWaiting, o as openA2aDb, s as settleRow, p as pruneTerminalBefore, l as listWaiting } from './db.js-B8BUpxGM.js';
+import { g as getDshConnection } from './dsh-connection.js-xltcocWy.js';
 import { a as entryForEvent, h as historyToEvents } from './dsh-events.js-CGuF_had.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-Dogr6xsl.js.map
+//# sourceMappingURL=watcher.js-DcT3cS4v.js.map

package/build/server/chunks/entries/endpoints/api/a2a/_id_/{_server.ts.js-CpeC2QLb.js → _server.ts.js-19pFOjH8.js}

@@ -1,8 +1,8 @@
-import { g as getRow } from '../../../../../chunks/db.js-DRhjT6xK.js';
+import { g as getRow } from '../../../../../chunks/db.js-B8BUpxGM.js';
 import { j as json } from '../../../../../chunks/utils.js-CAdNO8Tu.js';
-import '../../../../../chunks/insight-config.js-CA-iT3lB.js';
-import '../../../../../chunks/config.js-B0w1-uCA.js';
-import '../../../../../chunks/settings-document.js-BRTO59Al.js';
+import '../../../../../chunks/insight-config.js-CaHHJpFK.js';
+import '../../../../../chunks/config.js-vThvQeMn.js';
+import '../../../../../chunks/settings-document.js-Gw1puaik.js';
 import 'node:fs';
 import 'node:path';
 import 'node:os';
@@ -36,4 +36,4 @@ var GET = ({ params }) => {
 };
 
 export { GET };
-//# sourceMappingURL=_server.ts.js-CpeC2QLb.js.map
+//# sourceMappingURL=_server.ts.js-19pFOjH8.js.map

package/build/server/chunks/entries/endpoints/api/a2a/{_server.ts.js-BkLuKDZr.js → _server.ts.js-BcUn6axe.js}

@@ -1,16 +1,16 @@
-import { a as listRecent } from '../../../../chunks/db.js-DRhjT6xK.js';
-import { e as ensureStarted } from '../../../../chunks/watcher.js-Dogr6xsl.js';
+import { a as listRecent } from '../../../../chunks/db.js-B8BUpxGM.js';
+import { e as ensureStarted } from '../../../../chunks/watcher.js-DcT3cS4v.js';
 import { j as json } from '../../../../chunks/utils.js-CAdNO8Tu.js';
-import '../../../../chunks/insight-config.js-CA-iT3lB.js';
-import '../../../../chunks/config.js-B0w1-uCA.js';
-import '../../../../chunks/settings-document.js-BRTO59Al.js';
+import '../../../../chunks/insight-config.js-CaHHJpFK.js';
+import '../../../../chunks/config.js-vThvQeMn.js';
+import '../../../../chunks/settings-document.js-Gw1puaik.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-DL5qjlq2.js';
+import '../../../../chunks/dsh-connection.js-xltcocWy.js';
 import '../../../../chunks/dsh-events.js-CGuF_had.js';
 import '../../../../chunks/merge.js-yMwW440S.js';
 import '../../../../chunks/shared.js-HQ0rfhm4.js';
@@ -61,4 +61,4 @@ var GET = ({ url }) => {
 };
 
 export { GET };
-//# sourceMappingURL=_server.ts.js-BkLuKDZr.js.map
+//# sourceMappingURL=_server.ts.js-BcUn6axe.js.map