@deepseek-insight/dsi 0.5.29 → 0.5.31

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

@@ -0,0 +1,545 @@
+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 { EventEmitter } from 'node:events';
+import * as nodePty from 'node-pty';
+
+//#region src/lib/server/terminal/scrub.ts
+/**
+* Child-environment scrub for DSI's terminal sessions — a deliberate
+* mechanism-copy of DSH's `scrubbedParentEnv` with one ownership-specific
+* change: DSI strips its own `DSI_*` namespace too (ADR 2026-09-23 D6).
+*
+* Credential-shaped names and both reserved namespaces must never reach a
+* terminal the operator can type into; explicitly supplied entries merge
+* AFTER the scrub, so a deliberate opt-in survives. Case-insensitive
+* matching because Windows environment names are case-insensitive.
+* The proxy overlay re-applies after the strip so a child behind a proxied
+* parent routes the same way.
+* @mirrors deepseek-harness/packages/subprocess/subprocess/src/index.ts:47-80
+*/
+/** Namespace prefixes reserved by the harness and by DSI — neither leaks
+*  into a child implicitly. */
+var RESERVED_PREFIXES = ["DSH_", "DSI_"];
+/** Credential-shaped environment names are NOT forwarded to children. */
+var SENSITIVE_ENV_PATTERN = /KEY|PASSWORD|SECRET|TOKEN/i;
+function isReserved(key) {
+	const upper = key.toUpperCase();
+	return RESERVED_PREFIXES.some((prefix) => upper.startsWith(prefix));
+}
+/**
+* The ambient parent environment minus credential-shaped names and minus
+* every `DSH_*`/`DSI_*` name — the base every DSI terminal child
+* starts from. `PATH`, `HOME`, locale, and proxy variables survive,
+* so child shells run normally.
+* @param explicit - deliberate caller entries merged after the scrub; a
+*   string is an opt-in that survives, `undefined` is a tombstone that
+*   removes an ordinary ambient entry.
+* @returns a fresh environment object safe to hand to a PTY child.
+*/
+function scrubbedChildEnv(explicit) {
+	const env = {};
+	for (const [key, value] of Object.entries(process.env)) if (value !== void 0 && !SENSITIVE_ENV_PATTERN.test(key) && !isReserved(key)) env[key] = value;
+	if (explicit !== void 0) for (const [key, value] of Object.entries(explicit)) if (value === void 0) Reflect.deleteProperty(env, key);
+	else env[key] = value;
+	return env;
+}
+//#endregion
+//#region src/lib/server/terminal/session.ts
+/**
+* TerminalSession — one live PTY session and its owned process tree
+* (spec 2026-09-24 Wave 2; ADR 2026-09-23 D4/D5/D8).
+*
+* Contracts honored here:
+* - D4: one send in flight; a second refuses SEND_ACTIVE. Sends settle with
+*   exactly stdin_read / inferred_idle / timeout / session_exit — silence
+*   alone is inferred_idle, never completion; stdin_read requires positive
+*   prompt evidence at the tail.
+* - D5: close is a quiescence ladder over the whole session — TERM to the
+*   foreground group, graceMs, KILL to survivors, reap; idempotent; rejects
+*   LINGERING_PIDS rather than claiming a success it cannot prove.
+* - D8: bounded retained tail with spill recovery; offsets are whole-stream
+*   byte coordinates and reads never consume one another.
+*
+* Foreground-group note (W2): the PTY child is a session leader, so the
+* negative-pid kill targets its process group — the foreground group for
+* the sessions DSI opens. A child that creates its own group is reached by
+* the ps-based survivor sweep in the close ladder.
+*/
+/** Positive prompt evidence: the tail's last line ends with a bare shell
+*  prompt ($ # % >). Overridable per session — the detector is an instance
+*  field, never a hidden global. */
+var DEFAULT_PROMPT_DETECT = /(?:^|\r?\n)[$%>#] \r?\n?$/;
+/** Send refusal helper — D4's SEND_ACTIVE is a refusal code, not a settle
+*  reason; sessions surface it as a thrown refusal the registry maps to the
+*  wire. Internal sends use this typed error. */
+var TerminalSendRefusal = class extends Error {
+	code;
+	constructor() {
+		super("a send is already in flight for this session");
+		this.name = "TerminalSendRefusal";
+		this.code = "SEND_ACTIVE";
+	}
+};
+var nextSessionId = 1;
+var TerminalSession = class extends EventEmitter {
+	/** Opaque session id (registry scope). */
+	id;
+	pid;
+	/** The session leader's process group — the foreground group DSI signals. */
+	processGroupId;
+	spec;
+	pty;
+	promptDetect;
+	tail = "";
+	tailStartOffset = 0;
+	totalBytes = 0;
+	spillFile = "";
+	spillHandle = null;
+	spillDropped = false;
+	exited = false;
+	outcome = null;
+	exitWaiters = [];
+	sendInFlight = false;
+	passiveSettling = false;
+	closePromise = null;
+	closedAnnounced = false;
+	constructor(spec, options) {
+		super();
+		this.spec = spec;
+		this.id = (options?.idPrefix ?? "t") + "-" + nextSessionId++;
+		this.promptDetect = options?.promptDetect ?? ((tail) => DEFAULT_PROMPT_DETECT.test(tail));
+		this.pty = nodePty.spawn(spec.argv[0], spec.argv.slice(1), {
+			name: spec.terminalType,
+			cols: spec.cols,
+			rows: spec.rows,
+			cwd: spec.cwd,
+			env: scrubbedChildEnv({
+				...spec.env,
+				TERM: spec.terminalType
+			})
+		});
+		this.pid = this.pty.pid;
+		this.processGroupId = this.pid;
+		this.pty.onData((data) => this.onOutput(data));
+		this.pty.onExit(({ exitCode, signal }) => this.onExit(exitCode, signal));
+	}
+	onOutput(data) {
+		const bytes = Buffer.byteLength(data);
+		this.totalBytes += bytes;
+		this.tail += data;
+		if (Buffer.byteLength(this.tail) > this.spec.tailBytes + Math.min(65536, this.spec.tailBytes)) this.trimTail();
+		this.emit("event", {
+			type: "output",
+			bytes: data,
+			nextOffset: this.totalBytes
+		});
+	}
+	/** Drop the head past the cap; the dropped bytes land in the spill file. */
+	trimTail() {
+		let cut = 0;
+		while (cut < this.tail.length && Buffer.byteLength(this.tail.slice(0, cut)) < Buffer.byteLength(this.tail) - this.spec.tailBytes) {
+			cut = this.tail.indexOf("\n", cut + 1);
+			if (cut === -1) {
+				cut = this.tail.length;
+				break;
+			}
+		}
+		if (cut <= 0) return;
+		const dropped = this.tail.slice(0, cut);
+		this.spillAppend(dropped);
+		this.tailStartOffset += Buffer.byteLength(dropped);
+		this.tail = this.tail.slice(cut);
+	}
+	async spillAppend(dropped) {
+		try {
+			if (!this.spillFile) {
+				this.spillFile = join(tmpdir(), "dsi-terminal-" + this.id + ".spill");
+				await mkdir(tmpdir(), { recursive: true });
+				await rm(this.spillFile, { force: true });
+			}
+			this.spillHandle ??= await open(this.spillFile, "a");
+			await this.spillHandle.writeFile(dropped);
+			this.spillDropped = true;
+		} catch {
+			this.spillDropped = false;
+			this.spillFile = "";
+			this.spillHandle = null;
+		}
+	}
+	/** Cursor-free read of the retained stream (never consumes).
+	*  @mirrors SubprocessOutputReader.readFrom */
+	readFrom(fromByte) {
+		const end = this.totalBytes;
+		const tailStart = this.tailStartOffset;
+		if (fromByte < tailStart) return {
+			text: this.tail,
+			nextOffset: end,
+			lossy: true,
+			spillPath: this.spillDropped ? this.spillFile : void 0
+		};
+		const skip = Math.max(0, fromByte - tailStart);
+		return {
+			text: this.tail.slice(skip),
+			nextOffset: end,
+			lossy: false
+		};
+	}
+	onExit(exitCode, signal) {
+		this.exited = true;
+		this.outcome = {
+			exitCode,
+			signal: signal === void 0 ? null : signal
+		};
+		this.emit("event", {
+			type: "exit",
+			outcome: this.outcome
+		});
+		for (const wake of this.exitWaiters) wake(this.outcome);
+		this.exitWaiters = [];
+	}
+	/** Resolves when the top-level process exits. */
+	waitForExit() {
+		if (this.outcome) return Promise.resolve(this.outcome);
+		return new Promise((resolve) => this.exitWaiters.push(resolve));
+	}
+	sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	/** Current retained tail (prompt detection input). */
+	getTail() {
+		return this.tail;
+	}
+	/** Whole-stream byte coordinate of the live tail (reattach resume point).
+	*  Named past the field — a same-named method would be shadowed by the
+	*  field initializer at runtime. */
+	streamBytes() {
+		return this.totalBytes;
+	}
+	/** Exit facts once the top-level process exited; null while live. */
+	exitOutcome() {
+		return this.outcome;
+	}
+	isExited() {
+		return this.exited;
+	}
+	/**
+	* Write text to the terminal and wait for one settle fact. Exactly one
+	* send may be in flight; a second refuses SEND_ACTIVE.
+	* @param data - text delivered verbatim (append \\n to submit a line).
+	* @param timeoutMs - hard bound for the whole wait.
+	*/
+	async send(data, timeoutMs) {
+		if (this.sendInFlight) throw new TerminalSendRefusal();
+		if (this.exited) return "session_exit";
+		this.sendInFlight = true;
+		try {
+			const baseline = this.tail.length;
+			this.pty.write(data);
+			const deadline = Date.now() + timeoutMs;
+			let sawOutput = false;
+			let lastActivity = Date.now();
+			const onOutput = () => {
+				sawOutput = true;
+				lastActivity = Date.now();
+			};
+			this.on("event", onOutput);
+			try {
+				for (;;) {
+					let reason;
+					if (this.exited) reason = "session_exit";
+					else if (this.promptDetect(this.tail.slice(baseline))) reason = "stdin_read";
+					else if (sawOutput && Date.now() - lastActivity >= this.spec.idleMs) reason = "inferred_idle";
+					else if (Date.now() >= deadline) reason = "timeout";
+					else {
+						await this.sleep(25);
+						continue;
+					}
+					this.emit("event", {
+						type: "settled",
+						reason
+					});
+					return reason;
+				}
+			} finally {
+				this.off("event", onOutput);
+			}
+		} finally {
+			this.sendInFlight = false;
+		}
+	}
+	/**
+	* Interactive typing — plain write, never locked, never dropped (the
+	* xterm/input path). A passive settle observer runs when no awaited send
+	* is watching, so the wire still gets settle facts for the badge.
+	*/
+	write(data) {
+		if (this.exited) return;
+		this.pty.write(data);
+		this.startPassiveSettle();
+	}
+	/** One passive settle observation; concurrent writes share the watcher. */
+	startPassiveSettle() {
+		if (this.passiveSettling || this.sendInFlight) return;
+		this.passiveSettling = true;
+		(async () => {
+			const deadline = Date.now() + 3e4;
+			let lastActivity = Date.now();
+			let sawOutput = false;
+			const onOutput = () => {
+				sawOutput = true;
+				lastActivity = Date.now();
+			};
+			this.on("event", onOutput);
+			try {
+				const baseline = this.tail.length;
+				for (;;) {
+					let reason = null;
+					if (this.exited) reason = "session_exit";
+					else if (this.promptDetect(this.tail.slice(baseline))) reason = "stdin_read";
+					else if (sawOutput && Date.now() - lastActivity >= this.spec.idleMs) reason = "inferred_idle";
+					else if (Date.now() >= deadline) reason = "timeout";
+					if (reason) {
+						this.emit("event", {
+							type: "settled",
+							reason
+						});
+						return;
+					}
+					await this.sleep(50);
+				}
+			} finally {
+				this.off("event", onOutput);
+				this.passiveSettling = false;
+			}
+		})();
+	}
+	/** Deliver one allowlisted signal to the foreground group.
+	*  @returns the exact group id that received it. */
+	signalForeground(signal) {
+		if (this.exited) throw new Error("session exited");
+		process.kill(-this.processGroupId, signal);
+		return this.processGroupId;
+	}
+	/** pid → ppid snapshot of the live process table. */
+	processTable() {
+		const out = spawnSync("ps", [
+			"-ax",
+			"-o",
+			"pid=,ppid="
+		], { encoding: "utf8" });
+		const table = /* @__PURE__ */ new Map();
+		if (out.status !== 0 || !out.stdout) return table;
+		for (const line of out.stdout.split("\n")) {
+			const m = line.trim().match(/^(\d+)\s+(\d+)$/);
+			if (m) table.set(Number(m[1]), Number(m[2]));
+		}
+		return table;
+	}
+	/** All descendants of a pid (any process group) from one snapshot —
+	*  job-control shells move background children to their own group, so a
+	*  pgid filter alone would orphan them. */
+	descendantPids(root, table) {
+		const children = /* @__PURE__ */ new Map();
+		for (const [pid, ppid] of table) {
+			const list = children.get(ppid) ?? [];
+			list.push(pid);
+			children.set(ppid, list);
+		}
+		const found = [];
+		const walk = (pid) => {
+			for (const child of children.get(pid) ?? []) {
+				found.push(child);
+				walk(child);
+			}
+		};
+		walk(root);
+		return found;
+	}
+	alive(pid) {
+		try {
+			process.kill(pid, 0);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async killSurvivors(survivors, signal) {
+		for (const pid of survivors) try {
+			process.kill(pid, signal);
+		} catch {}
+	}
+	/**
+	* TERM the foreground group, wait graceMs, KILL the session tree, reap.
+	* Idempotent: a second call awaits the first ladder's result.
+	*/
+	close() {
+		if (this.closePromise) return this.closePromise;
+		this.closePromise = this.runCloseLadder();
+		return this.closePromise;
+	}
+	async runCloseLadder() {
+		try {
+			const descendants = this.descendantPids(this.pid, this.processTable());
+			if (!this.exited) {
+				try {
+					this.signalForeground("SIGTERM");
+				} catch {}
+				if (!await Promise.race([this.waitForExit(), this.sleep(this.spec.graceMs).then(() => null)])) {
+					try {
+						process.kill(-this.processGroupId, "SIGKILL");
+					} catch {}
+					await this.waitForExit();
+				}
+			}
+			let survivors = descendants.filter((pid) => this.alive(pid));
+			if (survivors.length > 0) {
+				await this.killSurvivors(survivors, "SIGKILL");
+				await this.sleep(100);
+				survivors = survivors.filter((pid) => this.alive(pid));
+			}
+			if (!this.closedAnnounced) {
+				this.closedAnnounced = true;
+				this.emit("event", {
+					type: "closed",
+					quiescent: survivors.length === 0,
+					lingeringPids: survivors.length > 0 ? survivors : void 0
+				});
+			}
+			await this.dispose();
+			return survivors.length > 0 ? {
+				quiescent: false,
+				lingeringPids: survivors
+			} : { quiescent: true };
+		} catch (err) {
+			throw err instanceof Error ? err : new Error(String(err));
+		}
+	}
+	/** Release file handles; safe to call once the ladder settled. */
+	async dispose() {
+		if (this.spillHandle) {
+			await this.spillHandle.close().catch(() => void 0);
+			this.spillHandle = null;
+		}
+	}
+};
+//#endregion
+//#region src/lib/server/terminal/registry.ts
+/**
+* Terminal registry — the server-side session table and ownership fence
+* (spec 2026-09-24 Wave 2; ADR 2026-09-23 D7).
+*
+* DSI's terminal is operator-owned: sessions belong to the DSI server
+* process, and each attached browser tab holds one server-minted token.
+* Write/signal/close operations present the token; a wrong one is refused
+* FOREIGN_SESSION. Re-attach re-mints the token to the asking tab and
+* evicts the old one — many watchers, one writer (the one-writer invariant
+* of ADR D4 stays mechanical, not conventional).
+*
+* This module is the WIRING POINT: transport routes import the singleton;
+* nothing imports a route or a component.
+*/
+/** Refusal with a stable wire code (mirrors dsh-terminal's codes; the
+*  registry is where FOREIGN_SESSION and NO_SESSION are decided). */
+var TerminalRegistryRefusal = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "TerminalRegistryRefusal";
+		this.code = code;
+	}
+};
+var TerminalRegistry = class {
+	entries = /* @__PURE__ */ new Map();
+	/** Spawn a session from a fully specified spec (no defaults here —
+	*  the transport resolved them from config). Returns the minted token. */
+	create(spec, options) {
+		const session = new TerminalSession(spec, { promptDetect: options?.promptDetect });
+		const token = randomUUID();
+		this.entries.set(session.id, {
+			session,
+			token,
+			spec
+		});
+		return {
+			session,
+			token
+		};
+	}
+	/** Resolve a session for a tokened operation — the fence.
+	*  @throws TerminalRegistryRefusal NO_SESSION / FOREIGN_SESSION */
+	authorized(sessionId, token) {
+		const entry = this.entries.get(sessionId);
+		if (!entry) throw new TerminalRegistryRefusal("NO_SESSION", "no such terminal session");
+		if (entry.token !== token) throw new TerminalRegistryRefusal("FOREIGN_SESSION", "this tab does not own the terminal");
+		return entry.session;
+	}
+	/** Read-only view without a token: watching is open, writing is not. */
+	peek(sessionId) {
+		const entry = this.entries.get(sessionId);
+		if (!entry) throw new TerminalRegistryRefusal("NO_SESSION", "no such terminal session");
+		return {
+			id: entry.session.id,
+			exited: entry.session.isExited()
+		};
+	}
+	/** Re-attach: re-mint the token to the asking tab; the old token dies. */
+	reattach(sessionId) {
+		const entry = this.entries.get(sessionId);
+		if (!entry) throw new TerminalRegistryRefusal("NO_SESSION", "no such terminal session");
+		entry.token = randomUUID();
+		return {
+			token: entry.token,
+			fromByte: entry.session.streamBytes()
+		};
+	}
+	/** Tokened operations — each throws through the fence. */
+	send(sessionId, token, data, timeoutMs) {
+		return this.authorized(sessionId, token).send(data, timeoutMs);
+	}
+	/** Interactive typing — the write never locks and never drops. */
+	write(sessionId, token, data) {
+		this.authorized(sessionId, token).write(data);
+	}
+	signal(sessionId, token, signal) {
+		return this.authorized(sessionId, token).signalForeground(signal);
+	}
+	async close(sessionId, token) {
+		const result = await this.authorized(sessionId, token).close();
+		return result.quiescent ? { quiescent: true } : {
+			quiescent: false,
+			lingeringPids: result.lingeringPids
+		};
+	}
+	readFrom(sessionId, fromByte) {
+		const entry = this.entries.get(sessionId);
+		if (!entry) throw new TerminalRegistryRefusal("NO_SESSION", "no such terminal session");
+		return entry.session.readFrom(fromByte);
+	}
+	events(sessionId) {
+		return this.entries.get(sessionId)?.session;
+	}
+	exitOutcome(sessionId) {
+		return this.entries.get(sessionId)?.session.exitOutcome() ?? null;
+	}
+	/** Every live session id (the operator's list — one owner, no scoping). */
+	list() {
+		return [...this.entries.values()].map((e) => ({
+			id: e.session.id,
+			exited: e.session.isExited()
+		}));
+	}
+	/** Close every session and await quiescence (server shutdown path). */
+	async dispose() {
+		const closings = [...this.entries.values()].map((e) => e.session.close().catch(() => void 0));
+		await Promise.all(closings);
+		this.entries.clear();
+	}
+};
+/** The wiring singleton — routes import this, nothing else constructs. */
+var terminalRegistry = new TerminalRegistry();
+
+export { TerminalRegistryRefusal as T, TerminalSendRefusal as a, terminalRegistry as t };
+//# sourceMappingURL=registry.js-G1hzOje_.js.map

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

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

package/build/server/chunks/chunks/{state.js-BKUnFOB4.js → state.js-DO4TvfeY.js}

@@ -1,8 +1,8 @@
-import { i as index_server_exports } from './internal.js-D-70iBmc.js';
+import { i as index_server_exports } from './internal.js-BtKbXGxV.js';
 import './shared.js-HQ0rfhm4.js';
 import './exports.js-DH_tjtdv.js';
 import { U as snapshot, J as getContext, G as noop } from './server.js-11-pxAWV.js';
-import { U as UI_LOCALES } from './config.js-BvW5LrfQ.js';
+import { U as UI_LOCALES } from './config.js-B0w1-uCA.js';
 import { c as getLocale } from './runtime.js-CCJi3XaY.js';
 import './utils.js-CAdNO8Tu.js';
 
@@ -303,4 +303,4 @@ var page = {
 };
 
 export { afterNavigate as a, backtoworkspace2 as b, replaceState as c, dshunreachable1 as d, currentLocale as e, page as p, reapednote1 as r, sessionnotfound2 as s, t, unexpectederror1 as u };
-//# sourceMappingURL=state.js-BKUnFOB4.js.map
+//# sourceMappingURL=state.js-DO4TvfeY.js.map

package/build/server/chunks/chunks/{watcher.js-CuX0WU5B.js → watcher.js-BJlOJaBs.js}

@@ -1,6 +1,6 @@
-import { c as readA2aConfig } from './insight-config.js-CmCFt2Kp.js';
-import { i as insertWaiting, o as openA2aDb, s as settleRow, p as pruneTerminalBefore, l as listWaiting } from './db.js-CSrMZzws.js';
-import { g as getDshConnection } from './dsh-connection.js-DjwmUFoE.js';
+import { c as readA2aConfig } from './insight-config.js-DiF58x83.js';
+import { i as insertWaiting, o as openA2aDb, s as settleRow, p as pruneTerminalBefore, l as listWaiting } from './db.js-BTsRdpsi.js';
+import { g as getDshConnection } from './dsh-connection.js-DawPog_I.js';
 import { a as entryForEvent, h as historyToEvents } from './dsh-events.js-DEZgATm-.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-CuX0WU5B.js.map
+//# sourceMappingURL=watcher.js-BJlOJaBs.js.map

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

@@ -1,8 +1,8 @@
-import { g as getRow } from '../../../../../chunks/db.js-CSrMZzws.js';
+import { g as getRow } from '../../../../../chunks/db.js-BTsRdpsi.js';
 import { j as json } from '../../../../../chunks/utils.js-CAdNO8Tu.js';
-import '../../../../../chunks/insight-config.js-CmCFt2Kp.js';
-import '../../../../../chunks/config.js-BvW5LrfQ.js';
-import '../../../../../chunks/settings-document.js-i5MkkSFH.js';
+import '../../../../../chunks/insight-config.js-DiF58x83.js';
+import '../../../../../chunks/config.js-B0w1-uCA.js';
+import '../../../../../chunks/settings-document.js-BRTO59Al.js';
 import 'node:fs';
 import 'node:path';
 import 'node:os';
@@ -36,4 +36,4 @@ var GET = ({ params }) => {
 };
 
 export { GET };
-//# sourceMappingURL=_server.ts.js-BGuC49gg.js.map
+//# sourceMappingURL=_server.ts.js-CDJ0OmUG.js.map

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

@@ -1,16 +1,16 @@
-import { a as listRecent } from '../../../../chunks/db.js-CSrMZzws.js';
-import { e as ensureStarted } from '../../../../chunks/watcher.js-CuX0WU5B.js';
+import { a as listRecent } from '../../../../chunks/db.js-BTsRdpsi.js';
+import { e as ensureStarted } from '../../../../chunks/watcher.js-BJlOJaBs.js';
 import { j as json } from '../../../../chunks/utils.js-CAdNO8Tu.js';
-import '../../../../chunks/insight-config.js-CmCFt2Kp.js';
-import '../../../../chunks/config.js-BvW5LrfQ.js';
-import '../../../../chunks/settings-document.js-i5MkkSFH.js';
+import '../../../../chunks/insight-config.js-DiF58x83.js';
+import '../../../../chunks/config.js-B0w1-uCA.js';
+import '../../../../chunks/settings-document.js-BRTO59Al.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-DjwmUFoE.js';
+import '../../../../chunks/dsh-connection.js-DawPog_I.js';
 import '../../../../chunks/dsh-events.js-DEZgATm-.js';
 import '../../../../chunks/shared.js-HQ0rfhm4.js';
 import '../../../../chunks/uneval.js-BJ9Qq2SF.js';
@@ -60,4 +60,4 @@ var GET = ({ url }) => {
 };
 
 export { GET };
-//# sourceMappingURL=_server.ts.js-BVH1ToLe.js.map
+//# sourceMappingURL=_server.ts.js-BVFSRjvv.js.map

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

@@ -1,16 +1,16 @@
-import { c as readA2aConfig } from '../../../../../chunks/insight-config.js-CmCFt2Kp.js';
-import { g as getDshConnection } from '../../../../../chunks/dsh-connection.js-DjwmUFoE.js';
-import { c as configureWatcher, r as registerWatch } from '../../../../../chunks/watcher.js-CuX0WU5B.js';
+import { c as readA2aConfig } from '../../../../../chunks/insight-config.js-DiF58x83.js';
+import { g as getDshConnection } from '../../../../../chunks/dsh-connection.js-DawPog_I.js';
+import { c as configureWatcher, r as registerWatch } from '../../../../../chunks/watcher.js-BJlOJaBs.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-BvW5LrfQ.js';
-import '../../../../../chunks/settings-document.js-i5MkkSFH.js';
+import '../../../../../chunks/config.js-B0w1-uCA.js';
+import '../../../../../chunks/settings-document.js-BRTO59Al.js';
 import 'node:fs';
 import 'node:path';
 import 'node:os';
 import 'yaml';
 import '../../../../../chunks/settings-home2.js-f75-B6RI.js';
-import '../../../../../chunks/db.js-CSrMZzws.js';
+import '../../../../../chunks/db.js-BTsRdpsi.js';
 import 'node:sqlite';
 import '../../../../../chunks/dsh-events.js-DEZgATm-.js';
 import '../../../../../chunks/shared.js-HQ0rfhm4.js';
@@ -98,4 +98,4 @@ var POST = async ({ request }) => {
 };
 
 export { POST };
-//# sourceMappingURL=_server.ts.js-a85F1GOf.js.map
+//# sourceMappingURL=_server.ts.js-Bhou8F5X.js.map