@morlay/dsh-desktop-shell 0.0.1-alpha.2

package/dist/index.mjs

@@ -0,0 +1,1849 @@
+import { r as loadAppConfig } from "./appconfig-B4kozO2F.mjs";
+import { n as resolveDshHome } from "./dshhome-C_iyJzc8.mjs";
+import { t as DESKTOP_HOST_PACKAGE } from "./official-C8RFHQyT.mjs";
+import { a as runtimeOverrides, i as installProfile, o as workspaceWithOverrides, r as PROFILE_WORKSPACE_NAME } from "./profile-project-CEAT8PEX.mjs";
+import { i as ensureSeedProfile, r as SEED_RUNTIME_DIR_NAME } from "./seed-Bg2S14hM.mjs";
+import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { BrowserWindow, app, dialog, ipcMain, nativeTheme, protocol } from "electron";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { Readable, Writable } from "node:stream";
+import { randomBytes } from "node:crypto";
+//#region src/ipc.ts
+const DESKTOP_IPC = {
+	directoryPick: "dsh-desktop:directory-pick",
+	nativeThemeSet: "dsh-desktop:native-theme-set",
+	/** 桌面流载体：页面把 Gateway 的流请求交给主进程，主进程用标准 Request 喂宿主。 */
+	streamOpen: "dsh-desktop:stream-open",
+	streamCancel: "dsh-desktop:stream-cancel",
+	/** 逻辑流的上行项（客户端 → 宿主），主进程把它们写成宿主请求体的后续行。 */
+	streamUplink: "dsh-desktop:stream-uplink",
+	/** 上行结束：主进程据此结束宿主请求体。 */
+	streamUplinkEnd: "dsh-desktop:stream-uplink-end",
+	streamChunk: "dsh-desktop:stream-chunk",
+	streamEnd: "dsh-desktop:stream-end",
+	streamError: "dsh-desktop:stream-error",
+	/** 桌面快捷键：设备偏好的读写 / 录制状态（渲染进程 → 主进程）。 */
+	shortcutsGet: "dsh-desktop:shortcuts-get",
+	shortcutsEdit: "dsh-desktop:shortcuts-edit",
+	shortcutsRecording: "dsh-desktop:shortcuts-recording",
+	shortcutsCloseWindow: "dsh-desktop:shortcuts-close-window",
+	/** 命中的原生按键手势（主进程 → 渲染进程）；渲染侧的 native keyboard 适配器消费。 */
+	shortcutsInput: "dsh-desktop:shortcuts-input",
+	/** 配置快照变化（主进程 → 渲染进程）。 */
+	shortcutsChanged: "dsh-desktop:shortcuts-changed"
+};
+/** preload 从渲染进程 argv 里读回 scheme 的参数名（主进程与 preload 共用一份）。 */
+const DESKTOP_SCHEME_ARGUMENT = "--dsh-desktop-scheme";
+/**
+* 应用页面的自定义协议：取 app 工作区 package.json 的 name 派生，避免与官方桌面应用
+* 共用同一个 scheme。去 scope 前缀、转小写、非法字符换成 `-`；派生不出合法 scheme 就报错。
+*/
+function desktopScheme(name) {
+	const bare = name.slice(name.lastIndexOf("/") + 1).toLowerCase().replaceAll(/[^a-z0-9+.-]/gu, "-");
+	if (!/^[a-z][a-z0-9+.-]*$/u.test(bare)) throw new Error(`dsh desktop: application name "${name}" does not yield a usable URL scheme (${bare})`);
+	return bare;
+}
+function assertDesktopSender(event, scheme, hostnames) {
+	const senderFrame = event.senderFrame;
+	if (senderFrame === null) throw new Error("dsh desktop: rejected IPC without a sender frame");
+	const url = new URL(senderFrame.url);
+	if (url.protocol !== `${scheme}:` || !hostnames.includes(url.hostname)) throw new Error("dsh desktop: rejected IPC from an unowned renderer");
+}
+//#endregion
+//#region src/directory-picker.ts
+function installDesktopDirectoryPicker(getWindow, scheme) {
+	const pending = /* @__PURE__ */ new WeakMap();
+	ipcMain.handle(DESKTOP_IPC.directoryPick, async (event) => {
+		const window = getWindow();
+		if (window === void 0 || window.isDestroyed() || event.sender !== window.webContents || event.senderFrame !== window.webContents.mainFrame) throw new Error("dsh desktop: rejected directory picker from an unowned renderer");
+		assertDesktopSender(event, scheme, ["app"]);
+		const existing = pending.get(window);
+		if (existing !== void 0) return existing;
+		if (window.isMinimized()) window.restore();
+		window.show();
+		window.focus();
+		const result = dialog.showOpenDialog(window, { properties: ["openDirectory", "createDirectory"] }).then(({ canceled, filePaths }) => window.isDestroyed() || canceled ? null : filePaths[0] ?? null).finally(() => {
+			pending.delete(window);
+		});
+		pending.set(window, result);
+		return result;
+	});
+}
+/** 桌面流的宿主路径：页面/主进程都用它（两侧共享一份，避免路径写两处）。 */
+const DESKTOP_STREAM_PATH = "/.dsh/remote-stream";
+/**
+* 桌面流请求体的首行：定下这条逻辑流的 endpoint 与 payload，后续行都是上行项
+* （客户端 → 宿主；`$events` 这类宿主自己的流被上游释放，不会读到它们）。
+*/
+function encodeDesktopStreamOpen(endpoint, payload) {
+	return `${JSON.stringify({
+		endpoint,
+		payload
+	})}\n`;
+}
+/** 桌面流请求体里的一道上行项。 */
+function encodeDesktopStreamItem(item) {
+	return `${JSON.stringify(item)}\n`;
+}
+/** 单个 data 帧携带的最大原始字节数。 */
+const DESKTOP_PIPE_CHUNK_BYTES = 65536;
+const FRAME_MAGIC = 1146308659;
+const FRAME_HEADER_BYTES = 13;
+const MAX_CONTROL_PAYLOAD_BYTES = 1048576;
+const REQUEST_FRAME_START = 1;
+const REQUEST_FRAME_DATA = 2;
+const REQUEST_FRAME_END = 3;
+const REQUEST_FRAME_CANCEL = 4;
+const RESPONSE_FRAME_START = 1;
+const RESPONSE_FRAME_DATA = 2;
+const RESPONSE_FRAME_END = 3;
+const RESPONSE_FRAME_ERROR = 4;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isHeaders(value) {
+	return Array.isArray(value) && value.every((header) => Array.isArray(header) && header.length === 2 && typeof header[0] === "string" && typeof header[1] === "string");
+}
+function assertStreamId(streamId) {
+	if (!Number.isInteger(streamId) || streamId < 1 || streamId > 4294967295) throw new Error(`dsh desktop: invalid pipe stream id ${String(streamId)}`);
+}
+function encodeFrame(type, streamId, payload, dataType, direction) {
+	assertStreamId(streamId);
+	const limit = type === dataType ? DESKTOP_PIPE_CHUNK_BYTES : MAX_CONTROL_PAYLOAD_BYTES;
+	if (payload.byteLength > limit) throw new Error(`dsh desktop: ${direction} pipe frame exceeds the ${String(limit)}-byte limit`);
+	const frame = Buffer.allocUnsafe(FRAME_HEADER_BYTES + payload.byteLength);
+	frame.writeUInt32BE(FRAME_MAGIC, 0);
+	frame.writeUInt8(type, 4);
+	frame.writeUInt32BE(streamId, 5);
+	frame.writeUInt32BE(payload.byteLength, 9);
+	payload.copy(frame, FRAME_HEADER_BYTES);
+	return frame;
+}
+function jsonPayload(type, streamId, value, dataType, direction) {
+	return encodeFrame(type, streamId, Buffer.from(JSON.stringify(value), "utf8"), dataType, direction);
+}
+/** 编码开启一个请求流的元数据帧（壳侧）。 */
+function encodeDesktopRequestStart(streamId, request) {
+	return jsonPayload(REQUEST_FRAME_START, streamId, request, REQUEST_FRAME_DATA, "request");
+}
+/** 编码一个受限的请求体原始分片（壳侧）。 */
+function encodeDesktopRequestData(streamId, data) {
+	return encodeFrame(REQUEST_FRAME_DATA, streamId, Buffer.from(data), REQUEST_FRAME_DATA, "request");
+}
+/** 编码请求体正常结束（壳侧）。 */
+function encodeDesktopRequestEnd(streamId) {
+	return encodeFrame(REQUEST_FRAME_END, streamId, Buffer.alloc(0), REQUEST_FRAME_DATA, "request");
+}
+/** 编码取消一个请求及其响应（壳侧）。 */
+function encodeDesktopRequestCancel(streamId) {
+	return encodeFrame(REQUEST_FRAME_CANCEL, streamId, Buffer.alloc(0), REQUEST_FRAME_DATA, "request");
+}
+function frameLength(buffer, dataType, direction) {
+	if (buffer.byteLength < FRAME_HEADER_BYTES) return void 0;
+	if (buffer.readUInt32BE(0) !== FRAME_MAGIC) throw new Error(`dsh desktop: invalid ${direction} frame marker`);
+	const type = buffer.readUInt8(4);
+	const streamId = buffer.readUInt32BE(5);
+	const payloadLength = buffer.readUInt32BE(9);
+	assertStreamId(streamId);
+	const limit = type === dataType ? DESKTOP_PIPE_CHUNK_BYTES : MAX_CONTROL_PAYLOAD_BYTES;
+	if (payloadLength > limit) throw new Error(`dsh desktop: ${direction} frame exceeds the ${String(limit)}-byte limit`);
+	const total = FRAME_HEADER_BYTES + payloadLength;
+	return buffer.byteLength < total ? void 0 : total;
+}
+function parseJson(payload, subject) {
+	try {
+		return JSON.parse(payload.toString("utf8"));
+	} catch (error) {
+		throw new Error(`dsh desktop: ${subject} payload is not JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function assertEmpty(payload, subject) {
+	if (payload.byteLength !== 0) throw new Error(`dsh desktop: ${subject} frame carried a payload`);
+}
+/** 增量解码壳侧从响应管道收到的响应帧。 */
+var DesktopHostResponseDecoder = class {
+	buffer = Buffer.alloc(0);
+	/** 追加字节并返回所有已完整的响应帧。 */
+	push(chunk) {
+		this.buffer = this.buffer.byteLength === 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+		const frames = [];
+		for (;;) {
+			const frame = this.next();
+			if (frame === void 0) return frames;
+			frames.push(frame);
+		}
+	}
+	/** EOF 落在帧中间时报错。 */
+	finish() {
+		if (this.buffer.byteLength !== 0) throw new Error("dsh desktop: response pipe ended inside a frame");
+	}
+	next() {
+		const total = frameLength(this.buffer, RESPONSE_FRAME_DATA, "response");
+		if (total === void 0) return void 0;
+		const type = this.buffer.readUInt8(4);
+		const streamId = this.buffer.readUInt32BE(5);
+		const payload = this.buffer.subarray(FRAME_HEADER_BYTES, total);
+		this.buffer = this.buffer.subarray(total);
+		switch (type) {
+			case RESPONSE_FRAME_START: return {
+				type: "start",
+				streamId,
+				...this.parseStart(payload)
+			};
+			case RESPONSE_FRAME_DATA: return {
+				type: "data",
+				streamId,
+				data: Buffer.from(payload)
+			};
+			case RESPONSE_FRAME_END:
+				assertEmpty(payload, "response end");
+				return {
+					type: "end",
+					streamId
+				};
+			case RESPONSE_FRAME_ERROR: return {
+				type: "error",
+				streamId,
+				...this.parseError(payload)
+			};
+			default: throw new Error(`dsh desktop: unknown response frame type ${String(type)}`);
+		}
+	}
+	parseStart(payload) {
+		const value = parseJson(payload, "response start");
+		if (!isRecord(value) || !Number.isInteger(value.status) || value.status < 100 || value.status > 599 || !isHeaders(value.headers) || typeof value.hasBody !== "boolean") throw new Error("dsh desktop: invalid response start payload");
+		return {
+			status: value.status,
+			headers: value.headers,
+			hasBody: value.hasBody
+		};
+	}
+	parseError(payload) {
+		const value = parseJson(payload, "response error");
+		if (!isRecord(value) || typeof value.message !== "string") throw new Error("dsh desktop: invalid response error payload");
+		return { message: value.message };
+	}
+};
+/** IPC 事件校验（壳侧）。 */
+function isDesktopHostEvent(value) {
+	if (!isRecord(value)) return false;
+	if (value.type === "ready") return value.protocolVersion === 1;
+	if (value.type === "fatal") return typeof value.message === "string" && (value.diagnostic === void 0 || typeof value.diagnostic === "string");
+	return false;
+}
+//#endregion
+//#region src/host-process.ts
+function errorOf(reason, fallback) {
+	return reason instanceof Error ? reason : new Error(fallback);
+}
+async function exitsWithin(exit, milliseconds) {
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => {
+			resolve(false);
+		}, milliseconds);
+		timer.unref();
+	});
+	try {
+		return await Promise.race([exit.then(() => true), timeout]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+/** 桌面 host 子进程：字节管道上的请求/响应载体（FD 3/4）+ Node IPC 生命周期。 */
+var DesktopHostProcess = class {
+	node;
+	runtimeDir;
+	projectDir;
+	inspectPort;
+	options;
+	child;
+	requestPipe;
+	responsePipe;
+	responseDecoder = new DesktopHostResponseDecoder();
+	requestWriteTail = Promise.resolve();
+	nextStreamId = 1;
+	pending = /* @__PURE__ */ new Map();
+	blockedResponses = /* @__PURE__ */ new Set();
+	readyResolve;
+	readyReject;
+	readyPromise = new Promise((resolve, reject) => {
+		this.readyResolve = resolve;
+		this.readyReject = reject;
+	});
+	exitPromise;
+	stderr = "";
+	failureReported = false;
+	stopping = false;
+	constructor(node, runtimeDir, projectDir, inspectPort, options = {}) {
+		this.node = node;
+		this.runtimeDir = runtimeDir;
+		this.projectDir = projectDir;
+		this.inspectPort = inspectPort;
+		this.options = options;
+	}
+	/** 启动子进程一次；`ready` 之后才解析。 */
+	async start() {
+		if (this.child !== void 0) return this.readyPromise;
+		const entry = join(this.runtimeDir, "node_modules", ...DESKTOP_HOST_PACKAGE.split("/"), "lib", "index.js");
+		const primaryRuntime = this.options.primaryRuntime ?? join(this.runtimeDir, "..", "runtime", "primary-runtime");
+		const packageManager = this.options.packageManager;
+		const args = [
+			"--expose-internals",
+			...this.options.processTitle === void 0 ? [] : [`--title=${this.options.processTitle}`],
+			...this.inspectPort === void 0 ? [] : [`--inspect=127.0.0.1:${String(this.inspectPort)}`],
+			...this.options.nodeArgs ?? [],
+			entry,
+			this.runtimeDir,
+			this.projectDir,
+			primaryRuntime,
+			...packageManager === void 0 ? [] : [packageManager.pnpm, packageManager.nodeBin]
+		];
+		const env = {
+			...Object.fromEntries(Object.entries(process.env).filter(([name]) => name !== "NODE_OPTIONS" && !name.startsWith("DSH_DESKTOP_") && !/^(?:npm|pnpm|corepack)_/iu.test(name))),
+			...this.options.extraEnv
+		};
+		const child = (this.options.spawn ?? spawn)(this.node, args, {
+			cwd: this.projectDir,
+			env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe",
+				"pipe",
+				"pipe",
+				"ipc"
+			]
+		});
+		const requestPipe = child.stdio[3];
+		const responsePipe = child.stdio[4];
+		if (!(requestPipe instanceof Writable) || !(responsePipe instanceof Readable)) {
+			child.kill("SIGTERM");
+			throw new Error("dsh desktop host did not expose the required byte pipes and IPC channel");
+		}
+		this.child = child;
+		this.requestPipe = requestPipe;
+		this.responsePipe = responsePipe;
+		child.stderr?.setEncoding("utf8");
+		child.stderr?.on("data", (chunk) => {
+			this.stderr = (this.stderr + chunk).slice(-65536);
+			process.stderr.write(`[dsh-host] ${chunk}`);
+		});
+		child.stdout?.pipe(process.stdout);
+		responsePipe.on("data", (chunk) => {
+			this.acceptResponseBytes(chunk);
+		});
+		responsePipe.once("end", () => {
+			try {
+				this.responseDecoder.finish();
+			} catch (error) {
+				this.fail(errorOf(error, "dsh desktop host response pipe failed"));
+				return;
+			}
+			this.fail(/* @__PURE__ */ new Error("dsh desktop host response pipe ended"));
+		});
+		requestPipe.once("error", (error) => {
+			this.fail(error);
+		});
+		responsePipe.once("error", (error) => {
+			this.fail(error);
+		});
+		child.on("message", (message) => {
+			if (!isDesktopHostEvent(message)) {
+				this.fail(/* @__PURE__ */ new Error("dsh desktop host sent an invalid IPC event"));
+				this.killChild("SIGTERM");
+				return;
+			}
+			if (message.type === "fatal") {
+				if (message.diagnostic !== void 0) process.stderr.write(`[dsh-host] ${message.diagnostic}\n`);
+				this.fail(new Error(message.message));
+				return;
+			}
+			this.readyResolve({ protocolVersion: message.protocolVersion });
+		});
+		child.once("error", (error) => {
+			this.fail(error);
+		});
+		this.exitPromise = new Promise((resolve) => {
+			child.once("close", (code) => {
+				const suffix = this.stderr.trim() === "" ? "" : `: ${this.stderr.trim()}`;
+				if (code !== 0 && code !== null) this.fail(/* @__PURE__ */ new Error(`dsh desktop host exited with ${String(code)}${suffix}`));
+				else this.fail(/* @__PURE__ */ new Error(`dsh desktop host stopped${suffix}`));
+				resolve();
+			});
+		});
+		return this.readyPromise;
+	}
+	/** 把一个应用协议请求（`<scheme>://app/*`）交给子进程，响应体边收边出。 */
+	async fetch(request) {
+		await this.start();
+		const child = this.child;
+		if (child === void 0 || !child.connected || this.requestPipe === void 0) throw new Error("dsh desktop host is unavailable");
+		if (this.nextStreamId > 4294967295) throw new Error("dsh desktop host exhausted its request stream ids");
+		const streamId = this.nextStreamId++;
+		const method = request.method.toUpperCase();
+		const hasBody = method !== "GET" && method !== "HEAD" && request.body !== null;
+		return new Promise((resolve, reject) => {
+			const pending = {
+				resolve,
+				reject,
+				responseStarted: false,
+				uploadOpen: hasBody
+			};
+			const abort = () => {
+				if (!this.pending.has(streamId)) return;
+				const error = errorOf(request.signal.reason, "request aborted");
+				pending.uploadOpen = false;
+				pending.requestReader?.cancel(error).catch(() => void 0);
+				this.enqueueRequestFrame(encodeDesktopRequestCancel(streamId)).catch((pipeError) => {
+					this.fail(errorOf(pipeError, "dsh desktop request pipe failed"));
+				});
+				if (pending.controller === void 0) pending.reject(error);
+				else pending.controller.error(error);
+				this.finishPending(streamId, false);
+			};
+			if (request.signal.aborted) {
+				reject(errorOf(request.signal.reason, "request aborted"));
+				return;
+			}
+			request.signal.addEventListener("abort", abort, { once: true });
+			pending.removeAbort = () => {
+				request.signal.removeEventListener("abort", abort);
+			};
+			this.pending.set(streamId, pending);
+			this.pumpRequest(streamId, request, hasBody).catch((error) => {
+				this.failPending(streamId, errorOf(error, "dsh desktop request upload failed"));
+			});
+		});
+	}
+	/** 请求优雅退出，再等子进程收尾。 */
+	async stop() {
+		const child = this.child;
+		if (child === void 0) return;
+		this.stopping = true;
+		this.blockedResponses.clear();
+		this.responsePipe?.resume();
+		if (child.connected) this.send({ type: "shutdown" });
+		this.requestPipe?.destroy();
+		const exited = this.exitPromise ?? Promise.resolve();
+		if (!await exitsWithin(exited, 1e4)) this.killChild("SIGTERM");
+		if (!await exitsWithin(exited, 5e3)) {
+			this.killChild("SIGKILL");
+			if (!await exitsWithin(exited, 5e3)) throw new Error("dsh desktop host did not exit after SIGKILL");
+		}
+		this.child = void 0;
+		this.requestPipe = void 0;
+		this.responsePipe = void 0;
+	}
+	async pumpRequest(streamId, request, hasBody) {
+		await this.enqueueRequestFrame(encodeDesktopRequestStart(streamId, {
+			url: request.url,
+			method: request.method.toUpperCase(),
+			headers: [...request.headers.entries()],
+			hasBody
+		}));
+		if (!hasBody) return;
+		const body = request.body;
+		if (body === null) throw new Error("dsh desktop request body disappeared before upload");
+		const reader = body.getReader();
+		const pending = this.pending.get(streamId);
+		if (pending === void 0) {
+			await reader.cancel();
+			return;
+		}
+		pending.requestReader = reader;
+		try {
+			for (;;) {
+				const next = await reader.read();
+				if (next.done) break;
+				for (let offset = 0; offset < next.value.byteLength; offset += DESKTOP_PIPE_CHUNK_BYTES) {
+					if (!this.pending.has(streamId)) return;
+					await this.enqueueRequestFrame(encodeDesktopRequestData(streamId, next.value.subarray(offset, offset + DESKTOP_PIPE_CHUNK_BYTES)));
+				}
+			}
+			const live = this.pending.get(streamId);
+			if (live !== void 0) {
+				await this.enqueueRequestFrame(encodeDesktopRequestEnd(streamId));
+				live.uploadOpen = false;
+			}
+		} finally {
+			reader.releaseLock();
+			const live = this.pending.get(streamId);
+			if (live?.requestReader === reader) delete live.requestReader;
+		}
+	}
+	enqueueRequestFrame(frame) {
+		const write = this.requestWriteTail.then(async () => {
+			const pipe = this.requestPipe;
+			if (pipe === void 0 || pipe.destroyed) throw new Error("dsh desktop host request pipe is unavailable");
+			if (!pipe.write(frame)) await once(pipe, "drain");
+		});
+		this.requestWriteTail = write.catch(() => void 0);
+		return write;
+	}
+	send(message) {
+		const child = this.child;
+		if (child === void 0 || !child.connected) throw new Error("dsh desktop host IPC is unavailable");
+		child.send(message, (error) => {
+			if (error !== null) this.fail(error);
+		});
+	}
+	acceptResponseBytes(chunk) {
+		try {
+			for (const frame of this.responseDecoder.push(chunk)) this.handleResponseFrame(frame);
+		} catch (error) {
+			this.fail(errorOf(error, "dsh desktop host response pipe failed"));
+			this.killChild("SIGTERM");
+		}
+	}
+	handleResponseFrame(frame) {
+		const pending = this.pending.get(frame.streamId);
+		if (pending === void 0) {
+			if (frame.streamId >= this.nextStreamId) throw new Error(`dsh desktop host responded for unknown stream ${String(frame.streamId)}`);
+			return;
+		}
+		switch (frame.type) {
+			case "start": {
+				if (pending.responseStarted) throw new Error(`dsh desktop host started stream ${String(frame.streamId)} twice`);
+				pending.responseStarted = true;
+				let body = null;
+				if (frame.hasBody) body = new ReadableStream({
+					start: (controller) => {
+						pending.controller = controller;
+					},
+					pull: () => {
+						this.blockedResponses.delete(frame.streamId);
+						this.resumeResponsePipe();
+					},
+					cancel: (reason) => {
+						this.cancelResponse(frame.streamId, reason);
+					}
+				});
+				pending.resolve(new Response(body, {
+					status: frame.status,
+					headers: new Headers(frame.headers.map(([name, value]) => [name, value]))
+				}));
+				return;
+			}
+			case "data": {
+				const controller = pending.controller;
+				if (!pending.responseStarted || controller === void 0) throw new Error(`dsh desktop host sent body data before a body start for stream ${String(frame.streamId)}`);
+				controller.enqueue(frame.data);
+				if ((controller.desiredSize ?? 0) <= 0) {
+					this.blockedResponses.add(frame.streamId);
+					this.responsePipe?.pause();
+				}
+				return;
+			}
+			case "end":
+				if (!pending.responseStarted) throw new Error(`dsh desktop host ended stream ${String(frame.streamId)} before its response start`);
+				pending.controller?.close();
+				this.finishPending(frame.streamId, true);
+				return;
+			case "error":
+				this.failPending(frame.streamId, new Error(frame.message));
+				return;
+			default: return;
+		}
+	}
+	cancelResponse(streamId, reason) {
+		const pending = this.pending.get(streamId);
+		if (pending === void 0) return;
+		pending.uploadOpen = false;
+		pending.requestReader?.cancel(reason).catch(() => void 0);
+		this.enqueueRequestFrame(encodeDesktopRequestCancel(streamId)).catch((error) => {
+			this.fail(errorOf(error, "dsh desktop request pipe failed"));
+		});
+		this.finishPending(streamId, false);
+	}
+	failPending(streamId, error) {
+		const pending = this.pending.get(streamId);
+		if (pending === void 0) return;
+		pending.uploadOpen = false;
+		pending.requestReader?.cancel(error).catch(() => void 0);
+		if (pending.controller === void 0) pending.reject(error);
+		else pending.controller.error(error);
+		this.enqueueRequestFrame(encodeDesktopRequestCancel(streamId)).catch((pipeError) => {
+			this.fail(errorOf(pipeError, "dsh desktop request pipe failed"));
+		});
+		this.finishPending(streamId, false);
+	}
+	finishPending(streamId, cancelOpenUpload) {
+		const pending = this.pending.get(streamId);
+		if (pending === void 0) return;
+		if (cancelOpenUpload && pending.uploadOpen) {
+			pending.uploadOpen = false;
+			pending.requestReader?.cancel().catch(() => void 0);
+			this.enqueueRequestFrame(encodeDesktopRequestCancel(streamId)).catch((error) => {
+				this.fail(errorOf(error, "dsh desktop request pipe failed"));
+			});
+		}
+		pending.removeAbort?.();
+		this.pending.delete(streamId);
+		this.blockedResponses.delete(streamId);
+		this.resumeResponsePipe();
+	}
+	resumeResponsePipe() {
+		if (this.blockedResponses.size === 0) this.responsePipe?.resume();
+	}
+	killChild(signal) {
+		const child = this.child;
+		if (child === void 0 || child.pid === void 0) return;
+		if (process.platform !== "win32") try {
+			process.kill(-child.pid, signal);
+			return;
+		} catch (error) {
+			if (error.code !== "ESRCH") throw error;
+		}
+		child.kill(signal);
+	}
+	fail(error) {
+		if (!this.stopping) this.readyReject(error);
+		if (!this.failureReported && !this.stopping) {
+			this.failureReported = true;
+			try {
+				this.options.onFailure?.(error);
+			} catch (listenerError) {
+				console.error(listenerError);
+			}
+		}
+		const closing = this.stopping;
+		for (const pending of this.pending.values()) {
+			pending.requestReader?.cancel(error).catch(() => void 0);
+			if (closing) pending.resolve(new Response("desktop host is shutting down", { status: 503 }));
+			else if (pending.controller === void 0) pending.reject(error);
+			else pending.controller.error(error);
+			pending.removeAbort?.();
+		}
+		this.pending.clear();
+		this.blockedResponses.clear();
+		this.responsePipe?.resume();
+	}
+};
+//#endregion
+//#region ../../../vendor/deepseek-harness/packages/util/values/lib/index.js
+/** Duplicate-install-safe JSON and immutable-value helpers. @module @deepseek-ai/dsh-util-values */
+/**
+* Mark an unreachable closed-union branch.
+* @param value - impossible value; an unhandled typed variant fails at the call site.
+* @param context - optional switch-site label included in the failure message.
+* @returns never; a runtime value that escaped its type always throws.
+*/
+function assertNever(value, context) {
+	const rendered = JSON.stringify(value) ?? String(value);
+	throw new Error(`unreachable variant${context ? ` in ${context}` : ""}: ${rendered}`);
+}
+//#endregion
+//#region ../../../vendor/deepseek-harness/packages/util/crypto/lib/index.js
+/**
+* Random v4 UUID, minted from `crypto.getRandomValues`.
+* @returns the UUID string.
+*/
+function randomUUID() {
+	const bytes = globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+	const hex = Array.from(bytes, (byte, index) => {
+		return (index === 6 ? byte & 15 | 64 : index === 8 ? byte & 63 | 128 : byte).toString(16).padStart(2, "0");
+	}).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+//#endregion
+//#region ../../../vendor/deepseek-harness/packages/client/shortcuts/lib/protocol.js
+const keyNames = {
+	Slash: "/",
+	Comma: ",",
+	Period: ".",
+	Backslash: "\\",
+	Backquote: "`",
+	Minus: "-",
+	Equal: "=",
+	BracketLeft: "[",
+	BracketRight: "]",
+	Semicolon: ";",
+	Quote: "'",
+	Enter: "Enter",
+	Escape: "Esc",
+	Space: "Space",
+	Tab: "Tab",
+	Backspace: "Backspace",
+	Delete: "Delete",
+	ArrowUp: "↑",
+	ArrowDown: "↓",
+	ArrowLeft: "←",
+	ArrowRight: "→"
+};
+const modifierOrder = [
+	"control",
+	"alt",
+	"shift",
+	"meta"
+];
+/**
+* Expand logical modifiers, deduplicate, and validate the physical code.
+* @param binding - declared binding.
+* @param platform - receiving device platform.
+* @returns canonical binding; unsupported codes throw during registration.
+*/
+function normalizeBinding(binding, platform) {
+	const codes = [binding.code, ...binding.secondCode === void 0 ? [] : [binding.secondCode]];
+	codes.sort();
+	for (const code of codes) if (!/^(Key[A-Z]|Digit[0-9]|F([1-9]|1[0-9]|2[0-4]))$/u.test(code) && !Object.hasOwn(keyNames, code)) throw new Error(`Unsupported shortcut code: ${code}`);
+	if (codes.length === 2 && codes[0] === codes[1]) throw new Error("Shortcut keys must be distinct");
+	const modifiers = new Set(binding.modifiers.map((value) => value === "primary" ? platform === "macos" ? "meta" : "control" : value));
+	return {
+		code: codes[0],
+		...codes[1] === void 0 ? {} : { secondCode: codes[1] },
+		modifiers: modifierOrder.filter((value) => modifiers.has(value))
+	};
+}
+/**
+* Produce an exact-match index from a normalized binding.
+* @param binding - normalized physical key and modifiers.
+* @returns stable index used for both matching and conflict checks.
+*/
+function bindingKey(binding) {
+	const codes = binding.secondCode === void 0 ? [binding.code] : [binding.code, binding.secondCode].sort();
+	return [...binding.modifiers, ...codes].join("+");
+}
+/**
+* Check Web combinations: Windows and macOS also admit any three or four modifiers; Linux retains the limited set.
+* @param binding - normalized candidate.
+* @param platform - receiving device platform.
+* @returns whether this combination is admitted; admission does not guarantee browser or system delivery.
+*/
+function isWebBindingAllowed(binding, platform) {
+	if (binding.secondCode !== void 0) return false;
+	if (platform === "windows" || platform === "macos") {
+		if (binding.modifiers.length >= 3) return true;
+		const primary = platform === "macos" ? "meta" : "control";
+		if (binding.modifiers.length === 1 && (["Comma", "Backslash"].includes(binding.code) && binding.modifiers[0] === primary || binding.code === "Backquote" && binding.modifiers[0] === "control")) return true;
+		if (binding.modifiers.length === 2 && binding.modifiers.includes(primary) && (binding.modifiers.includes("alt") || binding.modifiers.includes("shift"))) return true;
+	}
+	return [
+		{
+			code: "Slash",
+			modifiers: ["primary"]
+		},
+		{
+			code: "Comma",
+			modifiers: ["primary", "shift"]
+		},
+		{
+			code: "Period",
+			modifiers: ["primary", "shift"]
+		}
+	].some((candidate) => bindingKey(binding) === bindingKey(normalizeBinding(candidate, platform)));
+}
+/** Validated preference documents and deterministic conflict resolution, without browser dependencies. */
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const commandPattern = /^[a-z][a-zA-Z0-9-]*(?:\.[a-zA-Z][a-zA-Z0-9-]*)+$/u;
+/**
+* Validate JSON binding fields before normalization; unknown fields are rejected to prevent lossy rewrites.
+* @param value - file or IPC input.
+* @returns a binding with a supported physical code, or null for explicit removal.
+*/
+function parseBinding(value) {
+	if (value === null) return null;
+	if (!record(value) || Object.keys(value).some((key) => key !== "code" && key !== "secondCode" && key !== "modifiers") || typeof value.code !== "string" || !Array.isArray(value.modifiers) || Object.hasOwn(value, "secondCode") && typeof value.secondCode !== "string" || !value.modifiers.every((modifier) => typeof modifier === "string" && [
+		"primary",
+		"control",
+		"alt",
+		"shift",
+		"meta"
+	].includes(modifier))) throw new Error("Invalid shortcut binding");
+	const binding = {
+		code: value.code,
+		modifiers: value.modifiers,
+		...typeof value.secondCode === "string" ? { secondCode: value.secondCode } : {}
+	};
+	normalizeBinding(binding, "windows");
+	return binding;
+}
+/**
+* Decode the complete document while preserving dormant command overrides.
+* @param raw - stored JSON, or null for a missing document.
+* @returns the accepted document or a classified read failure.
+*/
+function parseShortcutDocument(raw) {
+	if (raw === null) return {
+		schemaVersion: 1,
+		profiles: {}
+	};
+	try {
+		const value = JSON.parse(raw);
+		if (!record(value)) return "invalid";
+		if (typeof value.schemaVersion === "number" && value.schemaVersion > 2) return "future";
+		if (value.schemaVersion !== 1 && value.schemaVersion !== 2 || !record(value.profiles) || Object.keys(value).some((key) => key !== "schemaVersion" && key !== "profiles")) return "invalid";
+		const profiles = {};
+		for (const [profile, overrides] of Object.entries(value.profiles)) {
+			if (!/^(desktop|web):(macos|windows|linux)$/u.test(profile) || !record(overrides)) return "invalid";
+			const bindings = {};
+			for (const [id, binding] of Object.entries(overrides)) {
+				if (!commandPattern.test(id)) return "invalid";
+				const parsed = parseBinding(binding);
+				if (value.schemaVersion === 1 && parsed?.secondCode !== void 0) return "invalid";
+				bindings[id] = parsed;
+			}
+			profiles[profile] = bindings;
+		}
+		return {
+			schemaVersion: value.schemaVersion,
+			profiles
+		};
+	} catch (_error) {
+		return "invalid";
+	}
+}
+/**
+* Check system, editor, and browser reservations using expanded physical modifiers.
+* @param binding - normalized candidate.
+* @param runtime - receiving application shell.
+* @param platform - receiving device.
+* @returns the rejection reason, or null when this combination is allowed.
+*/
+function bindingIssue(binding, runtime, platform) {
+	const { code, modifiers } = binding;
+	if (runtime === "desktop" && (platform === "windows" || platform === "macos")) return null;
+	if (binding.secondCode !== void 0) return "unsupported-key";
+	if (modifiers.length === 0 || modifiers.every((modifier) => modifier === "shift")) return "modifier-required";
+	if ((platform === "windows" || platform === "macos") && modifiers.length >= 3) return null;
+	if (runtime === "web" && (platform === "windows" || platform === "macos") && isWebBindingAllowed(binding, platform)) return null;
+	const primary = modifiers.includes(platform === "macos" ? "meta" : "control");
+	if ([
+		"Escape",
+		"Tab",
+		"Space",
+		"Backspace",
+		"Delete",
+		"ArrowUp",
+		"ArrowDown",
+		"ArrowLeft",
+		"ArrowRight"
+	].includes(code) || code === "Enter" && !modifiers.includes("alt") || primary && [
+		"KeyC",
+		"KeyV",
+		"KeyX",
+		"KeyZ",
+		"KeyY",
+		"KeyQ",
+		"KeyH"
+	].includes(code) || primary && code === "KeyA" && !modifiers.includes("shift") || platform !== "macos" && (modifiers.includes("meta") || modifiers.includes("alt") && ["F4", "F2"].includes(code)) || platform === "macos" && modifiers.includes("control") && modifiers.includes("meta") || platform === "macos" && modifiers.includes("alt") && !primary) return "reserved";
+	if (runtime === "web" && !isWebBindingAllowed(binding, platform)) return "unsupported-browser";
+	return null;
+}
+/**
+* Select the command owner's explicit default for one device profile.
+* @param definition - command identity and per-profile defaults.
+* @param runtime - receiving shell.
+* @param platform - receiving device.
+* @returns the declared physical binding, or undefined for an unbound action.
+*/
+function resolveShortcutDefault(definition, runtime, platform) {
+	return definition.defaults[`${runtime}:${platform}`];
+}
+/**
+* Resolve overrides and conflicts independently of registration order. Explicit overrides displace defaults.
+* @param definitions - active commands.
+* @param document - accepted preferences.
+* @param runtime - receiving shell.
+* @param platform - receiving device.
+* @returns every active command, including unavailable conflicting bindings.
+*/
+function effectiveShortcuts(definitions, document, runtime, platform) {
+	const overrides = document.profiles[`${runtime}:${platform}`] ?? {};
+	const fixed = definitions.flatMap((row) => row.fixed?.map((binding) => ({
+		id: row.id,
+		binding: normalizeBinding(binding, platform)
+	})) ?? []);
+	const rows = definitions.filter((row) => row.fixed === void 0).map(({ id, defaults }) => {
+		const modified = Object.hasOwn(overrides, id);
+		const candidate = modified ? overrides[id] : resolveShortcutDefault({
+			id,
+			defaults
+		}, runtime, platform);
+		const binding = candidate == null ? null : normalizeBinding(candidate, platform);
+		return {
+			id,
+			binding,
+			modified,
+			issue: binding === null ? null : bindingIssue(binding, runtime, platform)
+		};
+	});
+	return rows.map((row) => {
+		const binding = row.binding;
+		return {
+			...row,
+			conflicts: binding === null ? [] : [.../* @__PURE__ */ new Set([...rows.filter((other) => other.id !== row.id && other.binding !== null && other.issue === null && overlappingBindings(other.binding, binding) && (!row.modified || other.modified)).map((other) => other.id), ...fixed.filter((other) => overlappingBindings(other.binding, binding)).map((other) => other.id)])]
+		};
+	});
+}
+/**
+* Detect identical combinations or a single key contained in a two-key chord.
+* @param left - normalized candidate.
+* @param right - normalized occupied binding.
+* @returns whether both bindings require the same modifiers and overlap.
+*/
+function overlappingBindings(left, right) {
+	if (left.modifiers.join("+") !== right.modifiers.join("+")) return false;
+	if (left.secondCode !== void 0 && right.secondCode !== void 0) return bindingKey(left) === bindingKey(right);
+	return [left.code, left.secondCode].some((code) => code !== void 0 && (code === right.code || code === right.secondCode));
+}
+/**
+* Apply an edit without modifying other profiles or dormant overrides.
+* @param document - accepted document.
+* @param edit - validated operation.
+* @param runtime - current shell.
+* @param platform - current device.
+* @returns the candidate document, pending conflict checks and durable storage.
+*/
+function editShortcutDocument(document, edit, runtime, platform) {
+	const schemaVersion = runtime === "desktop" && (platform === "macos" || platform === "windows") ? 2 : document.schemaVersion;
+	const profile = `${runtime}:${platform}`;
+	let overrides = { ...document.profiles[profile] };
+	switch (edit.type) {
+		case "set":
+			overrides[edit.id] = edit.binding;
+			break;
+		case "reset": {
+			const { [edit.id]: _removed, ...remaining } = overrides;
+			overrides = remaining;
+			break;
+		}
+		case "reset-all":
+			overrides = {};
+			break;
+		/* v8 ignore next -- parseShortcutEdit validates this closed union before persistence. */
+		default: return assertNever(edit, "shortcut edit");
+	}
+	return {
+		schemaVersion,
+		profiles: {
+			...document.profiles,
+			[profile]: overrides
+		}
+	};
+}
+/**
+* Validate a preference edit at the Desktop IPC boundary.
+* @param value - untrusted renderer request.
+* @returns the constrained operation; malformed requests throw.
+*/
+function parseShortcutEdit(value) {
+	if (!record(value)) throw new Error("Invalid shortcut edit");
+	if (value.type === "reset-all" && Object.keys(value).length === 1) return { type: value.type };
+	if (typeof value.id !== "string" || !commandPattern.test(value.id)) throw new Error("Invalid shortcut command");
+	if (value.type === "reset" && Object.keys(value).length === 2) return {
+		type: "reset",
+		id: value.id
+	};
+	if (value.type === "set" && Object.keys(value).length === 3) return {
+		type: "set",
+		id: value.id,
+		binding: parseBinding(value.binding)
+	};
+	throw new Error("Invalid shortcut edit");
+}
+/**
+* Validate the trusted product's serializable command catalog at IPC ingress.
+* @param value - renderer-supplied active command definitions.
+* @returns validated definitions; duplicate IDs, overlapping defaults, and unsupported combinations throw.
+*/
+function parseShortcutDefinitions(value) {
+	if (!Array.isArray(value)) throw new Error("Invalid shortcut catalog");
+	const ids = /* @__PURE__ */ new Set();
+	for (const entry of value) {
+		if (!record(entry) || typeof entry.id !== "string" || !commandPattern.test(entry.id) || ids.has(entry.id) || !record(entry.defaults) || Object.keys(entry).some((key) => key !== "id" && key !== "defaults" && key !== "fixed")) throw new Error("Invalid shortcut definition");
+		ids.add(entry.id);
+		if (Object.hasOwn(entry, "fixed")) {
+			if (!Array.isArray(entry.fixed) || entry.fixed.length === 0 || Object.keys(entry.defaults).length > 0) throw new Error("Invalid fixed shortcut definition");
+			for (const binding of entry.fixed) if (parseBinding(binding) === null) throw new Error("Invalid fixed shortcut binding");
+		}
+		for (const [profile, candidate] of Object.entries(entry.defaults)) {
+			if (!/^(desktop|web):(macos|windows|linux)$/u.test(profile)) throw new Error("Invalid shortcut profile");
+			if (parseBinding(candidate) === null) throw new Error("Invalid shortcut default");
+		}
+	}
+	const definitions = value;
+	for (const runtime of ["desktop", "web"]) for (const platform of [
+		"macos",
+		"windows",
+		"linux"
+	]) {
+		const bindings = [];
+		for (const entry of definitions) {
+			const binding = resolveShortcutDefault(entry, runtime, platform);
+			if (binding === void 0) continue;
+			const normalized = normalizeBinding(binding, platform);
+			if (bindings.some((other) => overlappingBindings(other, normalized)) || bindingIssue(normalized, runtime, platform) !== null) throw new Error("Conflicting or reserved shortcut default");
+			bindings.push(normalized);
+		}
+	}
+	return definitions;
+}
+/** Serialized preference transactions; storage owners publish only accepted writes or read diagnostics. */
+/**
+* Create a disabled initial snapshot for asynchronous adapter startup.
+* @returns a fresh configuration with no accepted persisted state.
+*/
+function initialShortcutConfig() {
+	return {
+		revision: randomUUID(),
+		sequence: 0,
+		document: {
+			schemaVersion: 1,
+			profiles: {}
+		},
+		status: "loading",
+		error: null,
+		usingDefaults: true
+	};
+}
+/** Single-writer coordinator shared by localStorage and Electron's atomic file adapter. */
+var ShortcutPersistence = class {
+	storage;
+	runtime;
+	platform;
+	rereadBeforeWrite;
+	publish;
+	snapshot = initialShortcutConfig();
+	raw;
+	queue = Promise.resolve();
+	definitions = null;
+	active = true;
+	constructor(storage, runtime, platform, rereadBeforeWrite, publish) {
+		this.storage = storage;
+		this.runtime = runtime;
+		this.platform = platform;
+		this.rereadBeforeWrite = rereadBeforeWrite;
+		this.publish = publish;
+	}
+	/**
+	* Install or revoke a product catalog and invalidate drafts from its previous lifetime.
+	* @param definitions - current trusted definitions, or null while the product is not ready.
+	*/
+	setDefinitions(definitions) {
+		this.definitions = definitions;
+		this.accept({ ...this.snapshot });
+	}
+	/** Stop accepting edits or publishing late completions. */
+	dispose() {
+		this.active = false;
+	}
+	/**
+	* Read the current file; failures retain the last accepted document and disable ordinary writes.
+	* @returns the accepted snapshot or diagnostic snapshot.
+	*/
+	readCurrent() {
+		return this.serialize(() => this.read());
+	}
+	/**
+	* Compare the draft revision, validate the complete candidate, then persist before publishing.
+	* @param edit - constrained preference operation.
+	* @param revision - state against which the user reviewed the edit.
+	* @returns a classified outcome and the currently accepted snapshot.
+	*/
+	edit(edit, revision) {
+		return this.serialize(async () => {
+			if (this.rereadBeforeWrite) await this.read();
+			const result = (status) => ({
+				status,
+				snapshot: this.snapshot
+			});
+			if (!this.active || this.definitions === null || this.snapshot.status === "loading") return result("not-ready");
+			if (revision !== this.snapshot.revision) return result("stale");
+			if (this.snapshot.status === "unreadable") return result("unreadable");
+			if ((edit.type === "set" || edit.type === "reset") && !this.definitions.some((row) => row.id === edit.id && row.fixed === void 0)) return result("not-ready");
+			const document = editShortcutDocument(this.snapshot.document, edit, this.runtime, this.platform);
+			const rows = effectiveShortcuts(this.definitions, document, this.runtime, this.platform);
+			const invalid = rows.find((row) => (edit.type === "reset-all" || row.id === edit.id) && (row.issue !== null || row.conflicts.length > 0));
+			const displaced = edit.type === "set" ? rows.find((row) => row.conflicts.includes(edit.id)) : void 0;
+			if (invalid !== void 0 || displaced !== void 0) return {
+				...result("conflict"),
+				...invalid?.issue ? { issue: invalid.issue } : {},
+				conflicts: invalid?.conflicts.length ? invalid.conflicts : displaced === void 0 ? [] : [displaced.id]
+			};
+			try {
+				const raw = `${JSON.stringify(document, null, 2)}\n`;
+				await this.storage.write(raw);
+				this.raw = raw;
+				this.accept({
+					...this.snapshot,
+					document,
+					status: "ready",
+					error: null,
+					usingDefaults: false
+				});
+				return result("saved");
+			} catch (_error) {
+				return result("write-failed");
+			}
+		});
+	}
+	serialize(operation) {
+		const next = this.queue.then(operation);
+		this.queue = next.catch(() => void 0);
+		return next;
+	}
+	accept(snapshot) {
+		this.snapshot = {
+			...snapshot,
+			sequence: this.snapshot.sequence + 1,
+			revision: randomUUID()
+		};
+		if (!this.active) return;
+		try {
+			this.publish(this.snapshot);
+		} catch (error) {
+			console.error("Shortcut configuration subscriber failed:", error);
+		}
+	}
+	async read() {
+		let raw;
+		try {
+			raw = await this.storage.read();
+		} catch (_error) {
+			if (this.snapshot.error !== "read") this.accept({
+				...this.snapshot,
+				status: "unreadable",
+				error: "read"
+			});
+			return this.snapshot;
+		}
+		if (raw === this.raw && this.snapshot.error !== "read") return this.snapshot;
+		this.raw = raw;
+		const document = parseShortcutDocument(raw);
+		if (typeof document === "string") this.accept({
+			...this.snapshot,
+			status: "unreadable",
+			error: document
+		});
+		else this.accept({
+			...this.snapshot,
+			document,
+			status: "ready",
+			error: null,
+			usingDefaults: raw === null
+		});
+		return this.snapshot;
+	}
+};
+//#endregion
+//#region ../../../vendor/deepseek-harness/packages/util/atomic-write/lib/index.js
+/**
+* Zero-dependency atomic file replacement and writer coordination.
+* `writeFileAtomic` writes a random-suffix sibling with exclusive create and
+* the caller's permission bits, then renames it over the target, so readers
+* observe either the old or the new complete content and a replaced file ends
+* up with exactly the stated mode. `withFileLock` serializes cross-process
+* writers of one file through a `wx`-created `<file>.lock` sibling, so a
+* read-modify-write cycle can never resurrect a state another writer just
+* replaced; readers stay lock-free because the rename commit is atomic. A lock
+* whose recorded holder process no longer exists is taken over.
+* @module @deepseek-ai/dsh-atomic-write
+*/
+const WINDOWS_TRANSIENT_RENAME_ERRORS = /* @__PURE__ */ new Set([
+	"EACCES",
+	"EBUSY",
+	"EPERM"
+]);
+const WINDOWS_RENAME_RETRY_INITIAL_MS = 20;
+const WINDOWS_RENAME_RETRY_MAX_MS = 200;
+const WINDOWS_RENAME_RETRY_LIMIT = 8;
+/** Whether Windows reported temporary interference with an atomic replacement. */
+function isTransientWindowsRenameError(error) {
+	if (process.platform !== "win32") return false;
+	return WINDOWS_TRANSIENT_RENAME_ERRORS.has(error?.code ?? "");
+}
+/** Replace the target after bounded retries for transient Windows interference. */
+async function renameAtomicTemp(temp, filename) {
+	let delay = WINDOWS_RENAME_RETRY_INITIAL_MS;
+	for (let retries = 0;; retries += 1) {
+		try {
+			await rename(temp, filename);
+			return;
+		} catch (error) {
+			if (!isTransientWindowsRenameError(error)) throw error;
+			if (retries >= WINDOWS_RENAME_RETRY_LIMIT) throw error;
+		}
+		await new Promise((resolve) => setTimeout(resolve, delay));
+		delay = Math.min(delay * 2, WINDOWS_RENAME_RETRY_MAX_MS);
+	}
+}
+/**
+* Replace `filename` with `content` in one atomic step, creating parent
+* directories. The content is first written to a random-suffix sibling opened
+* with exclusive create (`wx`): the open refuses to follow a symlink planted
+* at the temp path, and the fresh inode carries `options.mode` through the
+* rename, so replacing a wider-permission file narrows it without a chmod
+* race. The rename also replaces a symlinked target itself instead of writing
+* through to its referent, and the same-directory sibling keeps the rename on
+* one filesystem. Windows replacement retries transient `EACCES`, `EBUSY`,
+* and `EPERM` failures for a bounded interval while the complete temp file
+* remains the rename source. On any remaining failure the temp file is
+* removed and the failure rethrown. Crash durability (fsync) is out of scope.
+* @param filename - final path receiving the content.
+* @param content - complete next file content.
+* @param options - permission bits for the replacement inode.
+*/
+async function writeFileAtomic(filename, content, options) {
+	await mkdir(dirname(filename), {
+		recursive: true,
+		...options.dirMode === void 0 ? {} : { mode: options.dirMode }
+	});
+	const temp = `${filename}.${randomBytes(6).toString("hex")}.tmp`;
+	try {
+		await writeFile(temp, content, {
+			mode: options.mode,
+			flag: "wx"
+		});
+		await renameAtomicTemp(temp, filename);
+	} catch (error) {
+		await rm(temp, { force: true });
+		throw error;
+	}
+}
+//#endregion
+//#region src/keybindings.ts
+/** 设备本地的快捷键偏好（Electron userData 下）：原子替换、单写者协调。 */
+/**
+* 打开设备配置（原子替换）。
+* @param userData - Electron 的 userData 目录，不接受渲染进程给的路径。
+* @param platform - 本机输入平台。
+* @param publish - 提交后更新原生绑定索引与受信页面。
+* @returns 单写者事务协调器。
+*/
+function desktopKeybindings(userData, platform, publish) {
+	const path = join(userData, "keybindings.json");
+	return new ShortcutPersistence({
+		read: async () => {
+			try {
+				return await readFile(path, "utf8");
+			} catch (error) {
+				if (error.code === "ENOENT") return null;
+				throw error;
+			}
+		},
+		write: (raw) => writeFileAtomic(path, raw, {
+			mode: 384,
+			dirMode: 448
+		})
+	}, "desktop", platform, false, publish);
+}
+//#endregion
+//#region src/shortcuts.ts
+/**
+* 桌面快捷键的原生侧：设备偏好持久化 + 原生按键转发 + 关闭窗口动作。
+*
+* 上游 `@deepseek-ai/dsh-client-shortcuts` 在 `data-platform` 存在时按 desktop 运行时起服务，
+* 并**强制要求** `window.dshDesktop.keyboard`（缺了就构造失败）——这里就是那份契约的实现：
+* 主进程按已绑定键过滤物理按键，把命中的手势经 IPC 交给渲染进程派发。
+*/
+/**
+* 装上桌面快捷键的原生侧。
+* @param getWindow - 当前主窗口。
+* @param userData - Electron 的 userData 目录。
+* @param platform - 本机输入平台。
+* @param scheme - 产品页面的自定义协议（校验 IPC 来源）。
+* @returns 窗口接入与释放操作。
+*/
+function installDesktopShortcuts(getWindow, userData, platform, scheme) {
+	let definitions = [];
+	let recording = false;
+	let revision;
+	let keys = /* @__PURE__ */ new Set();
+	const publish = (snapshot) => {
+		revision = definitions.length === 0 || snapshot.status === "loading" ? void 0 : snapshot.revision;
+		const rows = snapshot.status === "loading" ? [] : effectiveShortcuts(definitions, snapshot.document, "desktop", platform);
+		keys = new Set(rows.flatMap((row) => row.binding !== null && row.issue === null && row.conflicts.length === 0 ? [bindingKey(row.binding)] : []));
+		const window = getWindow();
+		if (window !== void 0 && !window.isDestroyed()) window.webContents.send(DESKTOP_IPC.shortcutsChanged, snapshot);
+	};
+	const persistence = desktopKeybindings(userData, platform, publish);
+	const windowOf = (event) => {
+		assertDesktopSender(event, scheme, ["app"]);
+		const window = getWindow();
+		if (window === void 0 || window.isDestroyed() || event.sender !== window.webContents) throw new Error("desktop shortcuts: rejected sender");
+		return window;
+	};
+	ipcMain.handle(DESKTOP_IPC.shortcutsGet, (event, input) => {
+		windowOf(event);
+		definitions = parseShortcutDefinitions(input);
+		persistence.setDefinitions(definitions);
+		return persistence.readCurrent();
+	});
+	ipcMain.handle(DESKTOP_IPC.shortcutsEdit, (event, input, expected) => {
+		windowOf(event);
+		if (typeof expected !== "string") throw new Error("desktop shortcuts: invalid revision");
+		return persistence.edit(parseShortcutEdit(input), expected);
+	});
+	ipcMain.handle(DESKTOP_IPC.shortcutsRecording, (event, active) => {
+		const window = windowOf(event);
+		if (typeof active !== "boolean") throw new Error("desktop shortcuts: invalid recording state");
+		recording = active;
+		window.webContents.setIgnoreMenuShortcuts(active);
+	});
+	ipcMain.handle(DESKTOP_IPC.shortcutsCloseWindow, (event, expected) => {
+		const window = windowOf(event);
+		if (expected !== revision || revision === void 0 || recording) return;
+		if (!window.isFocused() || !window.isEnabled()) return;
+		window.close();
+	});
+	const attach = (window) => {
+		const contents = window.webContents;
+		let deadKey = false;
+		const held = /* @__PURE__ */ new Set();
+		const consumed = /* @__PURE__ */ new Map();
+		const resetInput = () => {
+			deadKey = false;
+			held.clear();
+			consumed.clear();
+			if (!contents.isDestroyed()) contents.setIgnoreMenuShortcuts(false);
+		};
+		const clear = () => {
+			resetInput();
+			definitions = [];
+			keys.clear();
+			recording = false;
+			persistence.setDefinitions(null);
+		};
+		const beforeInput = (event, input) => {
+			if (event.defaultPrevented) {
+				resetInput();
+				return;
+			}
+			if (window !== getWindow() || !window.isFocused() || !window.isEnabled() || revision === void 0) {
+				contents.setIgnoreMenuShortcuts(false);
+				held.clear();
+				consumed.clear();
+				return;
+			}
+			const modifiers = [
+				"control",
+				"alt",
+				"shift",
+				"meta"
+			].filter((modifier) => input[modifier]);
+			const key = bindingKey({
+				code: input.code,
+				modifiers
+			});
+			const match = keys.has(key);
+			contents.setIgnoreMenuShortcuts(recording || match);
+			const composing = input.isComposing || input.key === "Dead" || deadKey || input.modifiers.includes("altgr");
+			if (input.type === "keyDown") deadKey = input.key === "Dead";
+			if (recording || composing) {
+				held.clear();
+				consumed.clear();
+				return;
+			}
+			let binding = {
+				code: input.code,
+				modifiers
+			};
+			let priority = false;
+			const modifierKey = /^(Control|Alt|Shift|Meta)(Left|Right)$/u.test(input.code);
+			if (input.type === "keyUp") {
+				if (consumed.get(input.code) === "press") event.preventDefault();
+				consumed.delete(input.code);
+				held.delete(input.code);
+				if (modifierKey) held.clear();
+				return;
+			}
+			if (!input.isAutoRepeat) consumed.delete(input.code);
+			if (modifierKey) {
+				held.clear();
+				return;
+			}
+			if (input.isAutoRepeat && consumed.has(input.code) && !match) {
+				event.preventDefault();
+				return;
+			}
+			if (input.isAutoRepeat && !held.has(input.code) && !match) return;
+			held.add(input.code);
+			const codes = [input.code, ...[...held].filter((value) => value !== input.code)];
+			codes.sort();
+			const pair = {
+				code: codes[0],
+				...codes[1] === void 0 ? {} : { secondCode: codes[1] },
+				modifiers
+			};
+			priority = keys.has(key);
+			if (codes.length === 2 && keys.has(bindingKey(pair))) {
+				binding = pair;
+				priority = true;
+			}
+			if (!priority) return;
+			event.preventDefault();
+			if (!input.isAutoRepeat) {
+				if (binding.secondCode !== void 0) {
+					consumed.set(binding.code, "repeat");
+					consumed.set(binding.secondCode, "repeat");
+				}
+				consumed.set(input.code, "press");
+			}
+			held.clear();
+			contents.send(DESKTOP_IPC.shortcutsInput, {
+				kind: "keyboard",
+				revision,
+				code: binding.code,
+				...binding.secondCode === void 0 ? {} : { secondCode: binding.secondCode },
+				repeat: input.isAutoRepeat,
+				control: input.control,
+				alt: input.alt,
+				shift: input.shift,
+				meta: input.meta
+			});
+		};
+		const navigation = (event) => {
+			if (event.isMainFrame && !event.isSameDocument) clear();
+		};
+		const disposeInput = () => {
+			contents.off("did-start-navigation", navigation);
+			contents.off("before-input-event", beforeInput);
+			contents.off("blur", resetInput);
+			resetInput();
+		};
+		contents.on("did-start-navigation", navigation);
+		contents.on("before-input-event", beforeInput);
+		contents.on("blur", resetInput);
+		contents.once("destroyed", disposeInput);
+		window.once("closed", clear);
+	};
+	return {
+		attach,
+		dispose() {
+			for (const channel of [
+				DESKTOP_IPC.shortcutsGet,
+				DESKTOP_IPC.shortcutsEdit,
+				DESKTOP_IPC.shortcutsRecording,
+				DESKTOP_IPC.shortcutsCloseWindow
+			]) ipcMain.removeHandler(channel);
+			persistence.dispose();
+		}
+	};
+}
+//#endregion
+//#region src/shell-env.ts
+function rcFileFor(shell) {
+	switch (basename(shell)) {
+		case "bash": return "~/.bashrc";
+		case "zsh": return "~/.zshrc";
+		default: return "";
+	}
+}
+function shellQuote(value) {
+	return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function shellWrappedSpawn(command, args, options) {
+	const shell = process.env.SHELL;
+	const rc = shell === void 0 || shell === "" ? "" : rcFileFor(shell);
+	if (rc !== "" && process.platform !== "win32" && shell !== void 0) {
+		const commandLine = `source ${rc} >/dev/null 2>&1; exec ${shellQuote(command)} ${args.map(shellQuote).join(" ")}`;
+		return spawn(shell, ["-c", commandLine], {
+			...options,
+			detached: true
+		});
+	}
+	return spawn(command, [...args], {
+		...options,
+		detached: process.platform !== "win32"
+	});
+}
+//#endregion
+//#region src/index.ts
+let focusPrimaryWindow = () => {};
+/** appconfig.json 的位置：打包形态只看 resources，dev 形态由 CLI 指到构建目录。 */
+function appConfigDir() {
+	const configured = process.env.DSH_DESKTOP_APPCONFIG_DIR;
+	return app.isPackaged || configured === void 0 || configured === "" ? process.resourcesPath : configured;
+}
+function startupFailure(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(error);
+	dialog.showErrorBox("dsh desktop startup failed", message);
+	app.exit(1);
+	throw error instanceof Error ? error : new Error(message);
+}
+const appConfig = await loadAppConfig(appConfigDir()).catch((error) => startupFailure(error));
+/** 自定义协议取自 app 名：与官方桌面应用（`dsh-app`）错开。 */
+const SCHEME = (() => {
+	try {
+		return desktopScheme(appConfig.name);
+	} catch (error) {
+		startupFailure(error);
+	}
+})();
+protocol.registerSchemesAsPrivileged([{
+	scheme: SCHEME,
+	privileges: {
+		standard: true,
+		secure: true,
+		supportFetchAPI: true,
+		corsEnabled: true,
+		stream: true,
+		codeCache: true
+	}
+}]);
+const WEB_FRONTEND_PACKAGE = "@deepseek-ai/dsh-web-frontend";
+const APPLICATION_URL = `${SCHEME}://app/`;
+/** Windows 自绘标题栏高度（DIP），与 preload 写入的 CSS 变量一致。 */
+const WINDOWS_TITLEBAR_HEIGHT = 40;
+async function pathExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function runtimeResources() {
+	const development = !app.isPackaged;
+	const node = (development ? process.env.DSH_DESKTOP_NODE_BINARY : void 0) ?? join(process.resourcesPath, "runtime", "node", process.platform === "win32" ? "node.exe" : "node");
+	const seed = (development ? process.env.DSH_DESKTOP_SEED_DIR : void 0) ?? join(process.resourcesPath, "seed");
+	const configured = process.env.DSH_DESKTOP_PRIMARY_RUNTIME_DIR;
+	return {
+		node,
+		seed,
+		primaryRuntime: configured !== void 0 && configured !== "" ? resolve(configured) : join(process.resourcesPath, "runtime", "primary-runtime"),
+		runtime: join(seed, SEED_RUNTIME_DIR_NAME),
+		pnpm: join(process.resourcesPath, "runtime", "pnpm", "bin", "pnpm.mjs"),
+		nodeBin: join(process.resourcesPath, "runtime", "bin")
+	};
+}
+async function installPlantedProfile(profileDir, resources) {
+	const settingsPath = join(profileDir, PROFILE_WORKSPACE_NAME);
+	const overrides = await runtimeOverrides(profileDir, resources.runtime);
+	await writeFile(settingsPath, workspaceWithOverrides(await readFile(settingsPath, "utf8"), overrides));
+	await installProfile({
+		node: resources.node,
+		pnpmEntry: resources.pnpm,
+		profileDir
+	});
+}
+function developmentProject() {
+	const configured = process.env.DSH_DESKTOP_DEV_PROJECT_DIR;
+	if (configured === void 0 || configured === "") return void 0;
+	if (app.isPackaged) throw new Error("dsh desktop: development project override is unavailable in packaged applications");
+	return resolve(configured);
+}
+/** 窗口形态：macOS 走 sidebar vibrancy + hiddenInset（交通灯落在侧边栏内），Windows 自绘 caption。 */
+function windowFrame() {
+	if (process.platform === "darwin") return {
+		titleBarStyle: "hiddenInset",
+		trafficLightPosition: {
+			x: 16,
+			y: 18
+		},
+		vibrancy: "sidebar",
+		visualEffectState: "active",
+		backgroundColor: "#00000000"
+	};
+	if (process.platform === "win32") return {
+		titleBarStyle: "hidden",
+		titleBarOverlay: {
+			height: WINDOWS_TITLEBAR_HEIGHT,
+			color: nativeTheme.shouldUseDarkColors ? "#1b1b1c" : "#f9fafb",
+			symbolColor: nativeTheme.shouldUseDarkColors ? "#f9fafb" : "#0f1115"
+		}
+	};
+	return { frame: false };
+}
+function createWindow(preload, config) {
+	const window = new BrowserWindow({
+		width: config.width,
+		height: config.height,
+		minWidth: config.minWidth,
+		minHeight: config.minHeight,
+		show: false,
+		...windowFrame(),
+		webPreferences: {
+			preload,
+			nodeIntegration: false,
+			contextIsolation: true,
+			sandbox: true,
+			webSecurity: true,
+			additionalArguments: [`${DESKTOP_SCHEME_ARGUMENT}=${SCHEME}`]
+		}
+	});
+	window.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
+	window.webContents.on("will-navigate", (event, url) => {
+		if (new URL(url).protocol !== `${SCHEME}:`) event.preventDefault();
+	});
+	return window;
+}
+function developmentHostInspectPort(enabled) {
+	const configured = process.env.DSH_DESKTOP_HOST_INSPECT_PORT;
+	if (!enabled || configured === void 0 || configured === "") return void 0;
+	const port = Number(configured);
+	if (!Number.isSafeInteger(port) || port < 1 || port > 65535) throw new Error("dsh desktop: DSH_DESKTOP_HOST_INSPECT_PORT must be an integer from 1 through 65535");
+	return port;
+}
+function developmentNodeArgs() {
+	const specifier = process.env.DSH_DESKTOP_TSX_IMPORT;
+	return specifier === void 0 || specifier === "" ? [] : [`--import=${specifier}`];
+}
+async function main() {
+	const development = developmentProject();
+	const resources = runtimeResources();
+	const hostInspectPort = developmentHostInspectPort(development !== void 0);
+	const activeProject = development ?? join(resolveDshHome(appConfig) ?? "", "profiles", "desktop");
+	const runtimeProject = development ?? resources.runtime;
+	const webDocumentRoot = join(runtimeProject, "node_modules", ...WEB_FRONTEND_PACKAGE.split("/"), "dist");
+	const dshHome = resolveDshHome(appConfig);
+	if (development === void 0) {
+		if (dshHome === void 0) throw new Error("dsh desktop: packaged applications require a concrete dshHome");
+		if (await ensureSeedProfile(resources.seed, dshHome)) await installPlantedProfile(activeProject, resources);
+	}
+	if (!await pathExists(join(webDocumentRoot, "index.html"))) throw new Error(`dsh desktop: the Web frontend is missing at ${webDocumentRoot}; the runtime closure must carry ${WEB_FRONTEND_PACKAGE}`);
+	let host;
+	let mainWindow;
+	let quitConfirmed = false;
+	let quitPrompting = false;
+	const appPreload = fileURLToPath(new URL("./preload-app.cjs", import.meta.url));
+	const confirmQuit = async (window) => {
+		if (quitPrompting) return;
+		quitPrompting = true;
+		try {
+			const options = {
+				type: "question",
+				buttons: ["Cancel", "Quit"],
+				defaultId: 0,
+				cancelId: 0,
+				noLink: true,
+				message: `Quit ${appConfig.name}?`,
+				detail: "The desktop backend and its running sessions will stop."
+			};
+			const parent = window ?? mainWindow;
+			const { response } = parent === void 0 || parent.isDestroyed() ? await dialog.showMessageBox(options) : await dialog.showMessageBox(parent, options);
+			if (response !== 1) return;
+			quitConfirmed = true;
+			app.quit();
+		} finally {
+			quitPrompting = false;
+		}
+	};
+	let hostFailureHandled = false;
+	const handleHostFailure = (error) => {
+		if (hostFailureHandled) return;
+		hostFailureHandled = true;
+		console.error(`[dsh-shell] backend stopped: ${error.message}`);
+		dialog.showErrorBox("dsh desktop backend stopped", error.message);
+		quitConfirmed = true;
+		app.exit(1);
+	};
+	const startHost = async (projectDir = activeProject) => {
+		const next = new DesktopHostProcess(resources.node, runtimeProject, projectDir, hostInspectPort, {
+			nodeArgs: development === void 0 ? [] : developmentNodeArgs(),
+			extraEnv: {
+				...dshHome === void 0 ? {} : { DSH_HOME: dshHome },
+				...development === void 0 ? {} : { ELECTRON_RUN_AS_NODE: "1" }
+			},
+			primaryRuntime: resources.primaryRuntime,
+			processTitle: `${appConfig.name}-server`,
+			...development === void 0 ? { packageManager: {
+				pnpm: resources.pnpm,
+				nodeBin: resources.nodeBin
+			} } : {},
+			spawn: shellWrappedSpawn,
+			onFailure: handleHostFailure
+		});
+		await next.start();
+		return next;
+	};
+	protocol.handle(SCHEME, async (request) => {
+		const url = new URL(request.url);
+		if (url.hostname !== "app") return new Response(null, { status: 404 });
+		const active = host;
+		if (active === void 0) return new Response("backend unavailable", { status: 503 });
+		if (!app.isPackaged) console.error(`[dsh-shell] recv ${request.method} ${url.pathname}`);
+		const response = await active.fetch(request);
+		if (!app.isPackaged) console.error(`[dsh-shell] ${request.method} ${url.pathname} → ${String(response.status)}`);
+		return response;
+	});
+	installDesktopDirectoryPicker(() => mainWindow, SCHEME);
+	let nextStreamId = 1;
+	const streamEncoder = new TextEncoder();
+	const activeStreams = /* @__PURE__ */ new Map();
+	/** 结束宿主请求体：已取消/已结束的流上 close 会抛，这里只当收尾。 */
+	const closeStreamUplink = (stream) => {
+		const uplink = stream.uplink;
+		if (uplink === void 0) return;
+		stream.uplink = void 0;
+		try {
+			uplink.close();
+		} catch (error) {
+			if (!app.isPackaged) console.error("[dsh-shell] stream uplink close failed", error);
+		}
+	};
+	ipcMain.handle(DESKTOP_IPC.streamOpen, async (event, endpoint, payload) => {
+		assertDesktopSender(event, SCHEME, ["app"]);
+		if (typeof endpoint !== "string") throw new Error("dsh desktop: stream endpoint must be text");
+		const active = host;
+		if (active === void 0) throw new Error("dsh desktop: Host is unavailable");
+		if (!app.isPackaged) console.error(`[dsh-shell] stream open ${endpoint}`);
+		const id = nextStreamId++;
+		const abort = new AbortController();
+		const stream = {
+			abort,
+			uplink: void 0
+		};
+		const body = new ReadableStream({
+			start: (controller) => {
+				stream.uplink = controller;
+				controller.enqueue(streamEncoder.encode(encodeDesktopStreamOpen(endpoint, payload)));
+			},
+			cancel: () => {
+				stream.uplink = void 0;
+			}
+		});
+		activeStreams.set(id, stream);
+		const request = new Request(`http://127.0.0.1${DESKTOP_STREAM_PATH}`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body,
+			signal: abort.signal,
+			duplex: "half"
+		});
+		(async () => {
+			try {
+				const response = await active.fetch(request);
+				if (!app.isPackaged) console.error(`[dsh-shell] stream ${endpoint} → ${String(response.status)}`);
+				event.sender.send(DESKTOP_IPC.streamChunk, {
+					id,
+					status: response.status
+				});
+				if (response.body === null) {
+					event.sender.send(DESKTOP_IPC.streamEnd, { id });
+					return;
+				}
+				const decoder = new TextDecoder();
+				for await (const chunk of response.body) event.sender.send(DESKTOP_IPC.streamChunk, {
+					id,
+					data: decoder.decode(chunk)
+				});
+				event.sender.send(DESKTOP_IPC.streamEnd, { id });
+			} catch (error) {
+				event.sender.send(DESKTOP_IPC.streamError, {
+					id,
+					message: error instanceof Error ? error.message : String(error)
+				});
+			} finally {
+				closeStreamUplink(stream);
+				activeStreams.delete(id);
+			}
+		})();
+		return id;
+	});
+	ipcMain.on(DESKTOP_IPC.streamCancel, (event, id) => {
+		if (mainWindow === void 0 || event.sender !== mainWindow.webContents) return;
+		if (typeof id !== "number") return;
+		activeStreams.get(id)?.abort.abort();
+	});
+	ipcMain.on(DESKTOP_IPC.streamUplink, (event, id, item) => {
+		if (mainWindow === void 0 || event.sender !== mainWindow.webContents) return;
+		if (typeof id !== "number") return;
+		const uplink = activeStreams.get(id)?.uplink;
+		if (uplink === void 0) return;
+		try {
+			uplink.enqueue(streamEncoder.encode(encodeDesktopStreamItem(item)));
+		} catch (error) {
+			if (!app.isPackaged) console.error("[dsh-shell] stream uplink rejected", error);
+		}
+	});
+	ipcMain.on(DESKTOP_IPC.streamUplinkEnd, (event, id) => {
+		if (mainWindow === void 0 || event.sender !== mainWindow.webContents) return;
+		if (typeof id !== "number") return;
+		const stream = activeStreams.get(id);
+		if (stream === void 0) return;
+		closeStreamUplink(stream);
+	});
+	ipcMain.on(DESKTOP_IPC.nativeThemeSet, (event, source) => {
+		if (mainWindow === void 0 || event.sender !== mainWindow.webContents) return;
+		if (source === "light" || source === "dark" || source === "system") nativeTheme.themeSource = source;
+	});
+	const shortcuts = installDesktopShortcuts(() => mainWindow, app.getPath("userData"), process.platform === "darwin" ? "macos" : process.platform === "win32" ? "windows" : "linux", SCHEME);
+	app.on("will-quit", () => {
+		shortcuts.dispose();
+	});
+	const createMainWindow = () => {
+		const window = createWindow(appPreload, appConfig.window);
+		mainWindow = window;
+		shortcuts.attach(window);
+		window.once("ready-to-show", () => {
+			if (!window.isDestroyed()) window.show();
+		});
+		window.on("close", (event) => {
+			if (!app.isPackaged || quitConfirmed) return;
+			event.preventDefault();
+			confirmQuit(window);
+		});
+		window.on("closed", () => {
+			if (mainWindow === window) mainWindow = void 0;
+		});
+		return window;
+	};
+	focusPrimaryWindow = () => {
+		const window = mainWindow;
+		if (window === void 0 || window.isDestroyed()) {
+			createMainWindow().loadURL(APPLICATION_URL);
+			return;
+		}
+		if (window.isMinimized()) window.restore();
+		window.show();
+		window.focus();
+	};
+	host = await startHost();
+	mainWindow = createMainWindow();
+	await mainWindow.loadURL(APPLICATION_URL);
+	if (development !== void 0 && process.env.DSH_DESKTOP_OPEN_DEVTOOLS !== "0") mainWindow.webContents.openDevTools({ mode: "detach" });
+	app.on("activate", () => {
+		if (BrowserWindow.getAllWindows().length === 0) focusPrimaryWindow();
+	});
+	app.on("window-all-closed", () => {
+		app.quit();
+	});
+	app.on("before-quit", (event) => {
+		if (app.isPackaged && !quitConfirmed) {
+			event.preventDefault();
+			confirmQuit();
+			return;
+		}
+		if (host === void 0) return;
+		event.preventDefault();
+		const active = host;
+		host = void 0;
+		active.stop().catch((error) => {
+			console.error(error);
+		}).finally(() => {
+			app.quit();
+		});
+	});
+}
+if (app.isPackaged) try {
+	const profile = join(app.getPath("appData"), appConfig.id);
+	await mkdir(profile, { recursive: true });
+	app.setPath("userData", profile);
+} catch (error) {
+	console.error(error);
+}
+if ((() => {
+	if (!app.requestSingleInstanceLock()) {
+		app.quit();
+		return false;
+	}
+	app.on("second-instance", () => {
+		focusPrimaryWindow();
+	});
+	return true;
+})()) app.whenReady().then(main).catch(async (error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(error);
+	const diagnosticFile = process.env.DSH_DESKTOP_DIAGNOSTIC_FILE;
+	if (diagnosticFile !== void 0) await import("node:fs/promises").then((fs) => fs.writeFile(diagnosticFile, `${error instanceof Error ? error.stack ?? message : message}\n`)).catch(() => void 0);
+	dialog.showErrorBox("dsh desktop startup failed", message);
+	app.exit(1);
+});
+//#endregion
+export {};