@achasoft/dsh-advanced-sidebar 0.1.0

package/lib/host.js

@@ -0,0 +1,3156 @@
+import z from "@deepseek-ai/schemastery";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { rm } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { randomUUID } from "node:crypto";
+import { connect } from "node:net";
+import { JobId } from "@deepseek-ai/dsh-jobs";
+
+//#region tsbuild/host/deletion.js
+/**
+* Commits Delete for the sidebar menu. Stateless apart from the context and settings it reads.
+*/
+var SessionDeleter = class {
+	ctx;
+	source;
+	/**
+	* @param ctx - Host context carrying the workspace registry and session persistence.
+	* @param source - reads the current settings section; called per request.
+	*/
+	constructor(ctx, source) {
+		this.ctx = ctx;
+		this.source = source;
+	}
+	/**
+	* Report whether the durable log can be removed at all.
+	* @returns the capability, with a reason when purging is impossible.
+	*/
+	describe() {
+		const persistence = this.ctx.get("sessionPersistence");
+		if (persistence === void 0) return {
+			canPurge: false,
+			reason: "no session-persistence backend is mounted; nothing is written to remove"
+		};
+		if (!persistence.supportsRawArtifacts) return {
+			canPurge: false,
+			reason: "this session-persistence backend keeps no per-session artifact, so Delete can only archive"
+		};
+		return { canPurge: true };
+	}
+	/**
+	* Hide one session, and remove its durable artifact when the mode and the Host allow it.
+	* @param request - the session to delete.
+	* @param signal - cancellation for the persistence listing.
+	* @returns what was actually done, or a classified failure.
+	*/
+	async delete(request, signal) {
+		const settings = this.source();
+		if (!settings.showDelete) return {
+			ok: false,
+			code: "disabled",
+			message: "Delete is switched off in the advanced-sidebar settings"
+		};
+		const registry = this.ctx.get("workspaceRegistry");
+		if (registry === void 0) return {
+			ok: false,
+			code: "no-registry",
+			message: "no workspace registry is mounted"
+		};
+		const sessionId = request.sessionId;
+		const artifact = settings.deleteMode === "purge" ? await this.locateArtifact(sessionId, signal) : void 0;
+		try {
+			await registry.archiveSession(sessionId);
+		} catch (error) {
+			return {
+				ok: false,
+				code: "archive-failed",
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+		if (settings.deleteMode === "archive") return {
+			ok: true,
+			archived: true,
+			purged: false
+		};
+		if (artifact === void 0 || "reason" in artifact) return {
+			ok: true,
+			archived: true,
+			purged: false,
+			purgeSkippedReason: artifact?.reason ?? this.describe().reason ?? "the session has no materialized artifact to remove"
+		};
+		try {
+			await rm(artifact.path, { force: true });
+		} catch (error) {
+			return {
+				ok: false,
+				code: "remove-failed",
+				message: `archived, but ${artifact.path} could not be removed: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+		return {
+			ok: true,
+			archived: true,
+			purged: true,
+			artifactPath: artifact.path
+		};
+	}
+	/**
+	* Find the backend artifact for one session, or say why it will not be removed.
+	* @param sessionId - the session to look up.
+	* @param signal - cancellation for the persistence listing.
+	* @returns the artifact path, or the reason purging is skipped.
+	*/
+	async locateArtifact(sessionId, signal) {
+		const capability = this.describe();
+		if (!capability.canPurge) return { reason: capability.reason ?? "purging is unavailable on this Host" };
+		if (this.ctx.agents.get(sessionId) !== void 0) return { reason: "the session is live, so its log was kept; delete it again after it stops" };
+		const persistence = this.ctx.sessionPersistence;
+		let headers;
+		try {
+			headers = await persistence.list(signal);
+		} catch (error) {
+			return { reason: `the durable session list could not be read: ${error instanceof Error ? error.message : String(error)}` };
+		}
+		const header = headers.find((entry) => entry.id === sessionId);
+		if (header === void 0) return { reason: "the session has no durable log on this Host" };
+		const location = persistence.locate(header);
+		if (location === void 0) return { reason: "this backend keeps no per-session artifact for that session" };
+		return { path: location.path };
+	}
+};
+
+//#endregion
+//#region tsbuild/host/paths.js
+/**
+* Path resolution and containment for every endpoint that takes a path from the browser.
+*
+* A browser-supplied path is untrusted input at a process boundary, so each one is resolved through
+* `ctx.fs` and proved to sit inside the workspace it claims to belong to before any command, read,
+* or launch sees it. `..` and symlinks are handled by the filesystem's own canonicalization rather
+* than by string arithmetic here.
+* @module @achasoft/dsh-advanced-sidebar/host/paths
+*/
+/**
+* Resolve one absolute directory as a workspace root.
+* @param ctx - Host context carrying the optional filesystem capability.
+* @param path - absolute directory path supplied by the browser.
+* @param signal - cancellation for the backend round-trip.
+* @returns the canonical directory, or the reason it was refused.
+*/
+async function resolveWorkspace(ctx, path, signal) {
+	const fs = ctx.get("fs");
+	if (fs === void 0) return {
+		ok: false,
+		rejection: {
+			code: "no-filesystem",
+			message: "no filesystem capability is mounted: this deployment composes no @deepseek-ai/dsh-fs provider"
+		}
+	};
+	let target;
+	try {
+		target = await fs.resolve(path, signal === void 0 ? {} : { signal });
+	} catch (error) {
+		return {
+			ok: false,
+			rejection: {
+				code: "path-denied",
+				message: describe(error, path)
+			}
+		};
+	}
+	const info = await fs.stat(target, signal);
+	if (info === void 0 || info.type !== "directory") return {
+		ok: false,
+		rejection: {
+			code: "path-denied",
+			message: `${path} is not a directory`
+		}
+	};
+	return {
+		ok: true,
+		value: {
+			target,
+			processPath: fs.processPath(target)
+		}
+	};
+}
+/**
+* Resolve one path and prove it sits inside an already-resolved workspace.
+* @param ctx - Host context carrying the optional filesystem capability.
+* @param workspace - the canonical workspace directory the path must stay within.
+* @param path - absolute path supplied by the browser.
+* @param signal - cancellation for the backend round-trip.
+* @returns the canonical path, or the reason it was refused.
+*/
+async function resolveInside(ctx, workspace, path, signal) {
+	const fs = ctx.get("fs");
+	/* v8 ignore next 4 -- the caller resolved `workspace` through the same service moments earlier. */
+	if (fs === void 0) return {
+		ok: false,
+		rejection: {
+			code: "no-filesystem",
+			message: "filesystem capability withdrawn mid-request"
+		}
+	};
+	let target;
+	try {
+		target = await fs.resolve(path, signal === void 0 ? {} : { signal });
+	} catch (error) {
+		return {
+			ok: false,
+			rejection: {
+				code: "path-denied",
+				message: describe(error, path)
+			}
+		};
+	}
+	if (!fs.contains(workspace.target, target)) return {
+		ok: false,
+		rejection: {
+			code: "path-denied",
+			message: `${path} is outside ${workspace.target.displayPath}`
+		}
+	};
+	return {
+		ok: true,
+		value: {
+			target,
+			processPath: fs.processPath(target)
+		}
+	};
+}
+/**
+* Phrase one resolution failure without leaking a stack.
+* @param error - whatever the backend threw.
+* @param path - the path that was being resolved.
+* @returns a single-line operator diagnostic.
+*/
+function describe(error, path) {
+	return `cannot resolve ${path}: ${error instanceof Error ? error.message : String(error)}`;
+}
+
+//#endregion
+//#region tsbuild/host/files.js
+/**
+* How much of a file's head decides whether it is text. A NUL byte anywhere in this window is the
+* same test `git` uses, and it is cheap enough to apply to every preview.
+*/
+const BINARY_PROBE_BYTES = 8e3;
+/** Reads file previews for the Files panel. */
+var FileReader = class {
+	ctx;
+	source;
+	/**
+	* @param ctx - Host context carrying the optional filesystem capability.
+	* @param source - reads the current settings section; called per request.
+	*/
+	constructor(ctx, source) {
+		this.ctx = ctx;
+		this.source = source;
+	}
+	/**
+	* Report whether a preview can be read on this Host.
+	* @returns availability, with the reason when there is no filesystem.
+	*/
+	describe() {
+		if (this.ctx.get("fs") === void 0) return {
+			available: false,
+			reason: "no filesystem capability is mounted: this deployment composes no @deepseek-ai/dsh-fs provider"
+		};
+		return { available: true };
+	}
+	/**
+	* List one directory level inside a workspace.
+	*
+	* The Web Client's own `listDirectory` cannot serve this panel: the Host's browse capability
+	* returns directories only, because its one caller is a workspace picker. A file browser needs
+	* the files.
+	* @param request - the directory and the workspace it must stay inside.
+	* @param signal - cancellation for the listing.
+	* @returns the level, or a classified failure.
+	*/
+	async list(request, signal) {
+		const fs = this.ctx.get("fs");
+		if (fs === void 0) return {
+			ok: false,
+			code: "no-filesystem",
+			message: "no filesystem capability is mounted"
+		};
+		const workspace = await resolveWorkspace(this.ctx, request.workspacePath, signal);
+		if (!workspace.ok) return {
+			ok: false,
+			code: workspace.rejection.code === "no-filesystem" ? "no-filesystem" : "path-denied",
+			message: workspace.rejection.message
+		};
+		const directory = await resolveInside(this.ctx, workspace.value, request.path, signal);
+		if (!directory.ok) return {
+			ok: false,
+			code: directory.rejection.code === "no-filesystem" ? "no-filesystem" : "path-denied",
+			message: directory.rejection.message
+		};
+		const info = await fs.stat(directory.value.target, signal);
+		if (info === void 0 || info.type !== "directory") return {
+			ok: false,
+			code: "not-a-file",
+			message: `${request.path} is not a directory`
+		};
+		let children;
+		try {
+			children = await fs.listDir(directory.value.target, signal);
+		} catch (error) {
+			return {
+				ok: false,
+				code: "read-failed",
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+		const settings = this.source();
+		const sorted = children.filter((child) => settings.filesShowHidden || !child.name.startsWith(".")).map((child) => ({
+			name: child.name,
+			path: fs.processPath(child.target),
+			kind: child.type,
+			...child.size === void 0 ? {} : { size: child.size }
+		})).sort((left, right) => {
+			const leftDirectory = left.kind === "directory";
+			if (leftDirectory !== (right.kind === "directory")) return leftDirectory ? -1 : 1;
+			return left.name.localeCompare(right.name);
+		});
+		const truncated = sorted.length > settings.filesMaxEntries;
+		const parent = fs.contains(directory.value.target, workspace.value.target) ? void 0 : dirname(directory.value.processPath);
+		return {
+			ok: true,
+			path: directory.value.processPath,
+			...parent === void 0 ? {} : { parent },
+			entries: truncated ? sorted.slice(0, settings.filesMaxEntries) : sorted,
+			truncated
+		};
+	}
+	/**
+	* Read one file, bounded by `filesMaxPreviewBytes`.
+	* @param request - the file and the workspace it must stay inside.
+	* @param signal - cancellation for the read.
+	* @returns the preview, or a classified failure.
+	*/
+	async read(request, signal) {
+		const fs = this.ctx.get("fs");
+		if (fs === void 0) return {
+			ok: false,
+			code: "no-filesystem",
+			message: "no filesystem capability is mounted"
+		};
+		const workspace = await resolveWorkspace(this.ctx, request.workspacePath, signal);
+		if (!workspace.ok) return {
+			ok: false,
+			code: workspace.rejection.code === "no-filesystem" ? "no-filesystem" : "path-denied",
+			message: workspace.rejection.message
+		};
+		const file = await resolveInside(this.ctx, workspace.value, request.path, signal);
+		if (!file.ok) return {
+			ok: false,
+			code: file.rejection.code === "no-filesystem" ? "no-filesystem" : "path-denied",
+			message: file.rejection.message
+		};
+		const info = await fs.stat(file.value.target, signal);
+		if (info === void 0 || info.type !== "file") return {
+			ok: false,
+			code: "not-a-file",
+			message: `${request.path} is not a regular file`
+		};
+		const max = this.source().filesMaxPreviewBytes;
+		let bytes;
+		try {
+			bytes = await fs.readBytes(file.value.target, signal, max);
+		} catch (error) {
+			return {
+				ok: false,
+				code: "read-failed",
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+		const size = info.size ?? bytes.byteLength;
+		if (isBinary(bytes)) return {
+			ok: true,
+			path: request.path,
+			text: "",
+			binary: true,
+			truncated: false,
+			bytes: size
+		};
+		return {
+			ok: true,
+			path: request.path,
+			text: new TextDecoder("utf-8", { fatal: false }).decode(bytes),
+			binary: false,
+			truncated: size > bytes.byteLength,
+			bytes: size
+		};
+	}
+};
+/**
+* Whether a file's leading bytes look like something other than text.
+* @param bytes - the read window.
+* @returns true when a NUL appears in the probe window.
+*/
+function isBinary(bytes) {
+	const limit = Math.min(bytes.byteLength, BINARY_PROBE_BYTES);
+	for (let index = 0; index < limit; index += 1) if (bytes[index] === 0) return true;
+	return false;
+}
+
+//#endregion
+//#region tsbuild/host/porcelain.js
+/**
+* Pure parser for `git status --porcelain=v2 --branch -z`.
+*
+* Kept apart from the command runner so the format — which is the only part of the git integration
+* with edge cases worth testing (renames carry two paths, `-z` terminates every line including the
+* headers, and a path may contain any byte but NUL) — is exercised without a subprocess.
+* @module @achasoft/dsh-advanced-sidebar/host/porcelain
+*/
+/**
+* `--porcelain=v2` status letters. `.` is git's spelling of "nothing to report in this index",
+* which is why {@link GitFileState} carries `unmodified` rather than leaving the field absent.
+*/
+const STATE_BY_LETTER = {
+	".": "unmodified",
+	"M": "modified",
+	"T": "typechange",
+	"A": "added",
+	"D": "deleted",
+	"R": "renamed",
+	"C": "copied",
+	"U": "conflicted"
+};
+/**
+* Map one status letter.
+* @param letter - a single `XY` character.
+* @returns the state, or `modified` for a letter a newer git introduced after this parser.
+*/
+function state(letter) {
+	if (letter === void 0) return "unmodified";
+	return STATE_BY_LETTER[letter] ?? "modified";
+}
+/**
+* Split one `1`/`2`/`u` record into its space-separated fields plus the trailing path.
+*
+* The path is the remainder after a fixed field count, never a split result: a path may contain
+* spaces, and splitting it would silently truncate every such file to its first word.
+* @param record - the record text without its NUL terminator.
+* @param fields - how many space-separated fields precede the path (including the leading type).
+* @returns the fields and the untouched path remainder, or undefined for a malformed record.
+*/
+function splitRecord(record, fields) {
+	const head = [];
+	let at = 0;
+	for (let index = 0; index < fields; index += 1) {
+		const space = record.indexOf(" ", at);
+		if (space < 0) return void 0;
+		head.push(record.slice(at, space));
+		at = space + 1;
+	}
+	const path = record.slice(at);
+	return path === "" ? void 0 : {
+		head,
+		path
+	};
+}
+/**
+* Parse the `# branch.ab +A -B` header.
+* @param value - the header's value text.
+* @returns ahead and behind counts; zeros when the header is malformed.
+*/
+function parseAheadBehind(value) {
+	const match = /^\+(\d+)\s+-(\d+)$/u.exec(value.trim());
+	if (match === null) return {
+		ahead: 0,
+		behind: 0
+	};
+	return {
+		ahead: Number(match[1]),
+		behind: Number(match[2])
+	};
+}
+/**
+* Parse one complete `--porcelain=v2 --branch -z` payload.
+*
+* Unknown record types are skipped rather than rejected: git adds record kinds over time, and a
+* reading that lists every change it understood is more useful than one that refuses the whole
+* repository because a future git emitted a line this parser has not met.
+* @param payload - git's stdout, verbatim.
+* @returns the branch facts and every parsed change.
+*/
+function parsePorcelainV2(payload) {
+	const branch = {
+		ahead: 0,
+		behind: 0,
+		detached: false
+	};
+	const changes = [];
+	const chunks = payload.split("\0");
+	for (let index = 0; index < chunks.length; index += 1) {
+		const chunk = chunks[index];
+		if (chunk === void 0 || chunk === "") continue;
+		if (chunk.startsWith("# ")) {
+			const space = chunk.indexOf(" ", 2);
+			const key = space < 0 ? chunk.slice(2) : chunk.slice(2, space);
+			const value = space < 0 ? "" : chunk.slice(space + 1);
+			if (key === "branch.head") if (value === "(detached)") branch.detached = true;
+			else branch.branch = value;
+			else if (key === "branch.upstream") branch.upstream = value;
+			else if (key === "branch.ab") {
+				const { ahead, behind } = parseAheadBehind(value);
+				branch.ahead = ahead;
+				branch.behind = behind;
+			}
+			continue;
+		}
+		if (chunk.startsWith("? ")) {
+			const path = chunk.slice(2);
+			if (path !== "") changes.push({
+				path,
+				index: "unmodified",
+				worktree: "untracked",
+				untracked: true,
+				conflicted: false
+			});
+			continue;
+		}
+		if (chunk.startsWith("! ")) continue;
+		if (chunk.startsWith("1 ")) {
+			const parsed = splitRecord(chunk, 8);
+			if (parsed === void 0) continue;
+			const xy = parsed.head[1] ?? "..";
+			changes.push({
+				path: parsed.path,
+				index: state(xy[0]),
+				worktree: state(xy[1]),
+				untracked: false,
+				conflicted: false
+			});
+			continue;
+		}
+		if (chunk.startsWith("2 ")) {
+			const parsed = splitRecord(chunk, 9);
+			const original = chunks[index + 1];
+			index += 1;
+			if (parsed === void 0) continue;
+			const xy = parsed.head[1] ?? "..";
+			changes.push({
+				path: parsed.path,
+				...original === void 0 || original === "" ? {} : { oldPath: original },
+				index: state(xy[0]),
+				worktree: state(xy[1]),
+				untracked: false,
+				conflicted: false
+			});
+			continue;
+		}
+		if (chunk.startsWith("u ")) {
+			const parsed = splitRecord(chunk, 10);
+			if (parsed === void 0) continue;
+			changes.push({
+				path: parsed.path,
+				index: "conflicted",
+				worktree: "conflicted",
+				untracked: false,
+				conflicted: true
+			});
+		}
+	}
+	return {
+		branch,
+		changes
+	};
+}
+/**
+* Whether a change belongs in the staged group — its index state differs from HEAD.
+* @param change - one parsed change.
+* @returns true when a commit right now would record something for this path.
+*/
+function isStaged(change) {
+	return !change.untracked && !change.conflicted && change.index !== "unmodified";
+}
+/**
+* Whether a change belongs in the unstaged group — its working tree differs from the index.
+* @param change - one parsed change.
+* @returns true when the path has edits no commit would record yet.
+*/
+function isUnstaged(change) {
+	return !change.untracked && !change.conflicted && change.worktree !== "unmodified";
+}
+
+//#endregion
+//#region tsbuild/host/run.js
+/**
+* One-shot command execution over `ctx.subprocess`, shared by the git reader and the Open in
+* launcher.
+*
+* The subprocess seam applies no defaults, so every disposition, bound, and grace period is stated
+* here from this plugin's own settings — which is also what keeps the two callers' behavior
+* configurable from cordis.yml rather than from constants buried in a runner.
+* @module @achasoft/dsh-advanced-sidebar/host/run
+*/
+/** No filesystem/subprocess capability, or a spawn that never produced a process. */
+var CommandUnavailableError = class extends Error {
+	/**
+	* @param message - operator diagnostic naming what was missing.
+	*/
+	constructor(message) {
+		super(message);
+		this.name = "CommandUnavailableError";
+	}
+};
+/**
+* Read one collect-mode stream in full.
+* @param reader - the stream's offset reader, present by the spawn's own disposition.
+* @returns the retained text and whether the head was dropped to fit the cap.
+*/
+function drain(reader) {
+	/* v8 ignore next -- both streams are spawned in collect mode, so both readers exist. */
+	if (reader === void 0) return {
+		text: "",
+		lossy: false
+	};
+	const read = reader.readFrom(0);
+	return {
+		text: read.text,
+		lossy: read.lossy
+	};
+}
+/**
+* Resolve one executable, returning undefined rather than throwing when it is absent.
+* @param ctx - Host context carrying the optional subprocess capability.
+* @param command - executable name or absolute path.
+* @param signal - cancellation for the lookup.
+* @returns the canonical executable path, or undefined when it does not resolve.
+* @throws {CommandUnavailableError} when no subprocess capability is mounted.
+*/
+async function resolveCommand(ctx, command, signal) {
+	const subprocess = ctx.get("subprocess");
+	if (subprocess === void 0) throw new CommandUnavailableError("no subprocess capability is mounted: this deployment composes no @deepseek-ai/dsh-subprocess provider");
+	try {
+		return await subprocess.resolveExecutable(command, void 0, signal);
+	} catch {
+		return;
+	}
+}
+/**
+* Run one command to completion under a timeout.
+* @param ctx - Host context carrying the optional subprocess capability.
+* @param spec - the fully specified invocation.
+* @param signal - the caller's cancellation, distinguished from the timeout in the outcome.
+* @returns exit facts and collected output.
+* @throws {CommandUnavailableError} when no subprocess capability is mounted.
+*/
+async function runCommand(ctx, spec, signal) {
+	const subprocess = ctx.get("subprocess");
+	if (subprocess === void 0) throw new CommandUnavailableError("no subprocess capability is mounted: this deployment composes no @deepseek-ai/dsh-subprocess provider");
+	const timeout = AbortSignal.timeout(spec.timeoutMs);
+	const combined = signal === void 0 ? timeout : AbortSignal.any([signal, timeout]);
+	const handle = subprocess.spawn({
+		argv: spec.argv,
+		cwd: spec.cwd,
+		stdio: {
+			stdin: "ignore",
+			stdout: { maxBytes: spec.maxBytes },
+			stderr: { maxBytes: spec.maxBytes }
+		},
+		graceMs: spec.graceMs,
+		signal: combined,
+		...spec.env === void 0 ? {} : { env: spec.env }
+	});
+	const outcome = await handle.done;
+	const stdout = drain(handle.collected.stdout);
+	return {
+		exitCode: outcome.exitCode,
+		signal: outcome.signal,
+		stdout: stdout.text,
+		stderr: drain(handle.collected.stderr).text,
+		timedOut: timeout.aborted,
+		aborted: signal?.aborted === true && !timeout.aborted,
+		stdoutLossy: stdout.lossy
+	};
+}
+
+//#endregion
+//#region tsbuild/host/git.js
+/**
+* `git`'s own separator between the two paths of a rename record and between status lines.
+* Requested explicitly (`-z`) so a path containing a newline or a quote cannot be misread — git's
+* default output would C-quote such a path and this parser would then compare a quoted spelling
+* against the unquoted one a later diff request repeats.
+*/
+const NUL_ARGS = ["-z"];
+/** Exit code of the synthetic outcome produced when the `git` binary does not resolve. */
+const MISSING_BINARY_EXIT = 127;
+/** The remote a branch with no upstream is published to when nothing else names one. */
+const DEFAULT_REMOTE = "origin";
+/**
+* What the model is told a commit message is, when the settings section supplies no prompt of its
+* own.
+*
+* It states the format because a model asked for "a commit message" writes a paragraph as readily
+* as a subject line, and the panel puts the answer straight into the box a person then edits.
+*/
+const DEFAULT_COMMIT_PROMPT = [
+	"Write a git commit message for the supplied diff.",
+	"Answer with the message alone: no preamble, no explanation, no code fences, no quotes.",
+	"First line: imperative mood, under 72 characters, no trailing period.",
+	"Then, only if the change needs it, a blank line and a short body explaining WHY rather than restating the diff. Wrap the body at 72 columns.",
+	"Describe what the diff actually does. Do not invent a motive it does not show."
+].join("\n");
+/** Compose one classified failure. */
+function fail$4(code, message) {
+	return {
+		ok: false,
+		code,
+		message
+	};
+}
+/** First non-empty line of git's stderr, which is the part worth showing. */
+function stderrLine(outcome) {
+	return outcome.stderr.split("\n").map((part) => part.trim()).find((part) => part !== "") ?? `git exited with code ${String(outcome.exitCode)}`;
+}
+/**
+* Turn a non-zero exit into the right classified failure.
+* @param outcome - the finished command.
+* @returns the failure a caller should return.
+*/
+function classify(outcome) {
+	if (outcome.timedOut) return fail$4("timeout", "git did not finish within gitTimeoutMs");
+	if (outcome.aborted) return fail$4("cancelled", "the request was abandoned before git finished");
+	if (outcome.exitCode === MISSING_BINARY_EXIT) return fail$4("no-git", "git is not installed, or not on this Host process PATH");
+	const message = stderrLine(outcome);
+	if (/not a git repository/iu.test(message)) return fail$4("not-a-repository", message);
+	return fail$4("git-failed", message);
+}
+/**
+* Take a model's answer down to the message itself.
+*
+* A model asked for plain text still fences it often enough that the panel would otherwise put
+* ```` ``` ```` into a commit; the wrapper is removed only when it wraps the WHOLE answer, so a
+* message that legitimately quotes a fenced block keeps it.
+* @param text - what the model streamed.
+* @returns the message, trimmed.
+*/
+function stripFence(text) {
+	const trimmed = text.trim();
+	return (/^```[^\n]*\n([\s\S]*)\n```$/u.exec(trimmed)?.[1] ?? trimmed).trim();
+}
+/**
+* Reads one workspace's git state. One instance serves every request; the resolved `git` path is
+* cached across calls and dropped whenever a lookup fails, so installing git later needs no restart.
+*/
+var GitReader = class {
+	ctx;
+	source;
+	executable;
+	version;
+	/**
+	* @param ctx - Host context carrying the subprocess and filesystem capabilities.
+	* @param source - reads the current settings section; called per request so a committed change
+	* reaches the next reading with no registration to rebuild.
+	*/
+	constructor(ctx, source) {
+		this.ctx = ctx;
+		this.source = source;
+	}
+	/**
+	* Report whether git can answer on this Host.
+	* @param signal - cancellation for the lookup.
+	* @returns availability plus the version string when one was read.
+	*/
+	async describe(signal) {
+		let executable;
+		try {
+			executable = await this.locate(signal);
+		} catch (error) {
+			/* v8 ignore next -- only a missing subprocess capability reaches here. */
+			return {
+				available: false,
+				reason: error instanceof Error ? error.message : String(error)
+			};
+		}
+		if (executable === void 0) return {
+			available: false,
+			reason: "git is not installed, or not on this Host process PATH"
+		};
+		return {
+			available: true,
+			...this.version === void 0 ? {} : { detail: this.version }
+		};
+	}
+	/**
+	* Read one workspace's changed paths.
+	* @param request - the workspace directory to read.
+	* @param signal - cancellation for the reading.
+	* @returns the reading, or a classified failure.
+	*/
+	async status(request, signal) {
+		const prepared = await this.prepare(request.workspacePath, signal);
+		if ("failure" in prepared) return prepared.failure;
+		const { repository, workspace } = prepared;
+		const outcome = await this.git(workspace.value.processPath, [
+			"status",
+			"--porcelain=v2",
+			"--branch",
+			"--untracked-files=all",
+			...NUL_ARGS
+		], signal);
+		if (outcome.exitCode !== 0) return classify(outcome);
+		const parsed = parsePorcelainV2(outcome.stdout);
+		const limit = this.source().gitMaxFiles;
+		const truncated = outcome.stdoutLossy || parsed.changes.length > limit;
+		const changes = truncated ? parsed.changes.slice(0, limit) : parsed.changes;
+		const conflicted = changes.filter((change) => change.conflicted);
+		return {
+			ok: true,
+			write: await this.writeCapability(repository.root, signal),
+			repositoryRoot: repository.root,
+			prefix: repository.prefix,
+			...parsed.branch.branch === void 0 ? {} : { branch: parsed.branch.branch },
+			...parsed.branch.upstream === void 0 ? {} : { upstream: parsed.branch.upstream },
+			ahead: parsed.branch.ahead,
+			behind: parsed.branch.behind,
+			detached: parsed.branch.detached,
+			staged: changes.filter(isStaged),
+			unstaged: changes.filter(isUnstaged),
+			untracked: changes.filter((change) => change.untracked),
+			conflicted,
+			truncated,
+			readAt: Date.now()
+		};
+	}
+	/**
+	* Read one path's patch.
+	* @param request - which path, and which of the two indexes to compare.
+	* @param signal - cancellation for the reading.
+	* @returns the patch, or a classified failure.
+	*/
+	async diff(request, signal) {
+		const prepared = await this.prepare(request.workspacePath, signal);
+		if ("failure" in prepared) return prepared.failure;
+		const { repository } = prepared;
+		const contained = await this.contain(repository.root, [request.path], signal);
+		if (contained !== void 0) return contained;
+		const common = [
+			"--no-pager",
+			"diff",
+			"--no-color",
+			"--no-ext-diff"
+		];
+		const argv = request.untracked ? [
+			...common,
+			"--no-index",
+			"--",
+			devNull(),
+			request.path
+		] : [
+			...common,
+			...request.staged ? ["--cached"] : [],
+			"--",
+			request.path
+		];
+		const max = this.source().gitDiffMaxBytes;
+		const outcome = await this.git(repository.root, argv, signal, max);
+		const differed = request.untracked && outcome.exitCode === 1 && outcome.stderr.trim() === "";
+		if (outcome.exitCode !== 0 && !differed) return classify(outcome);
+		const patch = outcome.stdout;
+		const truncated = outcome.stdoutLossy || patch.length > max;
+		return {
+			ok: true,
+			path: request.path,
+			patch: patch.length > max ? patch.slice(0, max) : patch,
+			binary: /^Binary files .* differ$/mu.test(patch),
+			truncated
+		};
+	}
+	/**
+	* Stage paths.
+	* @param request - the workspace and the repository-relative paths to add.
+	* @param signal - cancellation for the write and the reading that follows it.
+	* @returns the reading after the write, or a classified failure.
+	*/
+	stage(request, signal) {
+		if (!this.source().allowGitStaging) return Promise.resolve(fail$4("disabled", "staging is switched off in the advanced-sidebar settings"));
+		return this.write(request, signal, (paths) => [
+			"add",
+			"--",
+			...paths
+		]);
+	}
+	/**
+	* Unstage paths, leaving the working tree untouched.
+	* @param request - the workspace and the repository-relative paths to restore.
+	* @param signal - cancellation for the write and the reading that follows it.
+	* @returns the reading after the write, or a classified failure.
+	*/
+	unstage(request, signal) {
+		if (!this.source().allowGitStaging) return Promise.resolve(fail$4("disabled", "staging is switched off in the advanced-sidebar settings"));
+		return this.write(request, signal, (paths) => [
+			"restore",
+			"--staged",
+			"--",
+			...paths
+		]);
+	}
+	/**
+	* Record the staged changes.
+	*
+	* The message crosses as one argv element, so no shell ever sees it and nothing in it can become
+	* an option. Hooks run: a `pre-commit` that refuses is a real answer, and its stderr is returned
+	* verbatim rather than summarized.
+	* @param request - the workspace, the message, and whether to replace the previous commit.
+	* @param signal - cancellation for the commit and the reading that follows it.
+	* @returns the new commit and the reading after it, or a classified failure.
+	*/
+	async commit(request, signal) {
+		const settings = this.source();
+		if (!settings.allowGitCommit) return fail$4("disabled", "committing is switched off in the advanced-sidebar settings");
+		const message = request.message.trim();
+		if (message === "") return fail$4("empty-message", "a commit needs a message");
+		const prepared = await this.prepare(request.workspacePath, signal);
+		if ("failure" in prepared) return prepared.failure;
+		const { repository } = prepared;
+		if (await this.author(repository.root, signal) === void 0) return fail$4("no-identity", "git has no user.name and user.email, so it has no author to record; set them with `git config --global user.name` and `git config --global user.email`");
+		if (!request.amend && !await this.hasStaged(repository.root, signal)) return fail$4("nothing-staged", "nothing is staged, so there is nothing to commit");
+		const outcome = await this.git(repository.root, [
+			"commit",
+			...request.amend ? ["--amend"] : [],
+			"-m",
+			message
+		], signal, void 0, settings.gitCommitTimeoutMs);
+		if (outcome.exitCode !== 0) return classify(outcome);
+		const [commit, subject] = (await this.git(repository.root, [
+			"log",
+			"-1",
+			"--format=%h%n%s"
+		], signal)).stdout.split("\n");
+		const status = await this.status({ workspacePath: request.workspacePath }, signal);
+		if (!status.ok) return status;
+		return {
+			ok: true,
+			commit: (commit ?? "").trim(),
+			subject: (subject ?? "").trim(),
+			status,
+			notes: outcome.stderr.trim()
+		};
+	}
+	/**
+	* Send the current branch's commits to its remote.
+	*
+	* Only the current branch, and only to its own upstream: a refspec assembled from browser text
+	* would let one button push anything anywhere, and `git push` with no arguments already means
+	* exactly what the panel offers. A branch with no upstream is published only when the caller asks
+	* for it, because choosing a remote is a decision rather than a default.
+	* @param request - the workspace, and whether an unpublished branch may be published.
+	* @param signal - cancellation; the network wait runs under `gitPushTimeoutMs`.
+	* @returns the push, the reading after it, or a classified failure.
+	*/
+	async push(request, signal) {
+		const settings = this.source();
+		if (!settings.allowGitPush) return fail$4("disabled", "pushing is switched off in the advanced-sidebar settings");
+		const prepared = await this.prepare(request.workspacePath, signal);
+		if ("failure" in prepared) return prepared.failure;
+		const { repository } = prepared;
+		const before = await this.status({ workspacePath: request.workspacePath }, signal);
+		if (!before.ok) return before;
+		if (before.detached || before.branch === void 0) return fail$4("detached-head", "HEAD names a commit rather than a branch, so there is nothing to push");
+		const branch = before.branch;
+		const upstream = before.upstream;
+		if (upstream === void 0 && !request.setUpstream) return fail$4("no-upstream", `${branch} has no upstream; publish it to a remote first, or use Publish to record one`);
+		const remote = upstream === void 0 ? await this.defaultRemote(repository.root, signal) : upstream.split("/")[0] ?? DEFAULT_REMOTE;
+		if (remote === void 0) return fail$4("no-upstream", "this repository has no remote to push to");
+		const outcome = await this.git(repository.root, upstream === void 0 ? [
+			"push",
+			"--set-upstream",
+			remote,
+			branch
+		] : ["push"], signal, void 0, settings.gitPushTimeoutMs);
+		if (outcome.exitCode !== 0) return classify(outcome);
+		const status = await this.status({ workspacePath: request.workspacePath }, signal);
+		if (!status.ok) return status;
+		return {
+			ok: true,
+			branch,
+			remote,
+			published: upstream === void 0,
+			status,
+			notes: `${outcome.stdout}\n${outcome.stderr}`.trim()
+		};
+	}
+	/**
+	* Ask the deployment's own model to write a commit message for what is staged.
+	*
+	* The model sees the staged patch and nothing else — not the working tree, not the repository's
+	* history, not the session. It is the same model the composer is set to, so this needs no second
+	* credential and no second provider; a Host with no model reports the verb unavailable instead.
+	* @param request - the workspace, and whether the message is for an amend.
+	* @param signal - cancellation for the readings and the model call.
+	* @returns the drafted message, or a classified failure.
+	*/
+	async draftCommitMessage(request, signal) {
+		const settings = this.source();
+		if (!settings.allowGitCommit || !settings.allowCommitMessageDraft) return fail$4("disabled", "the drafted commit message is switched off in the advanced-sidebar settings");
+		const llm = this.ctx.get("llm");
+		const models = this.ctx.get("agentDefaultModel");
+		if (llm === void 0 || models === void 0) return fail$4("no-model", "no model is configured for this deployment");
+		const prepared = await this.prepare(request.workspacePath, signal);
+		if ("failure" in prepared) return prepared.failure;
+		const { repository } = prepared;
+		const patch = await this.stagedPatch(repository.root, request.amend, signal);
+		if ("failure" in patch) return patch.failure;
+		if (patch.text.trim() === "") return fail$4("nothing-staged", "nothing is staged, so there is nothing to describe");
+		const selection = models.currentSelection();
+		try {
+			let drafted = "";
+			for await (const chunk of llm.stream({
+				provider: selection.provider,
+				model: selection.model,
+				...selection.reasoningEffort === void 0 ? {} : { reasoningEffort: selection.reasoningEffort },
+				system: settings.commitMessagePrompt.trim() === "" ? DEFAULT_COMMIT_PROMPT : settings.commitMessagePrompt,
+				messages: [createUserMessage({
+					content: [{
+						type: "text",
+						text: patch.text
+					}],
+					source: {
+						kind: "plugin",
+						plugin: "dsh-advanced-sidebar"
+					}
+				})],
+				...signal === void 0 ? {} : { signal }
+			})) if (chunk.type === "text-delta") drafted += chunk.text;
+			const message = stripFence(drafted);
+			if (message === "") return fail$4("llm-failed", "the model returned no message");
+			return {
+				ok: true,
+				message,
+				model: `${selection.provider}/${selection.model}`,
+				truncated: patch.truncated
+			};
+		} catch (error) {
+			if (signal?.aborted === true) return fail$4("cancelled", "the request was abandoned");
+			return fail$4("llm-failed", error instanceof Error ? error.message : "the model request failed");
+		}
+	}
+	/**
+	* The patch a drafted message describes, bounded so a large change cannot become a large request.
+	* @param root - absolute repository root.
+	* @param amend - describe the previous commit's content as well as the index.
+	* @param signal - cancellation for the invocations.
+	* @returns the patch and whether it was cut, or the failure to return.
+	*/
+	async stagedPatch(root, amend, signal) {
+		const settings = this.source();
+		const base = amend && await this.hasParent(root, signal) ? ["HEAD~1"] : [];
+		const stat = await this.git(root, [
+			"diff",
+			"--cached",
+			"--stat",
+			...base
+		], signal);
+		if (stat.exitCode !== 0) return { failure: classify(stat) };
+		const cap = settings.commitMessageMaxBytes;
+		const patch = await this.git(root, [
+			"diff",
+			"--cached",
+			"--no-color",
+			...base
+		], signal, cap);
+		if (patch.exitCode !== 0) return { failure: classify(patch) };
+		const truncated = patch.stdoutLossy || patch.stdout.length >= cap;
+		return {
+			text: [
+				stat.stdout.trim(),
+				"",
+				truncated ? patch.stdout.slice(0, cap) : patch.stdout,
+				truncated ? "\n[the patch was truncated here]" : ""
+			].join("\n").trim(),
+			truncated
+		};
+	}
+	/**
+	* Whether HEAD has a parent commit.
+	* @param cwd - absolute repository root.
+	* @param signal - cancellation for the invocation.
+	* @returns true when `HEAD~1` resolves.
+	*/
+	async hasParent(cwd, signal) {
+		return (await this.git(cwd, [
+			"rev-parse",
+			"--verify",
+			"--quiet",
+			"HEAD~1"
+		], signal)).exitCode === 0;
+	}
+	/**
+	* The remote an unpublished branch would be published to.
+	* @param cwd - absolute repository root.
+	* @param signal - cancellation for the invocation.
+	* @returns `origin` when it exists, else the first remote, else undefined.
+	*/
+	async defaultRemote(cwd, signal) {
+		const outcome = await this.git(cwd, ["remote"], signal);
+		if (outcome.exitCode !== 0) return void 0;
+		const remotes = outcome.stdout.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+		return remotes.includes(DEFAULT_REMOTE) ? DEFAULT_REMOTE : remotes[0];
+	}
+	/**
+	* Run one index write over contained paths, then re-read the repository.
+	* @param request - the workspace and the paths.
+	* @param signal - cancellation for both invocations.
+	* @param argv - builds the git arguments from the accepted paths.
+	* @returns the reading after the write, or a classified failure.
+	*/
+	async write(request, signal, argv) {
+		if (request.paths.length === 0) return fail$4("path-denied", "no paths were given");
+		const prepared = await this.prepare(request.workspacePath, signal);
+		if ("failure" in prepared) return prepared.failure;
+		const { repository } = prepared;
+		const contained = await this.contain(repository.root, request.paths, signal);
+		if (contained !== void 0) return contained;
+		const outcome = await this.git(repository.root, argv(request.paths), signal);
+		if (outcome.exitCode !== 0) return classify(outcome);
+		const status = await this.status({ workspacePath: request.workspacePath }, signal);
+		return status.ok ? {
+			ok: true,
+			status
+		} : status;
+	}
+	/**
+	* Prove every path sits inside the repository before git is handed any of them.
+	*
+	* A path from the browser is untrusted input at a process boundary. `git add` and
+	* `git restore` both accept absolute paths and `..`, and `git diff --no-index` will read any file
+	* at all — so an unchecked path is a write outside the repository in one direction and an
+	* exfiltration route in the other.
+	* @param root - absolute repository root.
+	* @param paths - repository-relative paths, as the browser sent them.
+	* @param signal - cancellation for the resolutions.
+	* @returns the failure to return, or undefined when every path is inside.
+	*/
+	async contain(root, paths, signal) {
+		const resolved = await resolveWorkspace(this.ctx, root, signal);
+		if (!resolved.ok) return fail$4(resolved.rejection.code, resolved.rejection.message);
+		for (const path of paths) {
+			const inside = await resolveInside(this.ctx, resolved.value, resolve(root, path), signal);
+			if (!inside.ok) return fail$4(inside.rejection.code, inside.rejection.message);
+		}
+	}
+	/**
+	* The author `git commit` would record.
+	* @param cwd - the repository root.
+	* @param signal - cancellation for the invocation.
+	* @returns `Name <email>`, or undefined when git has no identity configured.
+	*/
+	async author(cwd, signal) {
+		const outcome = await this.git(cwd, ["var", "GIT_AUTHOR_IDENT"], signal);
+		if (outcome.exitCode !== 0) return void 0;
+		const ident = outcome.stdout.trim();
+		const at = ident.lastIndexOf(">");
+		return at < 0 ? void 0 : ident.slice(0, at + 1);
+	}
+	/**
+	* Whether the index differs from HEAD.
+	* @param cwd - the repository root.
+	* @param signal - cancellation for the invocation.
+	* @returns true when a commit would record something.
+	*/
+	async hasStaged(cwd, signal) {
+		return (await this.git(cwd, [
+			"diff",
+			"--cached",
+			"--quiet"
+		], signal)).exitCode !== 0;
+	}
+	/**
+	* Report what the panel may do to this repository.
+	* @param cwd - the repository root.
+	* @param signal - cancellation for the identity lookup.
+	* @returns the write capability.
+	*/
+	async writeCapability(cwd, signal) {
+		const settings = this.source();
+		const canStage = settings.allowGitStaging;
+		const canCommit = canStage && settings.allowGitCommit;
+		const canDraftMessage = canCommit && settings.allowCommitMessageDraft && this.ctx.get("llm") !== void 0 && this.ctx.get("agentDefaultModel") !== void 0;
+		const author = canCommit ? await this.author(cwd, signal) : void 0;
+		return {
+			canStage,
+			canCommit,
+			canPush: settings.allowGitPush,
+			canDraftMessage,
+			...author === void 0 ? {} : { author }
+		};
+	}
+	/**
+	* Resolve the workspace and its repository once for both endpoints.
+	* @param workspacePath - the browser-supplied directory.
+	* @param signal - cancellation for the resolution and the `rev-parse`.
+	* @returns the repository and the resolved workspace, or the failure to return.
+	*/
+	async prepare(workspacePath, signal) {
+		const workspace = await resolveWorkspace(this.ctx, workspacePath, signal);
+		if (!workspace.ok) return { failure: fail$4(workspace.rejection.code, workspace.rejection.message) };
+		const repository = await this.locateRepository(workspace.value.processPath, signal);
+		if ("failure" in repository) return { failure: repository.failure };
+		return {
+			repository: repository.repository,
+			workspace
+		};
+	}
+	/**
+	* Ask git where the repository containing a directory begins.
+	* @param cwd - the canonical workspace directory.
+	* @param signal - cancellation for the invocation.
+	* @returns the repository, or the failure to return.
+	*/
+	async locateRepository(cwd, signal) {
+		const outcome = await this.git(cwd, [
+			"rev-parse",
+			"--show-toplevel",
+			"--show-prefix"
+		], signal);
+		if (outcome.exitCode !== 0) return { failure: classify(outcome) };
+		const [root, prefix] = outcome.stdout.split("\n");
+		if (root === void 0 || root.trim() === "") return { failure: fail$4("not-a-repository", `${cwd} is not inside a git repository`) };
+		return { repository: {
+			root: root.trim(),
+			prefix: (prefix ?? "").trim().replace(/\/$/u, "")
+		} };
+	}
+	/**
+	* Run one git invocation with this plugin's own bounds.
+	* @param cwd - directory to run in.
+	* @param args - arguments after the executable.
+	* @param signal - the caller's cancellation.
+	* @returns the finished command.
+	*/
+	async git(cwd, args, signal, maxBytes, timeoutMs) {
+		const executable = await this.locate(signal);
+		if (executable === void 0) return {
+			exitCode: MISSING_BINARY_EXIT,
+			signal: null,
+			stdout: "",
+			stderr: "git is not installed, or not on this Host process PATH",
+			timedOut: false,
+			aborted: false,
+			stdoutLossy: false
+		};
+		const settings = this.source();
+		return runCommand(this.ctx, {
+			argv: [executable, ...args],
+			cwd,
+			timeoutMs: timeoutMs ?? settings.gitTimeoutMs,
+			maxBytes: maxBytes ?? Math.max(settings.gitDiffMaxBytes, 1 << 20),
+			graceMs: 1e3,
+			env: {
+				GIT_PAGER: "cat",
+				GIT_OPTIONAL_LOCKS: "0",
+				LC_ALL: "C",
+				GIT_EDITOR: "true",
+				GIT_TERMINAL_PROMPT: "0"
+			}
+		}, signal);
+	}
+	/**
+	* Resolve `git` once and remember it.
+	* @param signal - cancellation for the lookup.
+	* @returns the executable path, or undefined when git is absent.
+	* @throws {CommandUnavailableError} when no subprocess capability is mounted.
+	*/
+	async locate(signal) {
+		if (this.executable !== void 0) return this.executable;
+		const found = await resolveCommand(this.ctx, "git", signal);
+		if (found === void 0) return void 0;
+		this.executable = found;
+		try {
+			const outcome = await runCommand(this.ctx, {
+				argv: [found, "--version"],
+				cwd: process.cwd(),
+				timeoutMs: 5e3,
+				maxBytes: 4096,
+				graceMs: 1e3
+			}, signal);
+			if (outcome.exitCode === 0) this.version = outcome.stdout.trim();
+		} catch (error) {
+			/* v8 ignore next -- runCommand only throws for a withdrawn subprocess capability. */
+			if (!(error instanceof CommandUnavailableError)) throw error;
+		}
+		return found;
+	}
+};
+/**
+* The empty left-hand side of an untracked file's synthesized patch.
+* @returns the platform's null device path.
+*/
+function devNull() {
+	return process.platform === "win32" ? "NUL" : "/dev/null";
+}
+
+//#endregion
+//#region tsbuild/host/open-in.js
+/** Id of the built-in file-manager target; no configured editor may claim it. */
+const REVEAL_TARGET_ID = "reveal";
+/** Wall-clock bound on a launch. A desktop opener returns immediately or is broken. */
+const LAUNCH_TIMEOUT_MS = 15e3;
+/** TERM-to-KILL grace for a launcher that ignored its deadline. */
+const LAUNCH_GRACE_MS = 2e3;
+/** Compose one classified failure. */
+function fail$3(code, message) {
+	return {
+		ok: false,
+		code,
+		message
+	};
+}
+/** The file manager's name on this platform, used as the target's menu text. */
+function revealLabel(platform) {
+	if (platform === "darwin") return "Finder";
+	if (platform === "win32") return "File Explorer";
+	return "File manager";
+}
+/**
+* Launches external applications for the Open in submenu. One instance serves every request and
+* caches each target's resolved executable.
+*/
+var OpenInLauncher = class {
+	ctx;
+	source;
+	resolved = /* @__PURE__ */ new Map();
+	/**
+	* @param ctx - Host context carrying the subprocess and filesystem capabilities.
+	* @param source - reads the current settings section; called per request so an edited target list
+	* reaches the next menu with no registration to rebuild.
+	*/
+	constructor(ctx, source) {
+		this.ctx = ctx;
+		this.source = source;
+	}
+	/**
+	* List every target in menu order with its availability.
+	*
+	* Unavailable targets are listed rather than hidden: a person who configured an editor and does
+	* not see it cannot tell a typo in `command` from a menu that simply has no such feature.
+	* @param signal - cancellation for the executable lookups.
+	* @returns the targets, file manager first.
+	*/
+	async describe(signal) {
+		const platform = process.platform;
+		const views = [{
+			id: REVEAL_TARGET_ID,
+			label: revealLabel(platform),
+			available: await this.available(this.revealCommand(platform).argv[0] ?? "", signal),
+			kind: "reveal"
+		}];
+		for (const editor of this.source().editors) views.push({
+			id: editor.id,
+			label: editor.label,
+			available: await this.available(editor.command, signal),
+			kind: "command"
+		});
+		return views;
+	}
+	/**
+	* Hand one path to a target.
+	* @param request - which target, and which absolute path.
+	* @param signal - cancellation for the launch.
+	* @returns settlement, or a classified failure.
+	*/
+	async open(request, signal) {
+		const resolvedPath = await resolveWorkspace(this.ctx, request.path, signal);
+		const target = resolvedPath.ok ? resolvedPath.value.processPath : await this.resolveFile(request.path, signal);
+		if (target === void 0) return fail$3("path-denied", `${request.path} does not exist on this Host`);
+		const directory = resolvedPath.ok;
+		if (request.targetId === REVEAL_TARGET_ID) return this.reveal(target, directory, signal);
+		const editor = this.source().editors.find((entry) => entry.id === request.targetId);
+		if (editor === void 0) return fail$3("unknown-target", `no Open in target "${request.targetId}"`);
+		const executable = await this.locate(editor.command, signal);
+		if (executable === void 0) return fail$3("unavailable", `${editor.label}: "${editor.command}" does not resolve on this Host`);
+		return this.launch([
+			executable,
+			...editor.args,
+			target
+		], signal);
+	}
+	/**
+	* Show a path in the operating system's file manager.
+	* @param target - the canonical path.
+	* @param directory - whether the path is a directory (opened) or a file (selected).
+	* @param signal - cancellation for the launch.
+	* @returns settlement, or a classified failure.
+	*/
+	async reveal(target, directory, signal) {
+		const platform = process.platform;
+		const { argv, tolerateExit } = this.revealCommand(platform, target, directory);
+		const command = argv[0];
+		if (command === void 0) return fail$3("unavailable", `no file manager is known for ${platform}`);
+		const executable = await this.locate(command, signal);
+		if (executable === void 0) return fail$3("unavailable", `${command} does not resolve on this Host`);
+		return this.launch([executable, ...argv.slice(1)], signal, tolerateExit);
+	}
+	/**
+	* The platform's file-manager invocation.
+	* @param platform - the Host platform.
+	* @param target - the canonical path; omitted while only the executable name is needed.
+	* @param directory - whether the path is a directory.
+	* @returns the argv and whether a non-zero exit is normal for it.
+	*/
+	revealCommand(platform, target = "", directory = true) {
+		if (platform === "darwin") return {
+			argv: directory ? ["open", target] : [
+				"open",
+				"-R",
+				target
+			],
+			tolerateExit: false
+		};
+		if (platform === "win32") return {
+			argv: directory ? ["explorer.exe", target] : ["explorer.exe", `/select,${target}`],
+			tolerateExit: true
+		};
+		return {
+			argv: ["xdg-open", directory ? target : dirname(target)],
+			tolerateExit: false
+		};
+	}
+	/**
+	* Run one launcher and classify its outcome.
+	* @param argv - resolved executable and arguments.
+	* @param signal - cancellation for the launch.
+	* @param tolerateExit - accept a non-zero exit as success (Windows Explorer).
+	* @returns settlement, or a classified failure.
+	*/
+	async launch(argv, signal, tolerateExit = false) {
+		let outcome;
+		try {
+			outcome = await runCommand(this.ctx, {
+				argv,
+				cwd: process.cwd(),
+				timeoutMs: LAUNCH_TIMEOUT_MS,
+				maxBytes: 8192,
+				graceMs: LAUNCH_GRACE_MS
+			}, signal);
+		} catch (error) {
+			if (error instanceof CommandUnavailableError) return fail$3("unavailable", error.message);
+			throw error;
+		}
+		if (outcome.timedOut) return fail$3("timeout", `${argv[0] ?? "launcher"} did not return within ${String(LAUNCH_TIMEOUT_MS)}ms`);
+		if (outcome.exitCode === 0 || tolerateExit) return { ok: true };
+		const detail = outcome.stderr.trim();
+		return fail$3("launch-failed", detail === "" ? `${argv[0] ?? "launcher"} exited with code ${String(outcome.exitCode)}` : detail);
+	}
+	/**
+	* Resolve a file path that is not a directory.
+	* @param path - the browser-supplied path.
+	* @param signal - cancellation for the resolution.
+	* @returns the canonical path, or undefined when nothing is there.
+	*/
+	async resolveFile(path, signal) {
+		const fs = this.ctx.get("fs");
+		if (fs === void 0) return void 0;
+		try {
+			const resolved = await fs.resolve(path, signal === void 0 ? {} : { signal });
+			return await fs.stat(resolved, signal) === void 0 ? void 0 : fs.processPath(resolved);
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Whether one command resolves, without reporting why it does not.
+	* @param command - executable name or path.
+	* @param signal - cancellation for the lookup.
+	* @returns true when the command resolves.
+	*/
+	async available(command, signal) {
+		if (command === "") return false;
+		try {
+			return await this.locate(command, signal) !== void 0;
+		} catch (error) {
+			/* v8 ignore next -- only a missing subprocess capability reaches here. */
+			if (error instanceof CommandUnavailableError) return false;
+			/* v8 ignore next */
+			throw error;
+		}
+	}
+	/**
+	* Resolve one command once and remember the answer, negative answers included.
+	* @param command - executable name or path.
+	* @param signal - cancellation for the lookup.
+	* @returns the executable path, or undefined when the command is absent.
+	* @throws {CommandUnavailableError} when no subprocess capability is mounted.
+	*/
+	async locate(command, signal) {
+		if (this.resolved.has(command)) return this.resolved.get(command);
+		const found = await resolveCommand(this.ctx, command, signal);
+		this.resolved.set(command, found);
+		return found;
+	}
+	/** Drop every cached lookup, so an edited target list or a newly installed editor is re-probed. */
+	forget() {
+		this.resolved.clear();
+	}
+};
+
+//#endregion
+//#region tsbuild/host/preview.js
+/** Claude Code's launch file, read relative to the workspace root. */
+const LAUNCH_FILE = ".claude/launch.json";
+/** How long one readiness probe waits for the socket before retrying. */
+const PROBE_TIMEOUT_MS = 500;
+/** How long to wait between readiness probes. */
+const PROBE_INTERVAL_MS = 250;
+/** In-memory cap per collected stream, in bytes. Generous: a dev server's startup banner is small
+* and its request log is what a person scrolls back through. */
+const STREAM_MAX_BYTES = 4 * 1024 * 1024;
+/** Compose one classified failure. */
+function fail$2(code, message) {
+	return {
+		ok: false,
+		code,
+		message
+	};
+}
+/**
+* Where a configuration's frame should point.
+* @param launch - the configuration.
+* @returns the URL, or undefined when neither a url nor a port was given.
+*/
+function urlOf(launch) {
+	if (launch.url !== void 0 && launch.url !== "") return launch.url;
+	if (launch.port === void 0 || launch.port <= 0) return void 0;
+	return `http://127.0.0.1:${String(launch.port)}`;
+}
+/**
+* Whether a socket accepts a connection on one port.
+* @param port - the port to probe.
+* @param signal - cancellation of the whole readiness wait.
+* @returns true when the connection was accepted.
+*/
+function accepts(port, signal) {
+	return new Promise((resolve$1) => {
+		const socket = connect({
+			port,
+			host: "127.0.0.1"
+		});
+		const settle = (value) => {
+			socket.destroy();
+			signal.removeEventListener("abort", onAbort);
+			resolve$1(value);
+		};
+		const onAbort = () => {
+			settle(false);
+		};
+		socket.setTimeout(PROBE_TIMEOUT_MS);
+		socket.once("connect", () => {
+			settle(true);
+		});
+		socket.once("timeout", () => {
+			settle(false);
+		});
+		socket.once("error", () => {
+			settle(false);
+		});
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/** Sleep, resolving early when the wait is cancelled. */
+function pause(ms, signal) {
+	return new Promise((resolve$1) => {
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve$1();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			resolve$1();
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Read one launch file's configurations.
+*
+* A malformed file is reported rather than thrown: the panel still lists the settings rows and says
+* why the file was ignored, which is more useful than a Preview entry that refuses to open.
+* @param text - the file's contents.
+* @returns the configurations, or the reason the file was ignored.
+*/
+function parseLaunchFile(text) {
+	let document;
+	try {
+		document = JSON.parse(text);
+	} catch (error) {
+		return { error: `not valid JSON: ${error instanceof Error ? error.message : String(error)}` };
+	}
+	if (typeof document !== "object" || document === null) return { error: "the top level is not an object" };
+	const configurations = document.configurations;
+	if (!Array.isArray(configurations)) return { error: "it carries no `configurations` array" };
+	const launches = [];
+	for (const entry of configurations) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const row = entry;
+		const name = row.name;
+		if (typeof name !== "string" || name === "") continue;
+		const args = Array.isArray(row.runtimeArgs) ? row.runtimeArgs.filter((value) => typeof value === "string") : [];
+		launches.push({
+			name,
+			...typeof row.runtimeExecutable === "string" && row.runtimeExecutable !== "" ? { runtimeExecutable: row.runtimeExecutable } : {},
+			runtimeArgs: args,
+			...typeof row.port === "number" && Number.isInteger(row.port) && row.port > 0 ? { port: row.port } : {},
+			...typeof row.url === "string" && row.url !== "" ? { url: row.url } : {},
+			...typeof row.cwd === "string" && row.cwd !== "" ? { cwd: row.cwd } : {},
+			...typeof row.env === "object" && row.env !== null ? { env: Object.fromEntries(Object.entries(row.env).filter((pair) => typeof pair[1] === "string")) } : {}
+		});
+	}
+	return { launches };
+}
+/**
+* Merge a workspace's launch file with the settings rows.
+*
+* The file wins a name collision: a repository stating how to run itself outranks a deployment-wide
+* default that happens to use the same name.
+* @param fromFile - configurations read from `.claude/launch.json`.
+* @param fromSettings - configurations from the `previews` settings rows.
+* @returns the merged list, file rows first.
+*/
+function mergeLaunches(fromFile, fromSettings) {
+	const merged = fromFile.map((launch) => ({
+		launch,
+		origin: "launch-json"
+	}));
+	const claimed = new Set(fromFile.map((launch) => launch.name));
+	for (const launch of fromSettings) {
+		if (claimed.has(launch.name)) continue;
+		claimed.add(launch.name);
+		merged.push({
+			launch,
+			origin: "settings"
+		});
+	}
+	return merged;
+}
+/**
+* Owns every preview server in the process. One instance is created by the service and disposed
+* with it, which is what guarantees no dev server outlives the plugin.
+*/
+var PreviewServers = class {
+	ctx;
+	source;
+	records = /* @__PURE__ */ new Map();
+	/**
+	* Configurations with a start already in flight, keyed `<workspace>\u0000<name>`.
+	*
+	* `start()` awaits a file read, a path resolution, and an executable lookup before it registers
+	* anything, so two starts of one row would both find no predecessor and both spawn — leaving a
+	* dev server on the port that no `serverId` any panel holds can ever stop.
+	*/
+	starting = /* @__PURE__ */ new Set();
+	closing = false;
+	/**
+	* @param ctx - Host context carrying the subprocess and filesystem capabilities.
+	* @param source - reads the current settings section; called per request.
+	*/
+	constructor(ctx, source) {
+		this.ctx = ctx;
+		this.source = source;
+	}
+	/**
+	* Report whether a preview server can be started on this Host.
+	* @returns availability plus how many servers are already running.
+	*/
+	describe() {
+		const running = [...this.records.values()].filter((record) => record.state !== "exited" && record.state !== "failed").length;
+		if (this.ctx.get("subprocess") === void 0) return {
+			available: false,
+			reason: "no subprocess capability is mounted: this deployment composes no @deepseek-ai/dsh-subprocess provider",
+			running
+		};
+		if (this.ctx.get("fs") === void 0) return {
+			available: false,
+			reason: "no filesystem capability is mounted: a launch configuration has no directory to run in",
+			running
+		};
+		return {
+			available: true,
+			running
+		};
+	}
+	/**
+	* List one workspace's configurations, each with its current state.
+	* @param request - the workspace to read.
+	* @param signal - cancellation for the file read.
+	* @returns the list, or a classified failure.
+	*/
+	async list(request, signal) {
+		const workspace = await resolveWorkspace(this.ctx, request.workspacePath, signal);
+		if (!workspace.ok) return fail$2(workspace.rejection.code === "no-filesystem" ? "no-filesystem" : "path-denied", workspace.rejection.message);
+		const file = await this.readLaunchFile(workspace, signal);
+		return {
+			ok: true,
+			servers: mergeLaunches(file.launches, this.settingsLaunches()).map((resolved) => this.view(resolved, workspace.value.processPath)),
+			...file.path === void 0 ? {} : { launchFile: file.path },
+			...file.error === void 0 ? {} : { launchFileError: file.error }
+		};
+	}
+	/**
+	* Start one configuration.
+	* @param request - the workspace and the configuration name.
+	* @param signal - cancellation of the start itself; a started server owns its later lifetime.
+	* @returns the started row, or a classified failure.
+	*/
+	async start(request, signal) {
+		if (this.closing) return fail$2("closed", "the plugin is unloading");
+		if (this.ctx.get("subprocess") === void 0) return fail$2("no-subprocess", "no subprocess capability is mounted");
+		const workspace = await resolveWorkspace(this.ctx, request.workspacePath, signal);
+		if (!workspace.ok) return fail$2(workspace.rejection.code === "no-filesystem" ? "no-filesystem" : "path-denied", workspace.rejection.message);
+		const resolved = mergeLaunches((await this.readLaunchFile(workspace, signal)).launches, this.settingsLaunches()).find((entry) => entry.launch.name === request.name);
+		if (resolved === void 0) return fail$2("unknown-server", `no launch configuration named "${request.name}"`);
+		const launch = resolved.launch;
+		if (launch.runtimeExecutable === void 0 || launch.runtimeExecutable === "") return fail$2("not-startable", `"${launch.name}" names no command; it opens its url and starts nothing`);
+		const key = `${workspace.value.processPath}\u0000${launch.name}`;
+		if (this.starting.has(key)) return fail$2("limit-reached", `"${launch.name}" is already starting`);
+		this.starting.add(key);
+		try {
+			return await this.spawn(workspace, launch, resolved.origin, signal);
+		} finally {
+			this.starting.delete(key);
+		}
+	}
+	/**
+	* Start one validated configuration, holding its in-flight claim.
+	* @param workspace - the resolved workspace.
+	* @param launch - the configuration, already known to name a command.
+	* @param origin - which file it came from.
+	* @param signal - cancellation of the start.
+	* @returns the started row, or a classified failure.
+	*/
+	async spawn(workspace, launch, origin, signal) {
+		const subprocess = this.ctx.get("subprocess");
+		/* v8 ignore next -- the caller resolved the same service moments earlier. */
+		if (subprocess === void 0) return fail$2("no-subprocess", "no subprocess capability is mounted");
+		const settings = this.source();
+		const previous = this.find(workspace.value.processPath, launch.name);
+		if (previous !== void 0) await this.terminate(previous);
+		if ([...this.records.values()].filter((record$1) => record$1.state === "starting" || record$1.state === "ready").length >= settings.maxPreviews) return fail$2("limit-reached", `${String(settings.maxPreviews)} preview servers are already running`);
+		const directory = await this.launchDirectory(workspace, launch, signal);
+		if ("failure" in directory) return directory.failure;
+		let executable;
+		try {
+			executable = await resolveCommand(this.ctx, launch.runtimeExecutable ?? "", signal);
+		} catch (error) {
+			return fail$2("no-subprocess", error instanceof CommandUnavailableError ? error.message : String(error));
+		}
+		if (executable === void 0) return fail$2("unavailable", `"${launch.runtimeExecutable ?? ""}" does not resolve on this Host`);
+		if (this.closing) return fail$2("closed", "the plugin is unloading");
+		let handle;
+		try {
+			handle = subprocess.spawn({
+				argv: [executable, ...launch.runtimeArgs ?? []],
+				cwd: directory.path,
+				stdio: {
+					stdin: "ignore",
+					stdout: { maxBytes: STREAM_MAX_BYTES },
+					stderr: { maxBytes: STREAM_MAX_BYTES }
+				},
+				graceMs: settings.previewGraceMs,
+				env: {
+					NO_COLOR: "1",
+					FORCE_COLOR: "0",
+					...launch.env ?? {},
+					...launch.port === void 0 ? {} : { PORT: String(launch.port) }
+				}
+			});
+		} catch (error) {
+			return fail$2("spawn-failed", error instanceof Error ? error.message : String(error));
+		}
+		const record = {
+			serverId: randomUUID(),
+			name: launch.name,
+			workspace: workspace.value.processPath,
+			origin,
+			handle,
+			url: urlOf(launch),
+			port: launch.port,
+			startedAt: Date.now(),
+			base: 0,
+			buffer: "",
+			read: {
+				stdout: 0,
+				stderr: 0
+			},
+			state: launch.port === void 0 ? "ready" : "starting",
+			exitCode: null,
+			detail: void 0,
+			abort: new AbortController()
+		};
+		this.records.set(record.serverId, record);
+		if (this.closing) {
+			await this.terminate(record);
+			return fail$2("closed", "the plugin is unloading");
+		}
+		this.watch(record);
+		if (record.state === "starting") this.awaitReady(record);
+		return {
+			ok: true,
+			server: this.viewOf(record)
+		};
+	}
+	/**
+	* Stop one server and forget it.
+	* @param request - the handle.
+	* @returns settlement, or a classified failure.
+	*/
+	async stop(request) {
+		const record = this.records.get(request.serverId);
+		if (record === void 0) return fail$2("unknown-server", `no preview server ${request.serverId}`);
+		this.records.delete(record.serverId);
+		await this.terminate(record);
+		return { ok: true };
+	}
+	/**
+	* Read one server's output from a caller-owned offset, with its state at read time.
+	* @param request - the handle and the offset already rendered.
+	* @returns the delta and the state, or a classified failure.
+	*/
+	logs(request) {
+		const record = this.records.get(request.serverId);
+		if (record === void 0) return fail$2("unknown-server", `no preview server ${request.serverId}`);
+		this.drain(record);
+		const total = record.base + record.buffer.length;
+		const from = Number.isFinite(request.fromOffset) ? Math.max(0, Math.floor(request.fromOffset)) : 0;
+		const lossy = from < record.base;
+		const text = lossy ? record.buffer : record.buffer.slice(Math.min(from - record.base, record.buffer.length));
+		return {
+			ok: true,
+			serverId: record.serverId,
+			text,
+			nextOffset: total,
+			lossy,
+			server: this.viewOf(record)
+		};
+	}
+	/**
+	* Terminate every server and refuse new ones. Called from the service's teardown effect.
+	* @returns after every process tree has exited.
+	*/
+	async disposeAll() {
+		this.closing = true;
+		const live = [...this.records.values()];
+		this.records.clear();
+		await Promise.all(live.map((record) => this.terminate(record)));
+	}
+	/**
+	* The `previews` settings rows, normalized into the shape the merge reads.
+	* @returns the configured launches.
+	*/
+	settingsLaunches() {
+		return this.source().previews.map((row) => ({
+			name: row.name,
+			...row.runtimeExecutable === "" ? {} : { runtimeExecutable: row.runtimeExecutable },
+			runtimeArgs: row.runtimeArgs,
+			...row.port <= 0 ? {} : { port: row.port },
+			...row.url === "" ? {} : { url: row.url },
+			...row.cwd === "" ? {} : { cwd: row.cwd }
+		}));
+	}
+	/**
+	* Read and parse the workspace's launch file.
+	* @param workspace - the resolved workspace.
+	* @param signal - cancellation for the read.
+	* @returns the configurations, the file's path when it existed, and why it was ignored when it was.
+	*/
+	async readLaunchFile(workspace, signal) {
+		if (!this.source().previewsFromLaunchFile) return { launches: [] };
+		const fs = this.ctx.get("fs");
+		if (fs === void 0) return { launches: [] };
+		const path = join(workspace.value.processPath, LAUNCH_FILE);
+		let text;
+		try {
+			const target = await fs.resolve(path, signal === void 0 ? {} : { signal });
+			const info = await fs.stat(target, signal);
+			if (info === void 0 || info.type !== "file") return { launches: [] };
+			text = await fs.readText(target, signal);
+		} catch {
+			return { launches: [] };
+		}
+		const parsed = parseLaunchFile(text);
+		if ("error" in parsed) return {
+			launches: [],
+			path,
+			error: `${LAUNCH_FILE} was ignored: ${parsed.error}`
+		};
+		return {
+			launches: parsed.launches,
+			path
+		};
+	}
+	/**
+	* Resolve the directory one configuration runs in, proving it stays inside the workspace.
+	* @param workspace - the resolved workspace.
+	* @param launch - the configuration.
+	* @param signal - cancellation for the resolution.
+	* @returns the directory, or the failure to return.
+	*/
+	async launchDirectory(workspace, launch, signal) {
+		if (launch.cwd === void 0 || launch.cwd === "") return { path: workspace.value.processPath };
+		const candidate = isAbsolute(launch.cwd) ? launch.cwd : join(workspace.value.processPath, launch.cwd);
+		const resolved = await resolveInside(this.ctx, workspace.value, candidate, signal);
+		if (!resolved.ok) return { failure: fail$2(resolved.rejection.code === "no-filesystem" ? "no-filesystem" : "path-denied", resolved.rejection.message) };
+		return { path: resolved.value.processPath };
+	}
+	/**
+	* Watch one process for its exit.
+	* @param record - the started server.
+	*/
+	watch(record) {
+		record.handle.done.then((outcome) => {
+			record.abort.abort();
+			record.exitCode = outcome.exitCode;
+			record.state = record.state === "ready" ? "exited" : "failed";
+			if (record.state === "failed" && record.detail === void 0) record.detail = outcome.signal === null ? `the process exited with code ${String(outcome.exitCode)} before its port accepted` : `the process ended on ${outcome.signal} before its port accepted`;
+		}, (error) => {
+			record.abort.abort();
+			record.state = "failed";
+			record.detail = error instanceof Error ? error.message : String(error);
+		});
+	}
+	/**
+	* Probe one server's port until it accepts or the deadline passes.
+	* @param record - the started server.
+	*/
+	async awaitReady(record) {
+		const port = record.port;
+		/* v8 ignore next -- only a row WITH a port enters the starting state. */
+		if (port === void 0) return;
+		const deadline = Date.now() + this.source().previewReadyTimeoutMs;
+		while (!record.abort.signal.aborted && Date.now() < deadline) {
+			if (await accepts(port, record.abort.signal)) {
+				if (record.state === "starting") record.state = "ready";
+				return;
+			}
+			await pause(PROBE_INTERVAL_MS, record.abort.signal);
+		}
+		if (record.state === "starting") {
+			record.state = "failed";
+			record.detail = `port ${String(port)} did not accept a connection within previewReadyTimeoutMs`;
+		}
+	}
+	/**
+	* Move whatever the collected streams hold into the retained buffer.
+	*
+	* Both streams share one buffer and one offset, because the panel shows one log: a dev server
+	* prints its banner on one and its errors on the other, and two independently scrolling views of
+	* the same startup would be harder to read, not easier.
+	* @param record - the server to drain.
+	*/
+	drain(record) {
+		const take = (reader, from) => {
+			/* v8 ignore next -- both streams are spawned in collect mode, so both readers exist. */
+			if (reader === void 0) return {
+				text: "",
+				next: from
+			};
+			const read = reader.readFrom(from);
+			return {
+				text: read.lossy ? "" : read.text,
+				next: read.nextOffset
+			};
+		};
+		const out = take(record.handle.collected.stdout, record.read.stdout);
+		const err = take(record.handle.collected.stderr, record.read.stderr);
+		record.read = {
+			stdout: out.next,
+			stderr: err.next
+		};
+		const added = out.text + err.text;
+		if (added === "") return;
+		record.buffer += added;
+		const max = Math.max(this.source().previewScrollback, 1024);
+		if (record.buffer.length > max) {
+			const drop = record.buffer.length - max;
+			record.base += drop;
+			record.buffer = record.buffer.slice(drop);
+		}
+	}
+	/**
+	* Find a live record for one workspace and configuration name.
+	* @param workspace - canonical workspace path.
+	* @param name - configuration name.
+	* @returns the record, when one exists.
+	*/
+	find(workspace, name) {
+		for (const record of this.records.values()) if (record.workspace === workspace && record.name === name) return record;
+	}
+	/**
+	* Stop one process tree without letting a cleanup fault escape.
+	* @param record - the server to stop.
+	* @returns after the tree has exited.
+	*/
+	async terminate(record) {
+		record.abort.abort();
+		this.records.delete(record.serverId);
+		try {
+			record.handle.terminate();
+			await record.handle.waitForExit();
+		} catch {}
+	}
+	/**
+	* Project one configuration into its view, attaching a live record when one exists.
+	* @param resolved - the configuration and its origin.
+	* @param workspace - canonical workspace path.
+	* @returns the view.
+	*/
+	view(resolved, workspace) {
+		const record = this.find(workspace, resolved.launch.name);
+		if (record !== void 0) return this.viewOf(record);
+		const startable = resolved.launch.runtimeExecutable !== void 0 && resolved.launch.runtimeExecutable !== "";
+		const url = urlOf(resolved.launch);
+		return {
+			name: resolved.launch.name,
+			origin: resolved.origin,
+			startable,
+			state: startable ? "stopped" : "ready",
+			...url === void 0 ? {} : { url },
+			...resolved.launch.port === void 0 ? {} : { port: resolved.launch.port },
+			...startable ? {} : { detail: "this configuration opens its url and starts nothing" }
+		};
+	}
+	/**
+	* Project one live record into its view.
+	* @param record - the server.
+	* @returns the view.
+	*/
+	viewOf(record) {
+		return {
+			serverId: record.serverId,
+			name: record.name,
+			origin: record.origin,
+			startable: true,
+			state: record.state,
+			...record.url === void 0 ? {} : { url: record.url },
+			...record.port === void 0 ? {} : { port: record.port },
+			...record.handle.pid < 0 ? {} : { pid: record.handle.pid },
+			...record.state === "exited" || record.state === "failed" ? { exitCode: record.exitCode } : {},
+			...record.detail === void 0 ? {} : { detail: record.detail },
+			startedAt: record.startedAt
+		};
+	}
+};
+
+//#endregion
+//#region tsbuild/host/terminals.js
+/** Compose one classified failure. */
+function fail$1(code, message) {
+	return {
+		ok: false,
+		code,
+		message
+	};
+}
+/** Terminal geometry the substrate will accept, whatever the panel measured. */
+function clampGeometry(cols, rows) {
+	const bound = (value, low, high) => Number.isFinite(value) ? Math.min(Math.max(Math.round(value), low), high) : low;
+	return {
+		cols: bound(cols, 20, 500),
+		rows: bound(rows, 5, 200)
+	};
+}
+/**
+* Owns every panel terminal in the process. One instance is created by the service and disposed
+* with it, which is what guarantees no shell outlives the plugin.
+*/
+var PanelTerminals = class {
+	ctx;
+	source;
+	records = /* @__PURE__ */ new Map();
+	closing = false;
+	/**
+	* @param ctx - Host context carrying the subprocess and filesystem capabilities.
+	* @param source - reads the current settings section; called per request.
+	*/
+	constructor(ctx, source) {
+		this.ctx = ctx;
+		this.source = source;
+	}
+	/**
+	* Report whether a panel terminal can be allocated on this Host.
+	* @returns availability plus the shell that would answer.
+	*/
+	describe() {
+		if (this.ctx.get("subprocess") === void 0) return {
+			available: false,
+			reason: "no subprocess capability is mounted: this deployment composes no @deepseek-ai/dsh-subprocess provider"
+		};
+		if (this.ctx.get("fs") === void 0) return {
+			available: false,
+			reason: "no filesystem capability is mounted: the terminal has no way to resolve its working directory"
+		};
+		return {
+			available: true,
+			detail: this.shell()
+		};
+	}
+	/**
+	* Allocate one terminal in a workspace.
+	* @param request - the directory and the panel's measured geometry.
+	* @param signal - cancellation of the allocation; a published terminal owns its later lifetime.
+	* @returns the handle, or a classified failure.
+	*/
+	async open(request, signal) {
+		if (this.closing) return fail$1("closed", "the plugin is unloading");
+		const subprocess = this.ctx.get("subprocess");
+		if (subprocess === void 0) return fail$1("no-subprocess", "no subprocess capability is mounted");
+		const settings = this.source();
+		if ([...this.records.values()].filter((record$1) => record$1.running).length >= settings.maxTerminals) return fail$1("limit-reached", `${String(settings.maxTerminals)} panel terminals are already open`);
+		const workspace = await resolveWorkspace(this.ctx, request.workspacePath, signal);
+		if (!workspace.ok) return fail$1(workspace.rejection.code === "no-filesystem" ? "no-filesystem" : "path-denied", workspace.rejection.message);
+		const shell = this.shell();
+		const { cols, rows } = clampGeometry(request.cols, request.rows);
+		let handle;
+		try {
+			handle = await subprocess.spawnTerminal({
+				argv: [shell],
+				cwd: workspace.value.processPath,
+				rows,
+				cols,
+				graceMs: settings.terminalGraceMs,
+				signal,
+				env: {
+					TERM: "xterm-256color",
+					COLUMNS: String(cols),
+					LINES: String(rows)
+				}
+			});
+		} catch (error) {
+			return fail$1("spawn-failed", error instanceof Error ? error.message : String(error));
+		}
+		const record = {
+			id: randomUUID(),
+			handle,
+			shell,
+			cwd: workspace.value.processPath,
+			base: 0,
+			buffer: "",
+			running: true,
+			exitCode: null,
+			signal: null
+		};
+		this.records.set(record.id, record);
+		this.collect(record);
+		return {
+			ok: true,
+			terminalId: record.id,
+			shell,
+			cwd: record.cwd,
+			pid: handle.pid
+		};
+	}
+	/**
+	* Read output from a caller-owned offset.
+	* @param request - the handle and the offset already rendered.
+	* @returns the delta and the process state, or a classified failure.
+	*/
+	read(request) {
+		const record = this.records.get(request.terminalId);
+		if (record === void 0) return fail$1("unknown-terminal", `no panel terminal ${request.terminalId}`);
+		const total = record.base + record.buffer.length;
+		const from = Number.isFinite(request.fromOffset) ? Math.max(0, Math.floor(request.fromOffset)) : 0;
+		const lossy = from < record.base;
+		const text = lossy ? record.buffer : record.buffer.slice(Math.min(from - record.base, record.buffer.length));
+		return {
+			ok: true,
+			terminalId: record.id,
+			text,
+			nextOffset: total,
+			lossy,
+			running: record.running,
+			...record.running ? {} : {
+				exitCode: record.exitCode,
+				signal: record.signal
+			}
+		};
+	}
+	/**
+	* Send keystrokes.
+	* @param request - the handle and the text to deliver verbatim.
+	* @returns settlement, or a classified failure.
+	*/
+	async write(request) {
+		const record = this.records.get(request.terminalId);
+		if (record === void 0) return fail$1("unknown-terminal", `no panel terminal ${request.terminalId}`);
+		if (!record.running) return fail$1("unknown-terminal", `panel terminal ${record.id} has exited`);
+		try {
+			await record.handle.write(request.data);
+		} catch (error) {
+			return fail$1("spawn-failed", error instanceof Error ? error.message : String(error));
+		}
+		return { ok: true };
+	}
+	/**
+	* Deliver a signal to the terminal's foreground process group.
+	* @param request - the handle and the signal.
+	* @returns settlement, or a classified failure.
+	*/
+	async signal(request) {
+		const record = this.records.get(request.terminalId);
+		if (record === void 0) return fail$1("unknown-terminal", `no panel terminal ${request.terminalId}`);
+		if (!record.running) return fail$1("unknown-terminal", `panel terminal ${record.id} has exited`);
+		try {
+			await record.handle.signalForeground(request.signal);
+		} catch {}
+		return { ok: true };
+	}
+	/**
+	* Close one terminal and forget it.
+	* @param request - the handle.
+	* @returns settlement, or a classified failure.
+	*/
+	async close(request) {
+		const record = this.records.get(request.terminalId);
+		if (record === void 0) return fail$1("unknown-terminal", `no panel terminal ${request.terminalId}`);
+		this.records.delete(record.id);
+		await terminateQuietly(record.handle);
+		return { ok: true };
+	}
+	/**
+	* Terminate every terminal and refuse new ones. Called from the service's teardown effect.
+	* @returns after every terminal session has settled.
+	*/
+	async disposeAll() {
+		this.closing = true;
+		const live = [...this.records.values()];
+		this.records.clear();
+		await Promise.all(live.map((record) => terminateQuietly(record.handle)));
+	}
+	/**
+	* The shell a new terminal starts: the configured one, then `$SHELL`, then the platform default.
+	* @returns an executable name or path.
+	*/
+	shell() {
+		const configured = this.source().terminalShell.trim();
+		if (configured !== "") return configured;
+		if (process.platform === "win32") return process.env.COMSPEC ?? "powershell.exe";
+		const login = process.env.SHELL;
+		return login !== void 0 && login !== "" ? login : "/bin/sh";
+	}
+	/**
+	* Drain one terminal's output into its retained scrollback and record its settlement.
+	*
+	* Attached at allocation rather than at first read: a shell prints its prompt immediately, and a
+	* stream nobody is reading would otherwise apply backpressure until the panel polled.
+	* @param record - the freshly registered terminal.
+	*/
+	collect(record) {
+		const decoder = new TextDecoder("utf-8", { fatal: false });
+		record.handle.output.on("data", (chunk) => {
+			const text = typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+			if (text === "") return;
+			record.buffer += text;
+			const max = Math.max(this.source().terminalScrollback, 1024);
+			if (record.buffer.length > max) {
+				const drop = record.buffer.length - max;
+				record.base += drop;
+				record.buffer = record.buffer.slice(drop);
+			}
+		});
+		record.handle.done.then((outcome) => {
+			record.running = false;
+			record.exitCode = outcome.exitCode;
+			record.signal = outcome.signal;
+		}, (error) => {
+			record.running = false;
+			record.buffer += `\r\n[terminal transport failed: ${error instanceof Error ? error.message : String(error)}]\r\n`;
+		});
+	}
+};
+/**
+* Terminate one terminal session without letting a cleanup fault escape.
+* @param handle - the terminal to close.
+* @returns after the session tree has settled.
+*/
+async function terminateQuietly(handle) {
+	try {
+		await handle.terminate();
+	} catch {}
+}
+
+//#endregion
+//#region tsbuild/host/tasks.js
+/** Compose one classified failure. */
+function fail(code, message) {
+	return {
+		ok: false,
+		code,
+		message
+	};
+}
+/** Whether the registry still holds the record open. */
+function isLive(snapshot) {
+	return snapshot.status === "running" || snapshot.status === "stopping";
+}
+/**
+* Stops and reads background tasks on behalf of the Tasks panel. One instance serves every request
+* and retains the output it has already drained.
+*/
+var TaskController = class {
+	ctx;
+	source;
+	/** Accumulated output per job id, so a second panel open is not an empty read. */
+	collected = /* @__PURE__ */ new Map();
+	/**
+	* Tasks whose output has already been taken.
+	*
+	* `read()` is CONSUMING for a stream job and IDEMPOTENT for a final-output one, and the snapshot
+	* does not say which kind a job is. Appending every read would therefore duplicate a
+	* final-output job's text once per poll, so each task is drained exactly once — after settlement,
+	* when there is nothing further to come.
+	*/
+	drained = /* @__PURE__ */ new Set();
+	/**
+	* @param ctx - Host context carrying the optional job registry and the agent registry.
+	* @param source - reads the current settings section; called per request.
+	*/
+	constructor(ctx, source) {
+		this.ctx = ctx;
+		this.source = source;
+	}
+	/**
+	* Report what the Tasks panel may do on this Host.
+	* @returns availability plus the two per-verb permissions.
+	*/
+	describe() {
+		const settings = this.source();
+		if (this.ctx.get("jobs") === void 0) return {
+			available: false,
+			reason: "no job registry is mounted: this deployment composes no @deepseek-ai/dsh-jobs provider",
+			canKill: false,
+			canReadOutput: false
+		};
+		return {
+			available: true,
+			canKill: settings.allowTaskKill,
+			canReadOutput: settings.showTaskOutput
+		};
+	}
+	/**
+	* Stop one live task.
+	*
+	* The registry marks a killed record reported, which suppresses the completion notice its
+	* producer would otherwise open a model turn to deliver. That is the correct trade for a person
+	* pressing Stop — the work is being cancelled on their authority, not the model's — and it is why
+	* this verb is gated by `allowTaskKill` rather than always on.
+	* @param request - the owning session and the task id.
+	* @returns what the registry did, or a classified failure.
+	*/
+	async kill(request) {
+		if (!this.source().allowTaskKill) return fail("disabled", "stopping a background task is switched off in the advanced-sidebar settings");
+		const bound = this.bind(request.sessionId, request.taskId);
+		if ("failure" in bound) return bound.failure;
+		try {
+			const outcome = bound.jobs.kill(bound.id, bound.agent, "stopped from the DeepSeek Harness sidebar");
+			await this.absorb(request.sessionId, request.taskId);
+			return {
+				ok: true,
+				outcome
+			};
+		} catch (error) {
+			return fail("registry-refused", error instanceof Error ? error.message : String(error));
+		}
+	}
+	/**
+	* Read one task's output, or say why it is withheld.
+	* @param request - the owning session and the task id.
+	* @returns the accumulated output, or a classified failure.
+	*/
+	async output(request) {
+		if (!this.source().showTaskOutput) return fail("disabled", "task output is switched off in the advanced-sidebar settings");
+		const bound = this.bind(request.sessionId, request.taskId);
+		if ("failure" in bound) return bound.failure;
+		let snapshot;
+		try {
+			snapshot = bound.jobs.get(bound.id, bound.agent);
+		} catch (error) {
+			return fail("unknown-task", error instanceof Error ? error.message : String(error));
+		}
+		const retained = this.collected.get(request.taskId) ?? "";
+		if (isLive(snapshot) || !snapshot.reported) return {
+			ok: true,
+			taskId: request.taskId,
+			readable: retained !== "",
+			text: retained,
+			reason: isLive(snapshot) ? "the task is still running; its output stream belongs to the model until the task settles" : "the task has settled but its completion has not been reported to the model yet"
+		};
+		await this.absorb(request.sessionId, request.taskId);
+		return {
+			ok: true,
+			taskId: request.taskId,
+			readable: true,
+			text: this.collected.get(request.taskId) ?? ""
+		};
+	}
+	/** Drop retained output. Called from the service's teardown effect. */
+	dispose() {
+		this.collected.clear();
+		this.drained.clear();
+	}
+	/**
+	* Drain whatever the registry will still hand over and append it to the retained text.
+	* @param sessionId - the owning session.
+	* @param taskId - the task id.
+	*/
+	async absorb(sessionId, taskId) {
+		if (this.drained.has(taskId)) return;
+		const bound = this.bind(sessionId, taskId);
+		if ("failure" in bound) return;
+		this.drained.add(taskId);
+		try {
+			const read = bound.jobs.read(bound.id, bound.agent);
+			if (read.text !== "") this.collected.set(taskId, (this.collected.get(taskId) ?? "") + read.text);
+		} catch {}
+		await Promise.resolve();
+	}
+	/**
+	* Resolve the registry, the owning agent, and the branded job id together.
+	* @param sessionId - the owning session, as the browser spelled it.
+	* @param taskId - the task id, as the browser spelled it.
+	* @returns the bound handles, or the failure to return.
+	*/
+	bind(sessionId, taskId) {
+		const jobs = this.ctx.get("jobs");
+		if (jobs === void 0) return { failure: fail("no-registry", "no job registry is mounted") };
+		const agent = this.ctx.agents.get(sessionId);
+		if (agent === void 0) return { failure: fail("unknown-session", `no live agent answers for session ${sessionId}`) };
+		return {
+			jobs,
+			agent,
+			id: JobId(taskId)
+		};
+	}
+};
+
+//#endregion
+//#region tsbuild/host/index.js
+/**
+* The advanced-sidebar plugin's node half: one Remote namespace serving every operation the browser
+* structurally cannot perform, plus the `advanced-sidebar` settings section both halves address.
+*
+* What is here and what is not follows one rule — the Host owns only what a browser cannot do. The
+* session list, the workspace list, the background-task list, archiving, and directory listing all
+* already reach the Web Client through capabilities it holds, so this endpoint adds no second copy
+* of any of them. It answers for git (a subprocess), panel terminals (a pseudo-terminal), file
+* previews (a filesystem read), external applications (a launch), stopping a background task
+* (an owner-fenced registry), and deletion (a durable artifact).
+*
+* Nothing here is model-facing: no tool, no prompt section, no session event. Every result is a
+* discriminated value rather than a throw, because the RPC gateway erases a business exception's
+* classification and each panel's next move depends on which class it was.
+* @module @achasoft/dsh-advanced-sidebar/host
+*/
+var __runInitializers = void 0 && (void 0).__runInitializers || function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = void 0 && (void 0).__esDecorate || function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
+		else descriptor[key] = _;
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/**
+* The settings namespace both halves address; the browser card joins the plugin tab on it.
+*
+* Kebab-case, unlike the Remote namespace below: a settings namespace is a kebab-case grammar the
+* Host validates, while a Remote namespace is read as `ctx.remote.advancedSidebar.…` and so must be
+* an identifier.
+*/
+const ADVANCED_SIDEBAR_SETTINGS_NAMESPACE = settingsNamespace("advanced-sidebar");
+/** An Open in target id must be usable in a menu and on the wire. */
+const TARGET_ID_PATTERN = /^[a-z][a-z0-9-]*$/u;
+/**
+* Reject a section this service could not act on, for the constraints the schema cannot express.
+*
+* Called from the constructor as well as from the settings hook: the settings seam is optional, so
+* a composition without it never runs the hook — and these constraints come straight off the
+* composition file, where being wrong is a load-time mistake rather than a running deployment.
+* @param value - the resolved section, schema-valid by construction.
+*/
+function validateConfig(value) {
+	const seen = new Set(["reveal"]);
+	for (const editor of value.editors) {
+		if (!TARGET_ID_PATTERN.test(editor.id)) throw new TypeError(`advanced-sidebar: editor id "${editor.id}" must match ${String(TARGET_ID_PATTERN)}`);
+		if (seen.has(editor.id)) throw new TypeError(`advanced-sidebar: editor id "${editor.id}" is used twice (or collides with the built-in file-manager target)`);
+		seen.add(editor.id);
+		if (editor.command.trim() === "") throw new TypeError(`advanced-sidebar: editor "${editor.id}" has an empty command`);
+	}
+	const names = /* @__PURE__ */ new Set();
+	for (const preview of value.previews) {
+		if (preview.name.trim() === "") throw new TypeError("advanced-sidebar: a preview row has an empty name");
+		if (names.has(preview.name)) throw new TypeError(`advanced-sidebar: preview name "${preview.name}" is used twice`);
+		names.add(preview.name);
+		if (preview.runtimeExecutable === "" && preview.url === "" && preview.port <= 0) throw new TypeError(`advanced-sidebar: preview "${preview.name}" names no command, no url, and no port, so there is nothing to start and nowhere to point the frame`);
+	}
+	if (value.deleteMode === "purge" && !value.confirmDelete) throw new TypeError("advanced-sidebar: deleteMode \"purge\" removes a session log irreversibly, so confirmDelete cannot be false");
+}
+/** Schemastery shape of one preview launch row. */
+const PreviewSchema = z.object({
+	name: z.string().required(),
+	runtimeExecutable: z.string().required(),
+	runtimeArgs: z.array(z.string()).required(),
+	port: z.number().step(1).min(0).max(65535).required(),
+	url: z.string().required(),
+	cwd: z.string().required()
+});
+/** Schemastery shape of one Open in target row. */
+const EditorSchema = z.object({
+	id: z.string().required(),
+	label: z.string().required(),
+	command: z.string().required(),
+	args: z.array(z.string()).required()
+});
+/** Host endpoint for the sidebar's advanced operations, and owner of the settings section. */
+let AdvancedSidebarService = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _describe_decorators;
+	let _gitStatus_decorators;
+	let _gitDiff_decorators;
+	let _gitStage_decorators;
+	let _gitUnstage_decorators;
+	let _gitCommit_decorators;
+	let _gitPush_decorators;
+	let _gitCommitMessage_decorators;
+	let _terminalOpen_decorators;
+	let _terminalRead_decorators;
+	let _terminalWrite_decorators;
+	let _terminalSignal_decorators;
+	let _terminalClose_decorators;
+	let _listEntries_decorators;
+	let _previewList_decorators;
+	let _previewStart_decorators;
+	let _previewStop_decorators;
+	let _previewLogs_decorators;
+	let _readFile_decorators;
+	let _openIn_decorators;
+	let _taskKill_decorators;
+	let _taskOutput_decorators;
+	let _deleteSession_decorators;
+	return class AdvancedSidebarService$1 extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_describe_decorators = [Remote("describe")];
+			_gitStatus_decorators = [Remote("gitStatus")];
+			_gitDiff_decorators = [Remote("gitDiff")];
+			_gitStage_decorators = [Remote("gitStage")];
+			_gitUnstage_decorators = [Remote("gitUnstage")];
+			_gitCommit_decorators = [Remote("gitCommit")];
+			_gitPush_decorators = [Remote("gitPush")];
+			_gitCommitMessage_decorators = [Remote("gitCommitMessage")];
+			_terminalOpen_decorators = [Remote("terminalOpen")];
+			_terminalRead_decorators = [Remote("terminalRead")];
+			_terminalWrite_decorators = [Remote("terminalWrite")];
+			_terminalSignal_decorators = [Remote("terminalSignal")];
+			_terminalClose_decorators = [Remote("terminalClose")];
+			_listEntries_decorators = [Remote("listEntries")];
+			_previewList_decorators = [Remote("previewList")];
+			_previewStart_decorators = [Remote("previewStart")];
+			_previewStop_decorators = [Remote("previewStop")];
+			_previewLogs_decorators = [Remote("previewLogs")];
+			_readFile_decorators = [Remote("readFile")];
+			_openIn_decorators = [Remote("openIn")];
+			_taskKill_decorators = [Remote("taskKill")];
+			_taskOutput_decorators = [Remote("taskOutput")];
+			_deleteSession_decorators = [Remote("deleteSession")];
+			__esDecorate(this, null, _describe_decorators, {
+				kind: "method",
+				name: "describe",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "describe" in obj,
+					get: (obj) => obj.describe
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _gitStatus_decorators, {
+				kind: "method",
+				name: "gitStatus",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "gitStatus" in obj,
+					get: (obj) => obj.gitStatus
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _gitDiff_decorators, {
+				kind: "method",
+				name: "gitDiff",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "gitDiff" in obj,
+					get: (obj) => obj.gitDiff
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _gitStage_decorators, {
+				kind: "method",
+				name: "gitStage",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "gitStage" in obj,
+					get: (obj) => obj.gitStage
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _gitUnstage_decorators, {
+				kind: "method",
+				name: "gitUnstage",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "gitUnstage" in obj,
+					get: (obj) => obj.gitUnstage
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _gitCommit_decorators, {
+				kind: "method",
+				name: "gitCommit",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "gitCommit" in obj,
+					get: (obj) => obj.gitCommit
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _gitPush_decorators, {
+				kind: "method",
+				name: "gitPush",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "gitPush" in obj,
+					get: (obj) => obj.gitPush
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _gitCommitMessage_decorators, {
+				kind: "method",
+				name: "gitCommitMessage",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "gitCommitMessage" in obj,
+					get: (obj) => obj.gitCommitMessage
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _terminalOpen_decorators, {
+				kind: "method",
+				name: "terminalOpen",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "terminalOpen" in obj,
+					get: (obj) => obj.terminalOpen
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _terminalRead_decorators, {
+				kind: "method",
+				name: "terminalRead",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "terminalRead" in obj,
+					get: (obj) => obj.terminalRead
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _terminalWrite_decorators, {
+				kind: "method",
+				name: "terminalWrite",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "terminalWrite" in obj,
+					get: (obj) => obj.terminalWrite
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _terminalSignal_decorators, {
+				kind: "method",
+				name: "terminalSignal",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "terminalSignal" in obj,
+					get: (obj) => obj.terminalSignal
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _terminalClose_decorators, {
+				kind: "method",
+				name: "terminalClose",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "terminalClose" in obj,
+					get: (obj) => obj.terminalClose
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listEntries_decorators, {
+				kind: "method",
+				name: "listEntries",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listEntries" in obj,
+					get: (obj) => obj.listEntries
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _previewList_decorators, {
+				kind: "method",
+				name: "previewList",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "previewList" in obj,
+					get: (obj) => obj.previewList
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _previewStart_decorators, {
+				kind: "method",
+				name: "previewStart",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "previewStart" in obj,
+					get: (obj) => obj.previewStart
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _previewStop_decorators, {
+				kind: "method",
+				name: "previewStop",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "previewStop" in obj,
+					get: (obj) => obj.previewStop
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _previewLogs_decorators, {
+				kind: "method",
+				name: "previewLogs",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "previewLogs" in obj,
+					get: (obj) => obj.previewLogs
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _readFile_decorators, {
+				kind: "method",
+				name: "readFile",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "readFile" in obj,
+					get: (obj) => obj.readFile
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _openIn_decorators, {
+				kind: "method",
+				name: "openIn",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "openIn" in obj,
+					get: (obj) => obj.openIn
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _taskKill_decorators, {
+				kind: "method",
+				name: "taskKill",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "taskKill" in obj,
+					get: (obj) => obj.taskKill
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _taskOutput_decorators, {
+				kind: "method",
+				name: "taskOutput",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "taskOutput" in obj,
+					get: (obj) => obj.taskOutput
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _deleteSession_decorators, {
+				kind: "method",
+				name: "deleteSession",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "deleteSession" in obj,
+					get: (obj) => obj.deleteSession
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		/** Loader validation for every deployment-varying choice this plugin makes. */
+		static Config = z.object({
+			showInSessionHeader: z.boolean().required(),
+			showChanges: z.boolean().required(),
+			showTerminal: z.boolean().required(),
+			showFiles: z.boolean().required(),
+			showTasks: z.boolean().required(),
+			showOpenIn: z.boolean().required(),
+			showArchive: z.boolean().required(),
+			showDelete: z.boolean().required(),
+			showPreview: z.boolean().required(),
+			panelWidth: z.number().step(1).min(280).max(1400).required(),
+			confirmDelete: z.boolean().required(),
+			deleteMode: z.union(["archive", "purge"]).required(),
+			allowTaskKill: z.boolean().required(),
+			showTaskOutput: z.boolean().required(),
+			gitMaxFiles: z.number().step(1).min(1).max(1e4).required(),
+			gitDiffMaxBytes: z.number().step(1).min(1024).max(16 * 1024 * 1024).required(),
+			gitTimeoutMs: z.number().step(1).min(1e3).max(6e5).required(),
+			gitCommitTimeoutMs: z.number().step(1).min(1e3).max(18e5).required(),
+			allowGitStaging: z.boolean().required(),
+			allowGitCommit: z.boolean().required(),
+			allowGitPush: z.boolean().required(),
+			gitPushTimeoutMs: z.number().step(1).min(1e3).max(18e5).required(),
+			allowCommitMessageDraft: z.boolean().required(),
+			commitMessagePrompt: z.string(),
+			commitMessageMaxBytes: z.number().step(1).min(1024).max(4 * 1024 * 1024).required(),
+			terminalShell: z.string(),
+			terminalScrollback: z.number().step(1).min(1024).max(4 * 1024 * 1024).required(),
+			maxTerminals: z.number().step(1).min(1).max(32).required(),
+			terminalGraceMs: z.number().step(1).min(100).max(6e4).required(),
+			filesMaxPreviewBytes: z.number().step(1).min(1024).max(16 * 1024 * 1024).required(),
+			filesMaxEntries: z.number().step(1).min(1).max(2e4).required(),
+			filesShowHidden: z.boolean().required(),
+			editors: z.array(EditorSchema).required(),
+			previews: z.array(PreviewSchema).required(),
+			previewsFromLaunchFile: z.boolean().required(),
+			maxPreviews: z.number().step(1).min(1).max(16).required(),
+			previewReadyTimeoutMs: z.number().step(1).min(1e3).max(6e5).required(),
+			previewScrollback: z.number().step(1).min(1024).max(4 * 1024 * 1024).required(),
+			previewGraceMs: z.number().step(1).min(100).max(6e4).required()
+		});
+		source = __runInitializers(this, _instanceExtraInitializers);
+		git;
+		terminals;
+		launcher;
+		files;
+		tasks;
+		deleter;
+		preview;
+		/**
+		* @param ctx - Host context; every capability this service uses is resolved optionally, so a
+		* deployment missing one still serves a view that explains which panel is dark and why.
+		* @param config - the composition-layer preferences, used as the section's base layer.
+		*/
+		constructor(ctx, config) {
+			super(ctx, "advancedSidebar");
+			validateConfig(config);
+			this.source = () => config;
+			const read = () => this.source();
+			this.git = new GitReader(ctx, read);
+			this.terminals = new PanelTerminals(ctx, read);
+			this.launcher = new OpenInLauncher(ctx, read);
+			this.files = new FileReader(ctx, read);
+			this.tasks = new TaskController(ctx, read);
+			this.deleter = new SessionDeleter(ctx, read);
+			this.preview = new PreviewServers(ctx, read);
+			installSettingsSection(ctx, ADVANCED_SIDEBAR_SETTINGS_NAMESPACE, AdvancedSidebarService$1.Config, config, {
+				setSource: (current) => {
+					this.source = current;
+				},
+				onChange: () => {
+					this.launcher.forget();
+				},
+				validate: validateConfig
+			});
+			ctx.effect(() => async () => {
+				this.tasks.dispose();
+				await Promise.all([this.terminals.disposeAll(), this.preview.disposeAll()]);
+			}, "advanced-sidebar: panel terminals, preview servers, retained task output");
+		}
+		/**
+		* Describe which operations this Host can serve, so the menu can disable an entry with a reason
+		* instead of offering one that fails when it is pressed.
+		* @param signal - gateway-supplied cancellation for the executable probes.
+		* @returns the capability view.
+		*/
+		async describe(signal) {
+			const settings = this.source();
+			const deletion = this.deleter.describe();
+			return {
+				git: await this.git.describe(signal),
+				terminal: this.terminals.describe(),
+				files: this.files.describe(),
+				preview: this.preview.describe(),
+				tasks: this.tasks.describe(),
+				openIn: await this.launcher.describe(signal),
+				settings,
+				deletion: {
+					canPurge: deletion.canPurge,
+					mode: settings.deleteMode === "purge" && deletion.canPurge ? "purge" : "archive",
+					...deletion.reason === void 0 ? {} : { reason: deletion.reason }
+				},
+				readAt: Date.now()
+			};
+		}
+		/**
+		* Read one workspace's git status.
+		* @param request - the workspace directory.
+		* @param signal - gateway-supplied cancellation for the caller's abandoned request.
+		* @returns the reading, or a classified failure.
+		*/
+		gitStatus(request, signal) {
+			return this.git.status(request, signal);
+		}
+		/**
+		* Read one path's patch.
+		* @param request - the path and which index to compare.
+		* @param signal - gateway-supplied cancellation for the caller's abandoned request.
+		* @returns the patch, or a classified failure.
+		*/
+		gitDiff(request, signal) {
+			return this.git.diff(request, signal);
+		}
+		/**
+		* Stage paths into the index.
+		* @param request - the workspace and the repository-relative paths.
+		* @param signal - gateway-supplied cancellation for the caller's abandoned request.
+		* @returns the reading after the write, or a classified failure.
+		*/
+		gitStage(request, signal) {
+			return this.git.stage(request, signal);
+		}
+		/**
+		* Take paths back out of the index, leaving the working tree alone.
+		* @param request - the workspace and the repository-relative paths.
+		* @param signal - gateway-supplied cancellation for the caller's abandoned request.
+		* @returns the reading after the write, or a classified failure.
+		*/
+		gitUnstage(request, signal) {
+			return this.git.unstage(request, signal);
+		}
+		/**
+		* Record the staged changes.
+		* @param request - the workspace, the message, and whether to amend.
+		* @param signal - gateway-supplied cancellation; hooks run under `gitCommitTimeoutMs`.
+		* @returns the new commit and the reading after it, or a classified failure.
+		*/
+		gitCommit(request, signal) {
+			return this.git.commit(request, signal);
+		}
+		/**
+		* Send the current branch's commits to its remote.
+		* @param request - the workspace, and whether an unpublished branch may be published.
+		* @param signal - gateway-supplied cancellation; the network wait runs under `gitPushTimeoutMs`.
+		* @returns the push and the reading after it, or a classified failure.
+		*/
+		gitPush(request, signal) {
+			return this.git.push(request, signal);
+		}
+		/**
+		* Ask the deployment's own model to write a commit message for what is staged.
+		* @param request - the workspace, and whether the message is for an amend.
+		* @param signal - gateway-supplied cancellation for the readings and the model call.
+		* @returns the drafted message, or a classified failure.
+		*/
+		gitCommitMessage(request, signal) {
+			return this.git.draftCommitMessage(request, signal);
+		}
+		/**
+		* Allocate a panel terminal.
+		* @param request - the workspace directory and the panel's measured geometry.
+		* @param signal - gateway-supplied cancellation of the allocation.
+		* @returns the handle, or a classified failure.
+		*/
+		terminalOpen(request, signal) {
+			return this.terminals.open(request, signal);
+		}
+		/**
+		* Read a panel terminal's output from a caller-owned offset.
+		* @param request - the handle and the offset already rendered.
+		* @returns the delta and the process state, or a classified failure.
+		*/
+		terminalRead(request) {
+			return Promise.resolve(this.terminals.read(request));
+		}
+		/**
+		* Send keystrokes to a panel terminal.
+		* @param request - the handle and the text to deliver verbatim.
+		* @returns settlement, or a classified failure.
+		*/
+		terminalWrite(request) {
+			return this.terminals.write(request);
+		}
+		/**
+		* Deliver a signal to a panel terminal's foreground process group.
+		* @param request - the handle and the signal.
+		* @returns settlement, or a classified failure.
+		*/
+		terminalSignal(request) {
+			return this.terminals.signal(request);
+		}
+		/**
+		* Close a panel terminal.
+		* @param request - the handle.
+		* @returns settlement, or a classified failure.
+		*/
+		terminalClose(request) {
+			return this.terminals.close(request);
+		}
+		/**
+		* List one directory level for the Files panel.
+		* @param request - the directory and the workspace it must stay inside.
+		* @param signal - gateway-supplied cancellation for the caller's abandoned request.
+		* @returns the level, or a classified failure.
+		*/
+		listEntries(request, signal) {
+			return this.files.list(request, signal);
+		}
+		/**
+		* List one workspace's preview launch configurations, each with its current state.
+		* @param request - the workspace to read.
+		* @param signal - gateway-supplied cancellation for the caller's abandoned request.
+		* @returns the list, or a classified failure.
+		*/
+		previewList(request, signal) {
+			return this.preview.list(request, signal);
+		}
+		/**
+		* Start one preview configuration.
+		* @param request - the workspace and the configuration name.
+		* @param signal - gateway-supplied cancellation of the start.
+		* @returns the started row, or a classified failure.
+		*/
+		previewStart(request, signal) {
+			return this.preview.start(request, signal);
+		}
+		/**
+		* Stop one running preview server.
+		* @param request - the handle.
+		* @returns settlement, or a classified failure.
+		*/
+		previewStop(request) {
+			return this.preview.stop(request);
+		}
+		/**
+		* Read one preview server's output from a caller-owned offset, with its state at read time.
+		* @param request - the handle and the offset already rendered.
+		* @returns the delta and the state, or a classified failure.
+		*/
+		previewLogs(request) {
+			return Promise.resolve(this.preview.logs(request));
+		}
+		/**
+		* Read one file for the Files panel preview.
+		* @param request - the file and the workspace it must stay inside.
+		* @param signal - gateway-supplied cancellation for the caller's abandoned request.
+		* @returns the preview, or a classified failure.
+		*/
+		readFile(request, signal) {
+			return this.files.read(request, signal);
+		}
+		/**
+		* Hand one path to an external application or to the operating system's file manager.
+		* @param request - the target and the path.
+		* @param signal - gateway-supplied cancellation for the launch.
+		* @returns settlement, or a classified failure.
+		*/
+		openIn(request, signal) {
+			return this.launcher.open(request, signal);
+		}
+		/**
+		* Stop one live background task.
+		* @param request - the owning session and the task id.
+		* @returns what the registry did, or a classified failure.
+		*/
+		taskKill(request) {
+			return this.tasks.kill(request);
+		}
+		/**
+		* Read one settled background task's output.
+		* @param request - the owning session and the task id.
+		* @returns the accumulated output, or a classified failure.
+		*/
+		taskOutput(request) {
+			return this.tasks.output(request);
+		}
+		/**
+		* Delete one session: archive it, and remove its durable artifact when the mode and Host allow.
+		* @param request - the session to delete.
+		* @param signal - gateway-supplied cancellation for the persistence listing.
+		* @returns what was actually done, or a classified failure.
+		*/
+		deleteSession(request, signal) {
+			return this.deleter.delete(request, signal);
+		}
+	};
+})();
+var host_default = AdvancedSidebarService;
+
+//#endregion
+export { ADVANCED_SIDEBAR_SETTINGS_NAMESPACE, AdvancedSidebarService, REVEAL_TARGET_ID, host_default as default };