zidane 7.2.5 → 8.0.4

package/dist/url-D8HCl65b.js

@@ -0,0 +1,1259 @@
+import { i as styleReplacementForVia, n as resolveOldString } from "./edit-utils-EGosADZq.js";
+//#region src/chat/browser/url.ts
+/**
+* What the dev browser will load. It is a browser for the app you are
+* building, not the web at large: http(s) only, bare local addresses
+* default to http, anything that looks like a host gets https. Shared by the
+* GUI address bar and the agent's `browser_open` / `browser_navigate`.
+*/
+const LOCAL_HOST = /^(?:localhost|127(?:\.\d{1,3}){3}|0\.0\.0\.0|\[::1\]|[\w-]+\.localhost)(?::\d+)?(?:[/?#]|$)/i;
+const HOST_LIKE = /^(?:[\w-]+\.)+[a-z]{2,}(?::\d+)?(?:[/?#]|$)/i;
+const PORT_ONLY = /^:?(\d{2,5})([/?#].*)?$/;
+/** Normalize address-bar input to a loadable URL, or `null` when it is not one. */
+function normalizeBrowserUrl(input) {
+	const text = input.trim();
+	if (!text) return null;
+	const port = PORT_ONLY.exec(text);
+	if (port) return canonical(`http://localhost:${port[1]}${port[2] ?? ""}`);
+	if (/^[a-z][a-z\d+.-]*:\/\//i.test(text)) return isAllowedBrowserUrl(text) ? canonical(text) : null;
+	if (/\s/.test(text)) return null;
+	if (LOCAL_HOST.test(text)) return canonical(`http://${text}`);
+	if (HOST_LIKE.test(text)) return canonical(`https://${text}`);
+	return null;
+}
+/** Only http(s) pages (and the blank page) ever load in the dev browser. */
+function isAllowedBrowserUrl(url) {
+	if (url === "about:blank") return true;
+	try {
+		const { protocol } = new URL(url);
+		return protocol === "http:" || protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+/** A loopback address: the dev servers the browser exists for. */
+function isLocalBrowserUrl(url) {
+	try {
+		const host = new URL(url).hostname;
+		return host === "localhost" || host.endsWith(".localhost") || host === "0.0.0.0" || host === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(host);
+	} catch {
+		return false;
+	}
+}
+function canonical(url) {
+	try {
+		return new URL(url).toString();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/chat/command-notes.ts
+/** The persisted invocation header block: `` `❯ /commit args` ``. */
+function commandHeaderBlock(invocation) {
+	return `\`❯ ${invocation}\``;
+}
+/** `/name args` from a persisted header block, or null when the text is not one. */
+function parseCommandHeader(text) {
+	const match = /^`❯ (\/[\s\S]+)`$/.exec(text.trim());
+	return match ? match[1] : null;
+}
+const PREFIX_SEPARATOR = /^\s*(?:[:·—-]\s*)?/;
+/**
+* The receipt text for one note. Older displays repeat the command
+* (`/commit: 83dfea7`, `/review — 3 reviewers, fixes applied`); the prompt
+* bubble above already names it, so the prefix goes, and a leftover ` — `
+* reads as ` · `. A note without a display shows its first line.
+*/
+function commandNoteText(display, text, invocation) {
+	let line = (display ?? text.split("\n").find((l) => l.trim()) ?? "").trim();
+	const prefix = [invocation, invocation?.split(/\s/, 1)[0]].filter((p) => Boolean(p)).find((p) => line.startsWith(p)) ?? /^\/[\w.:-]+/.exec(line)?.[0];
+	if (prefix) {
+		const rest = line.slice(prefix.length).replace(PREFIX_SEPARATOR, "");
+		if (rest) line = /^[0-9a-f]{7,40}$/.test(rest) ? `committed ${rest}` : rest;
+	}
+	line = line.replace(/\s+—\s+/g, " · ");
+	return line.length > 160 ? `${line.slice(0, 159)}…` : line;
+}
+/**
+* The `display` a context note persists with: the command's marker, its
+* first line when it gave none, or `''` for a model-only note
+* (`display: false`), which shows nothing.
+*/
+function noteDisplay(display, text) {
+	return display === false ? "" : display ?? commandNoteText(void 0, text);
+}
+/** A command step label: the display as given, minus any leftover ` — `. */
+function commandStepLabel(display) {
+	return display.replace(/\s+—\s+/g, " · ");
+}
+const merged = /* @__PURE__ */ new WeakMap();
+function isTopPrompt(event) {
+	return event.kind === "user-prompt" && !event.childId && (event.depth ?? 0) === 0;
+}
+/**
+* One receipt line per exchange: every `command-note` in an exchange moves
+* to its end and joins into a single event (`committed 83dfea7 · pushed to
+* origin/main`). Returns `events` itself when there is nothing to merge;
+* the merged event keeps its identity while its notes do not change, so
+* memoised rows stay put.
+*/
+function gatherCommandNotes(events) {
+	if (!events.some((e) => e.kind === "command-note")) return events;
+	const out = [];
+	let notes = [];
+	const flush = () => {
+		if (notes.length === 0) return;
+		const first = notes[0];
+		const key = notes.map((n) => n.text).join("\0");
+		let event = first;
+		if (notes.length > 1) {
+			const cached = merged.get(first);
+			event = cached?.key === key ? cached.event : {
+				...first,
+				text: notes.map((n) => n.text).join(" · ")
+			};
+			merged.set(first, {
+				key,
+				event
+			});
+		}
+		let at = out.length;
+		while (at > 0 && out[at - 1].kind === "separator") at--;
+		out.splice(at, 0, event);
+		notes = [];
+	};
+	for (const event of events) {
+		if (isTopPrompt(event)) flush();
+		if (event.kind === "command-note" && !event.childId) {
+			notes.push(event);
+			continue;
+		}
+		out.push(event);
+	}
+	flush();
+	return out.length === events.length && out.every((e, i) => e === events[i]) ? events : out;
+}
+//#endregion
+//#region src/chat/edit-approval.ts
+/**
+* Convert a per-hunk approval mask into an `EditOutcome[]`. `true` →
+* `applied`; `false` → `denied` with the supplied reason.
+*
+* Length is `Math.max(mask.length, fallbackLength)` so callers passing a
+* shorter mask still get a fully-populated array — missing entries
+* default to applied, matching the "no decision => keep" convention.
+*/
+function maskToOutcomeKinds(mask, fallbackLength, deniedReason = "denied by user") {
+	const len = Math.max(mask.length, fallbackLength);
+	const out = [];
+	for (let i = 0; i < len; i++) {
+		const keep = i < mask.length ? mask[i] : true;
+		out.push(keep ? { kind: "applied" } : {
+			kind: "denied",
+			reason: deniedReason
+		});
+	}
+	return out;
+}
+function resolveApprovalForPayload(decision, payload) {
+	const total = payload.hunks.length;
+	if (decision === "deny") {
+		const outcomes = Array.from({ length: total }, () => ({
+			kind: "denied",
+			reason: "denied by user"
+		}));
+		return {
+			outcomes,
+			shouldBlock: true,
+			syntheticEvent: {
+				...payload,
+				outcomes
+			}
+		};
+	}
+	if (typeof decision === "object" && decision.kind === "partial") {
+		const outcomes = maskToOutcomeKinds(decision.mask, total);
+		return {
+			outcomes,
+			shouldBlock: !outcomes.some((o) => o.kind === "applied"),
+			syntheticEvent: {
+				...payload,
+				outcomes
+			}
+		};
+	}
+	return {
+		outcomes: Array.from({ length: total }, () => ({ kind: "applied" })),
+		shouldBlock: false,
+		syntheticEvent: null
+	};
+}
+/** Sentinel tags used by {@link buildEditOutcomesAnnotation} / parser. */
+const ANNOTATION_OPEN = "<edit-outcomes>";
+const ANNOTATION_CLOSE = "</edit-outcomes>";
+const OUTCOME_KIND_RE = /^applied|denied|skipped|failed$/;
+const OUTCOME_LINE_RE = /^#(\d+) (applied|denied|skipped|failed)(?:: ?(.*))?$/;
+/**
+* Render an `EditOutcome[]` as the wire-format annotation block. Returns
+* the body to APPEND to a tool result; callers join with a leading
+* `\n\n` separator. Idempotent on missing reasons — bare `applied` lines
+* stay terse.
+*/
+function buildEditOutcomesAnnotation(outcomes) {
+	const lines = [ANNOTATION_OPEN];
+	for (let i = 0; i < outcomes.length; i++) {
+		const o = outcomes[i];
+		if (!OUTCOME_KIND_RE.test(o.kind)) continue;
+		const reason = o.reason ? `: ${o.reason}` : "";
+		lines.push(`#${i + 1} ${o.kind}${reason}`);
+	}
+	lines.push(ANNOTATION_CLOSE);
+	return lines.join("\n");
+}
+/**
+* Parse an `<edit-outcomes>…</edit-outcomes>` annotation block out of a
+* tool result body. Returns the outcomes keyed by 1-based hunk index, or
+* `null` when the block is missing / malformed.
+*
+* Anchored on the explicit tag pair so the parser doesn't false-positive
+* on natural prose that happens to contain `#1 applied`.
+*/
+function parseEditOutcomesFromResult(result) {
+	const text = typeof result === "string" ? result : result.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+	if (!text) return null;
+	const openIdx = text.indexOf(`\n${ANNOTATION_OPEN}\n`);
+	const startIdx = openIdx >= 0 ? openIdx + 1 : text.startsWith(`${ANNOTATION_OPEN}\n`) ? 0 : -1;
+	if (startIdx < 0) return null;
+	const closeNeedle = `\n${ANNOTATION_CLOSE}`;
+	const closeIdx = text.indexOf(closeNeedle, startIdx);
+	if (closeIdx < 0) return null;
+	const body = text.slice(startIdx + 15 + 1, closeIdx);
+	const found = [];
+	for (const line of body.split("\n")) {
+		if (line.length === 0) continue;
+		const m = OUTCOME_LINE_RE.exec(line);
+		if (!m) return null;
+		const idx = Number.parseInt(m[1], 10);
+		if (!Number.isFinite(idx) || idx < 1) return null;
+		const kind = m[2];
+		const reason = m[3]?.trim();
+		found.push({
+			idx,
+			outcome: {
+				kind,
+				...reason ? { reason } : {}
+			}
+		});
+	}
+	if (found.length === 0) return null;
+	const maxIdx = Math.max(...found.map((f) => f.idx));
+	const outcomes = Array.from({ length: maxIdx }, () => ({ kind: "applied" }));
+	for (const { idx, outcome } of found) outcomes[idx - 1] = outcome;
+	return outcomes;
+}
+/**
+* Strip the first `<edit-outcomes>…</edit-outcomes>` block out of a tool
+* result body, returning the surrounding text. Used by the
+* `tool:transform` hook to peel a body-emitted annotation before
+* re-appending the merged (approval ∪ body) version — otherwise the
+* result would carry two annotation blocks and
+* {@link parseEditOutcomesFromResult} would only see the first.
+*
+* Anchored on the same `\n<edit-outcomes>\n` / start-of-string newline
+* shape the parser uses, so prose that incidentally mentions
+* `<edit-outcomes>` (e.g. a model summarizing its own format) isn't
+* mistakenly stripped. Trims a single leading `\n\n` separator when
+* present so successive strips don't leave dangling blank lines.
+* Idempotent on inputs that don't contain a properly-anchored block.
+*/
+function stripEditOutcomesAnnotation(text) {
+	const newlineNeedle = `\n${ANNOTATION_OPEN}\n`;
+	const newlineIdx = text.indexOf(newlineNeedle);
+	let openIdx;
+	if (newlineIdx >= 0) openIdx = newlineIdx + 1;
+	else if (text.startsWith(`${ANNOTATION_OPEN}\n`)) openIdx = 0;
+	else return text;
+	const closeIdx = text.indexOf(ANNOTATION_CLOSE, openIdx);
+	if (closeIdx < 0) return text;
+	const blockEnd = closeIdx + 16;
+	const sepStart = openIdx >= 2 && text.slice(openIdx - 2, openIdx) === "\n\n" ? openIdx - 2 : openIdx;
+	return text.slice(0, sepStart) + text.slice(blockEnd);
+}
+/**
+* Merge body-side outcomes (keyed against the approved subset the tool
+* actually ran on, in subset-position order) into approval-side outcomes
+* (1:1 with the model's ORIGINAL `edits` list, with `denied` entries for
+* every hunk the user dropped).
+*
+* Algorithm: walk the approval array; every `applied` placeholder
+* corresponds to one approved hunk that the body ran. Consume body's
+* outcomes in order against those placeholders. Non-`applied` approval
+* entries (`denied`, `skipped`) stay untouched — they describe gate-
+* level decisions the body never saw.
+*
+* Pure. Returns a fresh array; never mutates either input.
+*
+* Edge cases:
+*  - `body` is empty / shorter than the approved count → remaining
+*    approval `applied` placeholders stay as `applied` (the body ran
+*    happily; absence of a body entry means nothing failed).
+*  - `body` longer than approved count → trailing body entries are
+*    ignored. Shouldn't happen in practice (body sees the rebound
+*    subset), but the guard keeps the merge total-pure.
+*/
+function mergeApprovalAndBodyOutcomes(approval, body) {
+	if (!body || body.length === 0) return approval.slice();
+	const out = [];
+	let bi = 0;
+	for (const entry of approval) if (entry.kind === "applied" && bi < body.length) {
+		out.push(body[bi]);
+		bi++;
+	} else out.push(entry);
+	return out;
+}
+/**
+* Rewrite a `multi_edit` body header so the totals reflect the model's
+* ORIGINAL edit list (the merged outcomes count) instead of the subset
+* the body actually saw after gate rebinding. Without this, a partially
+* approved call surfaces a misleading `applied 2 of 2 edits` (subset
+* counts) on the wire even when the original was `applied 2 of 3`.
+*
+* Three body-side shapes are handled (matching `multi_edit`'s emit):
+*   1. `Edited <path>: applied N edits (R replacements).`
+*   2. `Edited <path>: applied N of M edits (R replacements).`
+*   3. `multi_edit error: no edits applied to <path> (M attempted).`
+*
+* The replacements count is preserved verbatim — it's a body-side stat
+* the chat layer can't recompute. When the first line doesn't look like
+* any of the three shapes (e.g. an unrelated error preamble bubbled up),
+* the text is returned unchanged.
+*/
+function rewriteMultiEditHeader(text, merged, path) {
+	const newlineIdx = text.indexOf("\n");
+	const firstLine = newlineIdx < 0 ? text : text.slice(0, newlineIdx);
+	const rest = newlineIdx < 0 ? "" : text.slice(newlineIdx);
+	const successMatch = firstLine.match(/^Edited .+: applied \d+(?: of \d+)? edits? \((\d+) replacement/);
+	const isFailedShape = firstLine.startsWith("multi_edit error: no edits applied to ") && firstLine.endsWith(" attempted).");
+	if (!successMatch && !isFailedShape) return text;
+	const replacements = successMatch ? Number.parseInt(successMatch[1], 10) || 0 : 0;
+	const applied = summarizeOutcomes(merged).applied;
+	const total = merged.length;
+	let newHeader;
+	if (applied === total) newHeader = `Edited ${path}: applied ${total} edit${total === 1 ? "" : "s"} (${replacements} replacement${replacements === 1 ? "" : "s"}).`;
+	else if (applied > 0) newHeader = `Edited ${path}: applied ${applied} of ${total} edits (${replacements} replacement${replacements === 1 ? "" : "s"}).`;
+	else newHeader = `multi_edit error: no edits applied to ${path} (${total} attempted).`;
+	return newHeader + rest;
+}
+/**
+* Aggregate counts for the transcript's summary badge (`3 applied · 1
+* denied · 1 skipped`). Exported so renderers don't reimplement the
+* tally. Pure / O(n).
+*/
+function summarizeOutcomes(outcomes) {
+	const counts = {
+		applied: 0,
+		denied: 0,
+		skipped: 0,
+		failed: 0,
+		pending: 0
+	};
+	if (!outcomes) return {
+		...counts,
+		total: 0
+	};
+	for (const o of outcomes) counts[o.kind] += 1;
+	return {
+		...counts,
+		total: outcomes.length
+	};
+}
+//#endregion
+//#region src/chat/edit-diff.ts
+function extractEditPayload(name, input, priorContent) {
+	const path = input.path;
+	if (typeof path !== "string" || path === "") return void 0;
+	if (name === "edit") {
+		const oldString = input.old_string;
+		const newString = input.new_string;
+		if (typeof oldString !== "string" || typeof newString !== "string") return void 0;
+		return {
+			tool: "edit",
+			path,
+			hunks: [{
+				oldString,
+				newString,
+				...input.replace_all === true ? { replaceAll: true } : {}
+			}],
+			...priorContent !== void 0 ? { priorContent } : {}
+		};
+	}
+	if (name === "multi_edit") {
+		const steps = input.edits;
+		if (!Array.isArray(steps) || steps.length === 0) return void 0;
+		const hunks = [];
+		for (const raw of steps) {
+			if (typeof raw?.old_string !== "string" || typeof raw?.new_string !== "string") return void 0;
+			hunks.push({
+				oldString: raw.old_string,
+				newString: raw.new_string,
+				...raw.replace_all === true ? { replaceAll: true } : {}
+			});
+		}
+		return {
+			tool: "multi_edit",
+			path,
+			hunks,
+			...priorContent !== void 0 ? { priorContent } : {}
+		};
+	}
+	if (name === "write_file") {
+		const content = input.content;
+		if (typeof content !== "string") return void 0;
+		return {
+			tool: "write_file",
+			path,
+			hunks: [{
+				oldString: priorContent ?? "",
+				newString: content
+			}],
+			...priorContent !== void 0 ? { priorContent } : {}
+		};
+	}
+}
+/**
+* LCS table cell budget shared by the line- and token-level diffs. 4M
+* cells ≈ low tens of MB of `number[]` rows — imperceptible — while
+* anything needing more (multi-thousand-line change cores) wouldn't
+* produce a human-readable minimal diff anyway.
+*/
+const LCS_CELL_BUDGET = 4e6;
+function computeLineDiff(oldString, newString) {
+	const oldLines = splitLines(oldString);
+	const newLines = splitLines(newString);
+	let lo = 0;
+	while (lo < oldLines.length && lo < newLines.length && oldLines[lo] === newLines[lo]) lo++;
+	let oldHi = oldLines.length;
+	let newHi = newLines.length;
+	while (oldHi > lo && newHi > lo && oldLines[oldHi - 1] === newLines[newHi - 1]) {
+		oldHi--;
+		newHi--;
+	}
+	const out = [];
+	for (let k = 0; k < lo; k++) out.push({
+		op: "context",
+		text: oldLines[k]
+	});
+	const n = oldHi - lo;
+	const m = newHi - lo;
+	if ((n + 1) * (m + 1) > LCS_CELL_BUDGET) {
+		for (let k = lo; k < oldHi; k++) out.push({
+			op: "remove",
+			text: oldLines[k]
+		});
+		for (let k = lo; k < newHi; k++) out.push({
+			op: "add",
+			text: newLines[k]
+		});
+	} else if (n > 0 || m > 0) appendLcsDiff(out, oldLines, newLines, lo, oldHi, newHi);
+	for (let k = oldHi; k < oldLines.length; k++) out.push({
+		op: "context",
+		text: oldLines[k]
+	});
+	return out;
+}
+/**
+* The classic LCS table + reverse walk over `old[lo..oldHi) ×
+* new[lo..newHi)`, appending ops to `out` in forward order. Diagonals at
+* equal lines → context; otherwise step into the higher of (up, left)
+* and emit remove/add respectively. Ties break so adjacent remove/add
+* pairs stay grouped (the intra-line highlighter pairs them up).
+*/
+function appendLcsDiff(out, oldLines, newLines, lo, oldHi, newHi) {
+	const n = oldHi - lo;
+	const m = newHi - lo;
+	const lcs = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }).fill(0));
+	for (let i = 0; i < n; i++) for (let j = 0; j < m; j++) lcs[i + 1][j + 1] = oldLines[lo + i] === newLines[lo + j] ? lcs[i][j] + 1 : Math.max(lcs[i][j + 1], lcs[i + 1][j]);
+	const core = [];
+	let i = n;
+	let j = m;
+	while (i > 0 || j > 0) {
+		if (i > 0 && j > 0 && oldLines[lo + i - 1] === newLines[lo + j - 1]) {
+			core.push({
+				op: "context",
+				text: oldLines[lo + i - 1]
+			});
+			i--;
+			j--;
+			continue;
+		}
+		if (j > 0 && (i === 0 || lcs[i][j - 1] >= lcs[i - 1][j])) {
+			core.push({
+				op: "add",
+				text: newLines[lo + j - 1]
+			});
+			j--;
+			continue;
+		}
+		core.push({
+			op: "remove",
+			text: oldLines[lo + i - 1]
+		});
+		i--;
+	}
+	core.reverse();
+	out.push(...core);
+}
+/**
+* Split a string into lines preserving empty lines but dropping the
+* implicit trailing `""` produced by a final `\n`. Exported only for
+* its tests — callers should use `computeLineDiff`.
+*/
+function splitLines(s) {
+	if (s === "") return [];
+	const parts = s.split("\n");
+	if (parts[parts.length - 1] === "") parts.pop();
+	return parts;
+}
+function computeInlineDiff(oldLine, newLine) {
+	const oldTokens = tokenize(oldLine);
+	const newTokens = tokenize(newLine);
+	const n = oldTokens.length;
+	const m = newTokens.length;
+	if ((n + 1) * (m + 1) > LCS_CELL_BUDGET) return {
+		oldSegments: oldLine === "" ? [] : [{
+			text: oldLine,
+			changed: true
+		}],
+		newSegments: newLine === "" ? [] : [{
+			text: newLine,
+			changed: true
+		}]
+	};
+	const lcs = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }).fill(0));
+	for (let i = 0; i < n; i++) for (let j = 0; j < m; j++) lcs[i + 1][j + 1] = oldTokens[i] === newTokens[j] ? lcs[i][j] + 1 : Math.max(lcs[i][j + 1], lcs[i + 1][j]);
+	const oldSegments = [];
+	const newSegments = [];
+	let i = n;
+	let j = m;
+	while (i > 0 || j > 0) {
+		if (i > 0 && j > 0 && oldTokens[i - 1] === newTokens[j - 1]) {
+			pushSegment(oldSegments, {
+				text: oldTokens[i - 1],
+				changed: false
+			});
+			pushSegment(newSegments, {
+				text: newTokens[j - 1],
+				changed: false
+			});
+			i--;
+			j--;
+			continue;
+		}
+		if (j > 0 && (i === 0 || lcs[i][j - 1] >= lcs[i - 1][j])) {
+			pushSegment(newSegments, {
+				text: newTokens[j - 1],
+				changed: true
+			});
+			j--;
+			continue;
+		}
+		pushSegment(oldSegments, {
+			text: oldTokens[i - 1],
+			changed: true
+		});
+		i--;
+	}
+	oldSegments.reverse();
+	newSegments.reverse();
+	return {
+		oldSegments,
+		newSegments
+	};
+}
+/**
+* Coalesce adjacent same-state segments so the renderer emits one
+* `<span>` per run instead of one per token — keeps the React tree
+* shallow on dense lines without changing the visual output.
+*
+* Walking direction is reverse (we push during the reverse walk, then
+* the caller reverses the array), so we coalesce against the *tail*.
+*/
+function pushSegment(buf, seg) {
+	const tail = buf[buf.length - 1];
+	if (tail && tail.changed === seg.changed) tail.text = seg.text + tail.text;
+	else buf.push(seg);
+}
+/**
+* Tokenize on word / non-word boundaries. Each run of `\w+` is one
+* token; each run of `\W+` (whitespace, punctuation) is another. This
+* gives the right granularity for renames (`oldName` → `newName`) and
+* for symbol swaps (`+ → -`) without exploding into per-char segments.
+*
+* Exported only for its tests.
+*/
+function tokenize(s) {
+	if (s === "") return [];
+	const out = [];
+	for (const match of s.matchAll(/\w+|\W+/g)) out.push(match[0]);
+	return out;
+}
+/**
+* Apply the payload's hunks against `priorContent` and return the
+* resulting file body. Mirrors the agent's tool-side semantics:
+*   - `replaceAll === true`  → `String.replaceAll`
+*   - otherwise              → first-occurrence `String.replace`
+*
+* Hunks are applied in order — a `multi_edit` later hunk operates on
+* the output of the earlier ones, just like the actual tool.
+*/
+function applyEditPayload(payload, priorContent) {
+	let out = priorContent;
+	for (const hunk of payload.hunks) out = hunk.replaceAll ? out.replaceAll(hunk.oldString, hunk.newString) : out.replace(hunk.oldString, hunk.newString);
+	return out;
+}
+/**
+* Like `buildUnifiedDiff` but operating against the full file content
+* so the diff carries *real* file line numbers and configurable
+* surrounding context.
+*
+* Strategy:
+*   1. Apply the payload to `priorContent` → `newContent`.
+*   2. Run `computeLineDiff` over the whole file.
+*   3. Group non-context ops into hunks, padding each with up to
+*      `contextLines` of context above and below. Adjacent hunks
+*      whose context regions touch are merged so we don't emit two
+*      `@@` headers separated by zero context lines.
+*
+* The output line numbers in the `@@` header are 1-based and reflect
+* the change's position in the actual file — what the user expects
+* when reading a diff alongside their editor.
+*
+* For `write_file` creating a new file (priorContent === ''), this
+* falls back to the same `--- /dev/null` convention as
+* `buildUnifiedDiff`.
+*/
+function buildContextualDiff(payload, priorContent, contextLines = 3) {
+	const newContent = applyEditPayload(payload, priorContent);
+	const isNewFile = priorContent === "";
+	const ops = computeLineDiff(priorContent, newContent);
+	const oldLineFor = [];
+	const newLineFor = [];
+	let ol = 1;
+	let nl = 1;
+	for (const op of ops) {
+		oldLineFor.push(ol);
+		newLineFor.push(nl);
+		if (op.op !== "add") ol++;
+		if (op.op !== "remove") nl++;
+	}
+	const hunks = [];
+	for (let i = 0; i < ops.length; i++) {
+		if (ops[i].op === "context") continue;
+		const start = Math.max(0, i - contextLines);
+		const end = Math.min(ops.length - 1, i + contextLines);
+		const last = hunks[hunks.length - 1];
+		if (last && start <= last[1] + 1) last[1] = Math.max(last[1], end);
+		else hunks.push([start, end]);
+	}
+	if (hunks.length === 0) return "";
+	const parts = [];
+	parts.push(isNewFile ? "--- /dev/null" : `--- a/${payload.path}`);
+	parts.push(`+++ b/${payload.path}`);
+	for (const [start, end] of hunks) {
+		const slice = ops.slice(start, end + 1);
+		const oldCount = slice.filter((l) => l.op !== "add").length;
+		const newCount = slice.filter((l) => l.op !== "remove").length;
+		const oldStart = oldCount === 0 ? Math.max(0, oldLineFor[start] - 1) : oldLineFor[start];
+		const newStart = newCount === 0 ? Math.max(0, newLineFor[start] - 1) : newLineFor[start];
+		parts.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+		for (const line of slice) {
+			const prefix = line.op === "add" ? "+" : line.op === "remove" ? "-" : " ";
+			parts.push(`${prefix}${line.text}`);
+		}
+	}
+	return `${parts.join("\n")}\n`;
+}
+/**
+* Build a per-hunk digest used by the compact diff view.
+*
+* Strategy:
+*  - When `priorContent` is present and the payload describes a real
+*    file transformation, compute the contextual diff once, then walk
+*    the LCS ops splitting at runs of `add` / `remove` to anchor each
+*    summary entry to the **real** file line. This guarantees the
+*    summary's `L<n>` matches what the user sees in their editor.
+*  - Otherwise, fall back to per-hunk LCS over the (oldString,
+*    newString) snippet pair. Line numbers are absent because the
+*    snippet has no file position.
+*/
+function summarizeEditPayload(payload) {
+	const prior = payload.priorContent;
+	if (prior !== void 0) return summarizeOpsByHunk(computeLineDiff(prior, applyEditPayload(payload, prior)));
+	const hunks = [];
+	let totalAdded = 0;
+	let totalRemoved = 0;
+	for (const hunk of payload.hunks) {
+		const ops = computeLineDiff(hunk.oldString, hunk.newString);
+		let added = 0;
+		let removed = 0;
+		let firstOld;
+		let firstNew;
+		for (const op of ops) if (op.op === "add") {
+			added++;
+			if (firstNew === void 0) firstNew = op.text;
+		} else if (op.op === "remove") {
+			removed++;
+			if (firstOld === void 0) firstOld = op.text;
+		}
+		totalAdded += added;
+		totalRemoved += removed;
+		hunks.push({
+			added,
+			removed,
+			...firstOld !== void 0 ? { firstOld } : {},
+			...firstNew !== void 0 ? { firstNew } : {}
+		});
+	}
+	return {
+		totalAdded,
+		totalRemoved,
+		hunks
+	};
+}
+/**
+* Walk an LCS op stream and emit one summary entry per *run* of
+* non-context ops, with the new-file line number where each run
+* starts. Adjacent add/remove ops collapse into the same entry —
+* matches git's hunk grouping at zero context.
+*/
+function summarizeOpsByHunk(ops) {
+	const hunks = [];
+	let totalAdded = 0;
+	let totalRemoved = 0;
+	let nl = 1;
+	let i = 0;
+	while (i < ops.length) {
+		if (ops[i].op === "context") {
+			nl++;
+			i++;
+			continue;
+		}
+		const runStartLine = nl;
+		let added = 0;
+		let removed = 0;
+		let firstOld;
+		let firstNew;
+		while (i < ops.length && ops[i].op !== "context") {
+			const cur = ops[i];
+			if (cur.op === "add") {
+				added++;
+				if (firstNew === void 0) firstNew = cur.text;
+				nl++;
+			} else {
+				removed++;
+				if (firstOld === void 0) firstOld = cur.text;
+			}
+			i++;
+		}
+		totalAdded += added;
+		totalRemoved += removed;
+		hunks.push({
+			line: runStartLine,
+			added,
+			removed,
+			...firstOld !== void 0 ? { firstOld } : {},
+			...firstNew !== void 0 ? { firstNew } : {}
+		});
+	}
+	return {
+		totalAdded,
+		totalRemoved,
+		hunks
+	};
+}
+function previewEditPayload(payload, priorContent, contextLines = 3) {
+	const resolution = [];
+	const resolvedHunks = [];
+	const perHunkDiff = [];
+	let running = priorContent;
+	for (const hunk of payload.hunks) {
+		if (hunk.oldString === "" || hunk.oldString === running) {
+			resolution.push({
+				resolved: true,
+				via: "exact",
+				occurrences: 1
+			});
+			resolvedHunks.push(hunk);
+			perHunkDiff.push(buildContextualDiff({
+				...payload,
+				hunks: [hunk]
+			}, running, contextLines));
+			running = hunk.newString;
+			continue;
+		}
+		const match = resolveOldString(running, hunk.oldString);
+		if (!match) {
+			resolution.push({ resolved: false });
+			resolvedHunks.push(hunk);
+			perHunkDiff.push("");
+			continue;
+		}
+		const ambiguous = match.occurrences > 1 && !hunk.replaceAll;
+		const styledNew = styleReplacementForVia(hunk.newString, match.via, match.actual);
+		const resolvedHunk = {
+			oldString: match.actual,
+			newString: styledNew,
+			...hunk.replaceAll ? { replaceAll: true } : {}
+		};
+		resolution.push({
+			resolved: !ambiguous,
+			via: match.via,
+			occurrences: match.occurrences,
+			...ambiguous ? { ambiguous: true } : {}
+		});
+		resolvedHunks.push(resolvedHunk);
+		perHunkDiff.push(ambiguous ? "" : buildContextualDiff({
+			...payload,
+			hunks: [resolvedHunk]
+		}, running, contextLines));
+		if (!ambiguous) running = hunk.replaceAll ? running.replaceAll(match.actual, styledNew) : running.replace(match.actual, styledNew);
+	}
+	const resolvedPayload = {
+		...payload,
+		hunks: resolvedHunks
+	};
+	const applicableHunks = resolvedHunks.filter((_, i) => resolution[i].resolved);
+	return {
+		diffText: applicableHunks.length === 0 ? "" : buildContextualDiff({
+			...payload,
+			hunks: applicableHunks
+		}, priorContent, contextLines),
+		resolution,
+		perHunkDiff,
+		resolvedPayload
+	};
+}
+/** Default size budget (UTF-16 code units) for transcript diff rows. */
+const DIFF_RENDER_MAX_BYTES = 524288;
+/** Marker appended to a line hard-truncated mid-content by the size cap. */
+const CLIP_LINE_MARKER = " …⟨line clipped⟩";
+/**
+* Truncate `line` so it fits `budget` code units including the marker,
+* without splitting a UTF-16 surrogate pair. Returns the line unchanged
+* when it already fits.
+*/
+function clipLine(line, budget) {
+	if (line.length <= budget) return line;
+	let end = Math.max(0, budget - 16);
+	const code = line.charCodeAt(end - 1);
+	if (end > 0 && code >= 55296 && code <= 56319) end--;
+	return line.slice(0, end) + CLIP_LINE_MARKER;
+}
+function clipDiffForRender(diff, maxLines = 600, maxBytes = DIFF_RENDER_MAX_BYTES) {
+	const lines = diff.split("\n");
+	const totalLines = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+	if (totalLines <= maxLines && diff.length <= maxBytes) return {
+		text: diff,
+		hiddenLines: 0,
+		totalLines
+	};
+	const kept = [];
+	let used = 0;
+	for (let i = 0; i < totalLines; i++) {
+		if (kept.length >= maxLines) break;
+		const line = lines[i];
+		const cost = line.length + 1;
+		if (used + cost > maxBytes) {
+			if (kept.length === 0) kept.push(clipLine(line, maxBytes));
+			break;
+		}
+		kept.push(line);
+		used += cost;
+	}
+	return {
+		text: kept.join("\n"),
+		hiddenLines: totalLines - kept.length,
+		totalLines
+	};
+}
+function buildUnifiedDiff(payload) {
+	const parts = [];
+	const isNewFile = payload.tool === "write_file" && payload.hunks[0]?.oldString === "";
+	parts.push(isNewFile ? `--- /dev/null` : `--- a/${payload.path}`);
+	parts.push(`+++ b/${payload.path}`);
+	for (const hunk of payload.hunks) {
+		const lines = computeLineDiff(hunk.oldString, hunk.newString);
+		const oldCount = lines.filter((l) => l.op !== "add").length;
+		const newCount = lines.filter((l) => l.op !== "remove").length;
+		const oldStart = oldCount === 0 ? 0 : 1;
+		const newStart = newCount === 0 ? 0 : 1;
+		parts.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+		for (const line of lines) {
+			const prefix = line.op === "add" ? "+" : line.op === "remove" ? "-" : " ";
+			parts.push(`${prefix}${line.text}`);
+		}
+	}
+	return `${parts.join("\n")}\n`;
+}
+const FILETYPE_BY_EXT = {
+	ts: "typescript",
+	mts: "typescript",
+	cts: "typescript",
+	tsx: "typescriptreact",
+	js: "javascript",
+	mjs: "javascript",
+	cjs: "javascript",
+	jsx: "javascriptreact",
+	py: "python",
+	pyi: "python",
+	rs: "rust",
+	go: "go",
+	json: "json",
+	jsonc: "json",
+	sh: "bash",
+	bash: "bash",
+	zsh: "bash",
+	yaml: "yaml",
+	yml: "yaml",
+	html: "html",
+	htm: "html",
+	css: "css",
+	md: "markdown",
+	markdown: "markdown",
+	zig: "zig",
+	lua: "lua",
+	toml: "toml",
+	sql: "sql"
+};
+function filetypeFromPath(path) {
+	const cleaned = path.split(/[?#]/, 1)[0];
+	const lastDot = cleaned.lastIndexOf(".");
+	if (lastDot === -1 || lastDot === cleaned.length - 1) return void 0;
+	const ext = cleaned.slice(lastDot + 1).toLowerCase();
+	return FILETYPE_BY_EXT[ext];
+}
+//#endregion
+//#region src/chat/prompt-segments.ts
+/**
+* Split a prompt buffer into word-sized atomic segments suitable for a
+* flex-row + flex-wrap renderer (TUI) or a `display: inline` flow with
+* inline-block chips (GUI). Each chip becomes one segment (atomic —
+* never broken across rows); each plain run is split into "word +
+* trailing space" units so wraps land at clean word boundaries.
+*
+* Robust to:
+*   - Overlapping refs — sorted by start; later refs that overlap are
+*     dropped via the first-wins rule.
+*   - Out-of-bounds refs — dropped entirely when `end > text.length` or
+*     `start >= text.length`. Partial clipping would silently truncate
+*     a chip's label; the caller is in a better position to surface the
+*     mismatch (typically a stale `refs` array referencing a previous text).
+*   - Whitespace-only plain runs — emitted as their own plain segment
+*     so chip-adjacent-to-chip cases keep the original spacing.
+*
+* Word splitter rationale: `\S+\s*` keeps trailing whitespace attached
+* to its preceding word so wrap boundaries land between words (cleanly).
+* A leading-whitespace-only segment is captured by `\s+` so we don't
+* drop it entirely when the plain run starts with a space.
+*/
+function splitPromptSegments(text, refs) {
+	const sorted = [...refs].filter((r) => r.end > r.start && r.start < text.length && r.end <= text.length).sort((a, b) => a.start - b.start);
+	const out = [];
+	let cursor = 0;
+	for (const ref of sorted) {
+		if (ref.start < cursor) continue;
+		if (ref.start > cursor) {
+			const matches = text.slice(cursor, ref.start).match(/\S+\s*|\s+/g) ?? [];
+			for (const m of matches) out.push({
+				kind: "plain",
+				text: m
+			});
+		}
+		out.push({
+			kind: "chip",
+			text: text.slice(ref.start, ref.end),
+			providerId: ref.providerId
+		});
+		cursor = ref.end;
+	}
+	if (cursor < text.length) {
+		const matches = text.slice(cursor).match(/\S+\s*|\s+/g) ?? [];
+		for (const m of matches) out.push({
+			kind: "plain",
+			text: m
+		});
+	}
+	return out;
+}
+/**
+* File-mention refs recovered from a prompt's text: `@<path>` at the start
+* or after whitespace, where the path looks like one (has a `/` or a `.`),
+* trailing punctuation excluded (the files completion's own rule).
+*
+* Refs are known only to the client that sent the prompt, which typed the
+* mention through a completion. The persisted turn and the send echo other
+* windows receive carry the text alone, so without this a prompt's chips
+* existed in the sender's live transcript only: gone after a reload, never
+* shown in another window or the TUI. Replay and the echo fill refs from
+* this when the event has none, so every client paints the same prompt.
+* Skills and chats mentions are not inferred: their tokens (`/name`,
+* `#token`) are ordinary text too often to guess without the catalogs.
+*/
+function inferPromptRefs(text) {
+	const refs = [];
+	for (const m of text.matchAll(/(^|\s)@(\S+)/g)) {
+		const path = m[2].replace(/[.,;:)\]}!?'"]+$/, "");
+		if (!/[/.]/.test(path) || path.includes("@")) continue;
+		const start = m.index + m[1].length;
+		refs.push({
+			start,
+			end: start + 1 + path.length,
+			providerId: "files"
+		});
+	}
+	return refs;
+}
+/**
+* The segments cut into the lines the user typed. A flex-wrap row cannot
+* break on a newline inside one of its items, so each line renders as its
+* own row; an empty array is a blank line.
+*/
+function promptSegmentLines(segments) {
+	const lines = [[]];
+	for (const segment of segments) {
+		if (segment.kind !== "plain") {
+			lines[lines.length - 1].push(segment);
+			continue;
+		}
+		segment.text.split("\n").forEach((part, i) => {
+			if (i > 0) lines.push([]);
+			if (part) lines[lines.length - 1].push({
+				kind: "plain",
+				text: part
+			});
+		});
+	}
+	return lines;
+}
+//#endregion
+//#region src/chat/settings-defaults.ts
+const DEFAULT_SETTINGS = {
+	showThinking: true,
+	toolCallDisplay: "formatted",
+	showToolResults: true,
+	groupToolCalls: false,
+	showFullShellOutput: false,
+	showRunReceipt: true,
+	showCacheNotices: true,
+	safeMode: true,
+	useDaemon: false,
+	remoteHosts: false,
+	orchestration: false,
+	loadProjectExtensions: false,
+	importForeignConfigs: false,
+	importRulerConfigs: true,
+	hideSubagentOutput: true,
+	subagentModels: true,
+	queueMessages: true,
+	theme: "default",
+	showAllProjects: false,
+	resumeLastSession: true,
+	persistToolResults: true,
+	stableToolList: false,
+	codemode: false,
+	sandbox: false,
+	sandboxNetwork: "allow",
+	sandboxAllowWrite: "",
+	autoCompact: true,
+	autoCompactThreshold: .8,
+	resumeOnMaxTokens: false,
+	maxOutputTokens: 0,
+	maxTurns: 0,
+	retryMaxAttempts: 0,
+	maxCostUsd: 0,
+	maxTotalTokens: 0,
+	maxWallMinutes: 0,
+	thinkingBinding: "drop_block",
+	showEditDiffs: true,
+	editDiffDisplay: "full",
+	transcriptDensity: "full",
+	showCompactionSummary: false,
+	compactionModel: "",
+	targetFps: 60,
+	mouseInteractions: true,
+	interactionMode: "ask",
+	smoothStreaming: true,
+	fileLogging: false,
+	showTodoIndicator: true,
+	showUsageIndicator: true,
+	showThrobber: false,
+	artifacts: true,
+	browser: true,
+	browserAgent: true,
+	browserAutoShow: true,
+	terminal: true,
+	terminalAgent: true,
+	terminalAgentTasks: true,
+	closeTerminalOnCleanExit: true,
+	confirmGitSync: true,
+	sidebarRunDetails: true,
+	openIn: "editor",
+	checkForUpdates: true,
+	subscriptionUsage: true,
+	uiMode: "full",
+	userInstructionsScope: "both",
+	ctrlCBehavior: "quit",
+	terminalTitle: "off",
+	sessionIcon: "",
+	attentionIcon: "",
+	activeIcon: "",
+	attachmentsEnabled: true,
+	externalEditor: true,
+	inlineAutocomplete: false
+};
+//#endregion
+//#region src/chat/hosts/types.ts
+/** A refused `add` / `rename`; `code` says why. */
+var HostRegistryError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "HostRegistryError";
+	}
+};
+//#endregion
+//#region src/chat/secret-shapes.ts
+/**
+* What a credential looks like, as pure predicates: secret-looking names
+* (`--api-key`, `DB_PASS`, `"apiKey"`), known token shapes (`sk-…`,
+* `ghp_…`, `zds_…`) and high-entropy values. Shared by everything that must
+* keep a token out of what it shows or saves: the host's MCP catalog
+* redaction (`src/ipc/daemon/redact.ts`) and the remote host URL check
+* (`./hosts/url.ts`). Node-free.
+*
+* Over-matching an ordinary word is a cosmetic loss; under-matching leaks a
+* credential, so the rules lean wide, but stay off file paths, package names
+* and plain words (`passthrough`, `bypass`, `keymap`).
+*/
+/**
+* A secret-looking name: a flag (`--auth-token`), a variable (`DB_PASS`), a
+* JSON key (`apiKey`) or a connection-string key (`Password`). `pass` and
+* `key` count only as a whole word or a `-` / `_` segment at the end.
+*/
+const SECRET_NAME = /token|secret|passw(?:or)?d|passphrase|pwd|api[-_]?key|access[-_]?key|private[-_]?key|auth|credential|bearer|cookie|(?:^|[-_])(?:pass|key)$/i;
+/** Token prefixes issued by common services, with enough body to be a credential. */
+const KNOWN_TOKEN = /(?<![\w-])(?:sk-[\w-]{16,}|sk_(?:live|test)_\w{16,}|gh[pousr]_\w{20,}|github_pat_\w{20,}|xox[abposr]-[\w-]{10,}|(?:AKIA|ASIA)[0-9A-Z]{16}|glpat-[\w-]{20,}|zds_[\w-]{20,}|AIza[\w-]{30,})/g;
+function isSecretName(name) {
+	return SECRET_NAME.test(name);
+}
+/** A known token shape somewhere in `value`. */
+function containsKnownToken(value) {
+	KNOWN_TOKEN.lastIndex = 0;
+	return KNOWN_TOKEN.test(value);
+}
+function entropy(value) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const char of value) counts.set(char, (counts.get(char) ?? 0) + 1);
+	let bits = 0;
+	for (const count of counts.values()) {
+		const p = count / value.length;
+		bits -= p * Math.log2(p);
+	}
+	return bits;
+}
+/**
+* A whole value that looks like a credential: a known token shape, a long
+* hex / UUID-like id, or a long random mix of cases and digits. Words joined
+* by dashes (`server-2024-edition`) and paths stay readable.
+*/
+function looksLikeSecret(value) {
+	KNOWN_TOKEN.lastIndex = 0;
+	const known = KNOWN_TOKEN.exec(value);
+	if (known && known[0] === value) return true;
+	if (value.length < 20 || !/^[\w\-+=.~]+$/.test(value) || !/\d/.test(value) || !/[a-z]/i.test(value)) return false;
+	const digits = value.replace(/\D/g, "").length;
+	if (/^[\da-f-]+$/i.test(value)) return digits / value.length >= .25;
+	return /[a-z]/.test(value) && /[A-Z]/.test(value) && entropy(value) >= 4;
+}
+function safeDecode(segment) {
+	try {
+		return decodeURIComponent(segment);
+	} catch {
+		return segment;
+	}
+}
+/** A URL path segment that carries a credential (as is, or percent-decoded). */
+function isSecretPathSegment(segment) {
+	const decoded = safeDecode(segment);
+	return looksLikeSecret(segment) || looksLikeSecret(decoded) || containsKnownToken(decoded);
+}
+//#endregion
+//#region src/chat/hosts/url.ts
+/**
+* Host URLs a client accepts: `wss://`, or `ws://` to this machine only (a
+* token must not cross the network in the clear), with no credentials in
+* them: no `user:pass@`, no query string, no fragment, no token-looking
+* path segment (`wss://h/zds_…`, a long random id: the shapes the MCP
+* catalog redacts, `../secret-shapes`). Tokens go in the token field, and a
+* URL ends up in hosts.json, error messages and the GUI's renderer.
+* Messages show {@link displayHostUrl}, never the input. Node-free.
+*/
+var RemoteHostError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RemoteHostError";
+	}
+};
+/**
+* A loopback host: `localhost`, `127.x.x.x` or `::1` (bracketed, as in a URL,
+* or bare, as an interface to bind). The one check for both ends: a client
+* allowing `ws://`, a server refusing to listen in the clear.
+*/
+function isLoopbackHost(host) {
+	const bare = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+	return bare === "localhost" || bare === "::1" || /^127\.\d+\.\d+\.\d+$/.test(bare);
+}
+/** Shown in place of a path segment that looks like a credential. */
+const REDACTED_SEGMENT = "<redacted>";
+/** Scheme, host, port and path of a URL (token-looking path segments redacted): what is safe to show or log. */
+function displayHostUrl(raw) {
+	try {
+		const url = new URL(raw.trim());
+		const path = url.pathname.split("/").map((segment) => isSecretPathSegment(segment) ? REDACTED_SEGMENT : segment).join("/");
+		return `${url.protocol}//${url.host}${path.replace(/\/$/, "")}`;
+	} catch {
+		return "<invalid URL>";
+	}
+}
+/** `raw` carries something {@link parseRemoteHostUrl} refuses as a credential (userinfo, query, fragment, a token-looking path segment). */
+function urlCarriesSecrets(raw) {
+	if (/[@?#]/.test(raw)) return true;
+	try {
+		return new URL(raw.trim()).pathname.split("/").some(isSecretPathSegment);
+	} catch {
+		return false;
+	}
+}
+/** Validate and normalize a host URL (no trailing slash); throws {@link RemoteHostError}. */
+function parseRemoteHostUrl(raw) {
+	let url;
+	try {
+		url = new URL(raw.trim());
+	} catch {
+		throw new RemoteHostError("Invalid host URL: expected wss://host[:port].");
+	}
+	const shown = displayHostUrl(raw);
+	if (url.username !== "" || url.password !== "") throw new RemoteHostError(`Host URLs can't carry a user or password (${shown}): put the token in the token field (or --token-file), not in the URL.`);
+	if (url.search !== "" || raw.includes("?")) throw new RemoteHostError(`Host URLs can't carry a query string (${shown}): remove it; a token goes in the token field (or --token-file).`);
+	if (url.hash !== "" || raw.includes("#")) throw new RemoteHostError(`Host URLs can't carry a fragment (${shown}): remove it.`);
+	if (url.pathname.split("/").some(isSecretPathSegment)) throw new RemoteHostError(`Host URLs can't carry a token in their path (${url.protocol}//${url.host}): remove it; a token goes in the token field (or --token-file).`);
+	if (url.protocol === "wss:" || url.protocol === "ws:" && isLoopbackHost(url.hostname)) return url.href.replace(/\/$/, "");
+	if (url.protocol === "ws:") throw new RemoteHostError(`Refusing ws://${url.host}: the token would travel unencrypted. Use wss:// (ws:// is only for 127.0.0.1 / localhost).`);
+	throw new RemoteHostError(`Invalid host URL ${shown}: expected wss://host[:port].`);
+}
+//#endregion
+export { resolveApprovalForPayload as A, isAllowedBrowserUrl as B, splitLines as C, maskToOutcomeKinds as D, buildEditOutcomesAnnotation as E, commandNoteText as F, normalizeBrowserUrl as H, commandStepLabel as I, gatherCommandNotes as L, stripEditOutcomesAnnotation as M, summarizeOutcomes as N, mergeApprovalAndBodyOutcomes as O, commandHeaderBlock as P, noteDisplay as R, previewEditPayload as S, tokenize as T, isLocalBrowserUrl as V, clipDiffForRender as _, KNOWN_TOKEN as a, extractEditPayload as b, looksLikeSecret as c, inferPromptRefs as d, promptSegmentLines as f, buildUnifiedDiff as g, buildContextualDiff as h, urlCarriesSecrets as i, rewriteMultiEditHeader as j, parseEditOutcomesFromResult as k, HostRegistryError as l, applyEditPayload as m, displayHostUrl as n, isSecretName as o, splitPromptSegments as p, parseRemoteHostUrl as r, isSecretPathSegment as s, RemoteHostError as t, DEFAULT_SETTINGS as u, computeInlineDiff as v, summarizeEditPayload as w, filetypeFromPath as x, computeLineDiff as y, parseCommandHeader as z };
+
+//# sourceMappingURL=url-D8HCl65b.js.map