zidane 7.2.4 → 8.0.4

package/dist/context-segments-BHKlagL6.js

@@ -0,0 +1,1016 @@
+import { n as estimateTokens } from "./utils-ngQzYzZD.js";
+//#region src/extensions/badge-actions.ts
+const MAX_TEXT = 65536;
+const MAX_ITEMS_PER_SOURCE = 8;
+const GROUP_ORDER = {
+	copy: 0,
+	prompt: 1,
+	open: 2,
+	more: 3
+};
+function isWebUrl(href) {
+	return href !== void 0 && /^https?:\/\//i.test(href);
+}
+function str$1(v, max) {
+	return typeof v === "string" && v.length > 0 && v.length <= max ? v : void 0;
+}
+/** A target from across a boundary (the GUI renderer), reduced to its known, bounded fields; `null` when unusable. */
+function normalizeBadgeTarget(raw) {
+	const t = raw && typeof raw === "object" ? raw : null;
+	if (!t) return null;
+	const kind = [
+		"link",
+		"file",
+		"commit",
+		"pull_request",
+		"branch",
+		"reference",
+		"artifact"
+	].find((k) => k === t.kind);
+	const text = str$1(t.text, 2048);
+	if (!kind || !text) return null;
+	const href = str$1(t.href, 4096);
+	const prompt = str$1(t.prompt, MAX_TEXT);
+	const sessionId = str$1(t.sessionId, 512);
+	const a = t.artifact && typeof t.artifact === "object" ? t.artifact : void 0;
+	const artifactKind = str$1(a?.kind, 64);
+	const artifactUri = str$1(a?.uri, 2048);
+	const r = t.reference && typeof t.reference === "object" ? t.reference : void 0;
+	const providerId = str$1(r?.providerId, 128);
+	const key = str$1(r?.key, 512);
+	return {
+		kind,
+		text,
+		...href ? { href } : {},
+		...prompt ? { prompt } : {},
+		...artifactKind && artifactUri ? { artifact: {
+			kind: artifactKind,
+			uri: artifactUri
+		} } : {},
+		...providerId && key ? { reference: {
+			providerId,
+			key
+		} } : {},
+		...sessionId ? { sessionId } : {}
+	};
+}
+/** What "Add to prompt" inserts for a target. */
+function badgePromptText(target) {
+	if (target.prompt) return target.prompt;
+	if (target.kind === "file" && target.href) return `@${target.href}`;
+	if (isWebUrl(target.href) && target.kind === "link") return target.href;
+	return target.text;
+}
+/** The built-in actions for a target (host-implemented; see {@link builtinBadgeEffect}). */
+function builtinBadgeActions(target) {
+	const items = [];
+	const web = isWebUrl(target.href);
+	if (web) items.push({
+		id: "copy-url",
+		label: "Copy URL",
+		group: "copy",
+		shortcut: "C",
+		source: "builtin"
+	});
+	else if (target.kind === "file" && target.href) items.push({
+		id: "copy-path",
+		label: "Copy path",
+		group: "copy",
+		shortcut: "C",
+		source: "builtin"
+	});
+	if (target.kind === "commit") items.push({
+		id: "copy-text",
+		label: "Copy SHA",
+		group: "copy",
+		...web ? {} : { shortcut: "C" },
+		source: "builtin"
+	});
+	else if (!web && target.kind !== "file") items.push({
+		id: "copy-text",
+		label: "Copy",
+		group: "copy",
+		shortcut: "C",
+		source: "builtin"
+	});
+	items.push({
+		id: "add-to-prompt",
+		label: "Add to prompt",
+		group: "prompt",
+		shortcut: "P",
+		source: "builtin"
+	});
+	if (web) items.push({
+		id: "open-browser",
+		label: "Open in browser",
+		group: "open",
+		shortcut: "O",
+		source: "builtin"
+	});
+	else if (target.kind === "file" && target.href) items.push({
+		id: "open-file",
+		label: "Open",
+		group: "open",
+		shortcut: "O",
+		source: "builtin"
+	});
+	return items;
+}
+/** The effect of a built-in action; `undefined` for an id that isn't one (or doesn't apply). */
+function builtinBadgeEffect(actionId, target) {
+	switch (actionId) {
+		case "copy-url": return isWebUrl(target.href) ? { copy: target.href } : void 0;
+		case "copy-path": return target.kind === "file" && target.href ? { copy: target.href } : void 0;
+		case "copy-text": return { copy: target.text };
+		case "add-to-prompt": return { insert: badgePromptText(target) };
+		case "open-browser": return isWebUrl(target.href) ? { open: target.href } : void 0;
+		case "open-file": return target.kind === "file" && target.href ? { open: target.href } : void 0;
+		default: return;
+	}
+}
+function matches(entry, target) {
+	const m = entry.value.match;
+	if (!m) return true;
+	if (m.kinds && !m.kinds.includes(target.kind)) return false;
+	if (m.artifactKinds && (!target.artifact || !m.artifactKinds.includes(target.artifact.kind))) return false;
+	if (m.references) {
+		const id = target.reference?.providerId;
+		if (!id || !m.references.includes(id)) return false;
+	}
+	return true;
+}
+/**
+* Extension items for a target, in registration order, after validation:
+* ids and labels must be non-empty strings, ids unique per source, at most
+* eight per source. A throwing `actions` contributes nothing.
+*/
+function extensionBadgeActions(target, registry) {
+	const out = [];
+	for (const entry of registry.badgeActions) {
+		if (!matches(entry, target)) continue;
+		let listed;
+		try {
+			listed = entry.value.actions(target);
+		} catch {
+			continue;
+		}
+		const seen = /* @__PURE__ */ new Set();
+		for (const action of listed ?? []) {
+			if (seen.size >= MAX_ITEMS_PER_SOURCE) break;
+			const id = str$1(action?.id, 64);
+			const label = str$1(action?.label, 80);
+			if (!id || !label || seen.has(id)) continue;
+			seen.add(id);
+			const group = action.group && action.group in GROUP_ORDER ? action.group : "more";
+			const shortcut = str$1(action.shortcut, 1);
+			out.push({
+				id,
+				label,
+				group,
+				...shortcut ? { shortcut } : {},
+				source: entry.value.id
+			});
+		}
+	}
+	return out;
+}
+/**
+* The full menu: built-ins then extension items, ordered by group (stable
+* within a group). An extension shortcut that collides with an earlier one
+* is dropped, never the item.
+*/
+function badgeMenu(target, registry) {
+	return mergeBadgeMenu([...builtinBadgeActions(target), ...registry ? extensionBadgeActions(target, registry) : []]);
+}
+/**
+* Order items the way {@link badgeMenu} does: by group, stable within one,
+* later colliding shortcuts dropped. For hosts that get the built-ins and the
+* extension items separately (the GUI renderer asks main for the latter).
+*/
+function mergeBadgeMenu(all) {
+	const sorted = all.map((item, i) => ({
+		item,
+		i
+	})).sort((a, b) => GROUP_ORDER[a.item.group ?? "more"] - GROUP_ORDER[b.item.group ?? "more"] || a.i - b.i).map(({ item }) => item);
+	const taken = /* @__PURE__ */ new Set();
+	return sorted.map((item) => {
+		if (!item.shortcut) return item;
+		const key = item.shortcut.toUpperCase();
+		if (taken.has(key)) {
+			const { shortcut: _drop, ...rest } = item;
+			return rest;
+		}
+		taken.add(key);
+		return item;
+	});
+}
+/** An effect from extension code, reduced to known, bounded string fields. */
+function normalizeBadgeEffect(raw) {
+	const e = raw && typeof raw === "object" ? raw : {};
+	const copy = str$1(e.copy, MAX_TEXT);
+	const insert = str$1(e.insert, MAX_TEXT);
+	const open = str$1(e.open, 4096);
+	const notice = str$1(e.notice, 280);
+	return {
+		...copy ? { copy } : {},
+		...insert ? { insert } : {},
+		...open && (/^https?:\/\//i.test(open) || open.startsWith("/")) ? { open } : {},
+		...notice ? { notice } : {}
+	};
+}
+/**
+* Run one menu item: a built-in resolves locally, an extension item runs its
+* registration's `run` (8 s deadline). Never throws: failures come back as a
+* `notice`.
+*/
+async function runBadgeAction(source, actionId, target, registry, ctx = {}) {
+	if (source === "builtin") return builtinBadgeEffect(actionId, target) ?? { notice: "Not available for this badge." };
+	const entry = registry?.badgeActions.find((e) => e.value.id === source);
+	if (!entry || !matches(entry, target)) return { notice: "This action is no longer available." };
+	const signal = AbortSignal.timeout(8e3);
+	try {
+		return normalizeBadgeEffect(await Promise.race([Promise.resolve(entry.value.run(actionId, target, {
+			...ctx,
+			signal
+		})), new Promise((_, reject) => signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("Timed out.")), { once: true }))]));
+	} catch (err) {
+		return { notice: err instanceof Error ? err.message : String(err) };
+	}
+}
+/**
+* The target for an artifact row (Artifacts panel / rail): its kind's
+* badge kind (commit, pull request, file; `artifact` for the rest), the
+* row's title and link, and what "Add to prompt" inserts: a commit's SHA,
+* a file's path, the link, else the label.
+*/
+function artifactBadgeTarget(artifact, row) {
+	const kind = artifact.kind === "commit" ? "commit" : artifact.kind === "pull_request" ? "pull_request" : artifact.kind === "file" ? "file" : "artifact";
+	const sha = kind === "commit" ? /^git:commit:([0-9a-f]{7,40})$/.exec(artifact.uri)?.[1] : void 0;
+	return {
+		kind,
+		text: sha ? sha.slice(0, 7) : row.title,
+		...row.href ? { href: row.href } : {},
+		...sha ? { prompt: sha } : kind === "artifact" && !row.href ? { prompt: artifact.label } : {},
+		artifact: {
+			kind: artifact.kind,
+			uri: artifact.uri
+		},
+		...artifact.sessionId ? { sessionId: artifact.sessionId } : {}
+	};
+}
+/** The target for a session badge (or one row of its card): GUI sidebar, TUI sessions list. */
+function sessionBadgeTarget(sessionId, entry, row) {
+	const { badge } = entry;
+	const uri = row?.uri ?? badge.card?.rows[0]?.uri ?? entry.kind;
+	const href = row ? row.href : badge.href;
+	const prompt = row ? row.prompt ?? row.href ?? row.lead : badge.prompt ?? badge.href;
+	return {
+		kind: "artifact",
+		text: row ? row.lead ?? row.title : badge.text,
+		...href ? { href } : {},
+		...prompt ? { prompt } : {},
+		artifact: {
+			kind: entry.kind,
+			uri
+		},
+		sessionId
+	};
+}
+//#endregion
+//#region src/chat/keybinding-spec.ts
+/**
+* Aliases the parser accepts on input so the on-disk format can be
+* forgiving (different terminals + docs label modifiers + keys
+* differently). Output names are canonicalized to one form per key so a
+* matcher only has to compare one canonical against an event's key name.
+* Unknown names pass through verbatim, which is useful for
+* terminal-specific keys we don't have to enumerate.
+*/
+const NAME_ALIASES = {
+	"esc": "escape",
+	"enter": "return",
+	"ret": "return",
+	"space": "space",
+	"spc": "space",
+	"del": "delete",
+	"ins": "insert",
+	"pgup": "pageup",
+	"pgdn": "pagedown",
+	"pagup": "pageup",
+	"pagedn": "pagedown",
+	"plus": "=",
+	"+": "=",
+	"minus": "-",
+	"{": "[",
+	"}": "]",
+	"~": "`",
+	"arrowleft": "left",
+	"arrowright": "right",
+	"arrowup": "up",
+	"arrowdown": "down"
+};
+const MODIFIER_ALIASES = {
+	ctrl: "ctrl",
+	control: "ctrl",
+	shift: "shift",
+	alt: "alt",
+	option: "alt",
+	opt: "alt",
+	meta: "meta",
+	cmd: "meta",
+	command: "meta",
+	super: "meta",
+	win: "meta"
+};
+/** A key name as the parser canonicalizes it (`'Enter'` → `'return'`, `'ArrowLeft'` → `'left'`). */
+function canonicalKeyName(key) {
+	const lower = key.toLowerCase();
+	return NAME_ALIASES[lower] ?? lower;
+}
+/**
+* The chords one binding lists. A binding may name several, any of which
+* fires the action: `"ctrl+w | cmd+w"` (or, in `keybindings.json`, an array).
+* A `|` right after a `+` / `-` is the key itself (`ctrl+|`).
+*/
+function bindingAlternatives(spec) {
+	if (typeof spec !== "string") return [];
+	return spec.split(/(?<![+\-])\|/).map((part) => part.trim()).filter(Boolean);
+}
+/** Every chord of `spec` that parses (see {@link bindingAlternatives}). */
+function parseBindingSpecs(spec) {
+	return bindingAlternatives(spec).map(parseOneSpec).filter((p) => p !== null);
+}
+/**
+* The spec's first valid chord (callers that pre-parse one binding). Use
+* {@link parseBindingSpecs} to honour every alternative.
+*/
+function parseBindingSpec(spec) {
+	return parseBindingSpecs(spec)[0] ?? null;
+}
+/**
+* Parse one `'ctrl+shift+o'`-style chord. Returns `null` for empty /
+* malformed inputs; the caller falls back to the default for that action.
+*
+* Tolerant by design:
+*   - Case-insensitive (`Ctrl+O` → same as `ctrl+o`).
+*   - Modifier order doesn't matter (`shift+ctrl+o` works).
+*   - Mixed `+` and `-` separators allowed (`ctrl-o`, `ctrl+o`).
+*   - Trailing / leading whitespace is stripped.
+*   - Duplicate modifiers collapse silently.
+*/
+function parseOneSpec(spec) {
+	const trimmed = spec.trim().toLowerCase();
+	if (!trimmed) return null;
+	const parts = trimmed.split(/[+\-]/).map((p) => p.trim()).filter(Boolean);
+	if (parts.length === 0) return null;
+	const result = {
+		ctrl: false,
+		shift: false,
+		alt: false,
+		meta: false,
+		name: ""
+	};
+	for (const part of parts) {
+		const modifier = MODIFIER_ALIASES[part];
+		if (modifier) {
+			result[modifier] = true;
+			continue;
+		}
+		if (result.name) return null;
+		result.name = NAME_ALIASES[part] ?? part;
+	}
+	if (!result.name) return null;
+	return result;
+}
+//#endregion
+//#region src/extensions/references.ts
+const ALLOWED_FLAGS = /* @__PURE__ */ new Set([
+	"i",
+	"u",
+	"m",
+	"s"
+]);
+const MAX_MATCHES = 200;
+/** Compile a pattern, or `null` when its source doesn't parse. */
+function compileReferencePattern(pattern) {
+	const flags = [...new Set([...pattern.flags ?? ""].filter((f) => ALLOWED_FLAGS.has(f)))].join("");
+	try {
+		return new RegExp(pattern.regex, `g${flags}`);
+	} catch {
+		return null;
+	}
+}
+function expandKey(template, m) {
+	return template.replace(/\$(\d)/g, (_, d) => m[Number(d)] ?? "").trim();
+}
+const compiled = /* @__PURE__ */ new WeakMap();
+function compiledPatterns(provider) {
+	let list = compiled.get(provider.patterns);
+	if (!list) {
+		list = provider.patterns.flatMap((p) => {
+			const re = compileReferencePattern(p);
+			return re ? [[re, p.key ?? "$0"]] : [];
+		});
+		compiled.set(provider.patterns, list);
+	}
+	return list;
+}
+/**
+* Every reference in `text` for the providers that scan `surface`, sorted,
+* without overlaps: the earliest start wins, then the longest, then the
+* earlier provider. Zero-length matches are skipped.
+*/
+function findReferences(text, providers, surface) {
+	if (!text || providers.length === 0) return [];
+	const found = [];
+	providers.forEach((provider, rank) => {
+		if (surface && provider.surfaces && !provider.surfaces.includes(surface)) return;
+		for (const [re, template] of compiledPatterns(provider)) {
+			re.lastIndex = 0;
+			let m;
+			let n = 0;
+			while ((m = re.exec(text)) && n++ < MAX_MATCHES) {
+				if (m[0].length === 0) {
+					re.lastIndex++;
+					continue;
+				}
+				const key = expandKey(template, m);
+				if (key) found.push({
+					start: m.index,
+					end: m.index + m[0].length,
+					providerId: provider.id,
+					key,
+					rank
+				});
+			}
+		}
+	});
+	found.sort((a, b) => a.start - b.start || b.end - b.start - (a.end - a.start) || a.rank - b.rank);
+	const out = [];
+	let cursor = 0;
+	for (const { rank: _rank, ...match } of found) {
+		if (match.start < cursor) continue;
+		out.push(match);
+		cursor = match.end;
+	}
+	return out;
+}
+/** The registry's providers as wire data, in registration order. */
+function referenceProviderWires(registry) {
+	return registry.references.map(({ value }) => ({
+		id: value.id,
+		patterns: value.patterns.map((p) => ({
+			regex: p.regex,
+			...p.flags ? { flags: p.flags } : {},
+			...p.key ? { key: p.key } : {}
+		})),
+		...value.surfaces ? { surfaces: [...value.surfaces] } : {}
+	}));
+}
+/** A view clipped to bounds and stripped of anything not JSON-safe. */
+function normalizeView(view) {
+	if (!view || typeof view.label !== "string" || !view.label) return null;
+	const str = (v, max) => typeof v === "string" && v ? v.slice(0, max) : void 0;
+	const icon = view.icon && (str(view.icon.gui, 128) || str(view.icon.tui, 8)) ? {
+		...str(view.icon.gui, 128) ? { gui: str(view.icon.gui, 128) } : {},
+		...str(view.icon.tui, 8) ? { tui: str(view.icon.tui, 8) } : {}
+	} : void 0;
+	const tone = view.tone && [
+		"muted",
+		"subtle",
+		"accent",
+		"success",
+		"warn",
+		"danger"
+	].includes(view.tone) ? view.tone : void 0;
+	const status = str(view.status, 64);
+	const title = str(view.title, 512);
+	const href = str(view.href, 2048);
+	return {
+		label: view.label.slice(0, 128),
+		...icon ? { icon } : {},
+		...tone ? { tone } : {},
+		...status ? { status } : {},
+		...title ? { title } : {},
+		...href ? { href } : {}
+	};
+}
+/** A cached resolver over the registry's providers. */
+function createReferenceResolver(registry, options = {}) {
+	const ttl = options.ttlMs ?? 3e5;
+	const missTtl = options.missTtlMs ?? 6e4;
+	const timeoutMs = options.timeoutMs ?? 8e3;
+	const now = options.now ?? Date.now;
+	const cache = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	const byId = (id) => registry.references.find((c) => c.value.id === id)?.value;
+	return {
+		resolve: async (providerId, key) => {
+			const provider = byId(providerId);
+			if (!provider) return null;
+			const id = `${providerId}\u0000${key}`;
+			const hit = cache.get(id);
+			if (hit && now() - hit.at < (hit.view ? ttl : missTtl)) return hit.view;
+			const pending = inflight.get(id);
+			if (pending) return pending;
+			const run = (async () => {
+				const signal = AbortSignal.timeout(timeoutMs);
+				try {
+					const view = normalizeView(await provider.resolve(key, { signal }));
+					cache.set(id, {
+						view,
+						at: now()
+					});
+					return view;
+				} catch {
+					return hit?.view ?? null;
+				} finally {
+					inflight.delete(id);
+				}
+			})();
+			inflight.set(id, run);
+			return run;
+		},
+		clear: () => cache.clear()
+	};
+}
+//#endregion
+//#region src/extensions/panels.ts
+/**
+* A load context from across a boundary (the GUI renderer), reduced to its
+* known string fields. Hosts run it before handing the context to `load` /
+* `onAction`.
+*/
+function normalizePanelLoadContext(raw) {
+	const ctx = raw && typeof raw === "object" ? raw : {};
+	const str = (v, max) => typeof v === "string" && v && v.length <= max ? v : void 0;
+	const sessionId = str(ctx.sessionId, 512);
+	const cwd = str(ctx.cwd, 4096);
+	const focusRaw = ctx.focus && typeof ctx.focus === "object" ? ctx.focus : void 0;
+	const kind = str(focusRaw?.kind, 64);
+	const uri = str(focusRaw?.uri, 2048);
+	return {
+		...sessionId ? { sessionId } : {},
+		...cwd ? { cwd } : {},
+		...kind || uri ? { focus: {
+			...kind ? { kind } : {},
+			...uri ? { uri } : {}
+		} } : {}
+	};
+}
+/** Caps applied before content crosses IPC or reaches a renderer. */
+const PANEL_CONTENT_LIMITS = {
+	sections: 32,
+	itemsPerSection: 200,
+	actions: 8,
+	/** Per string field. */
+	textChars: 2e4,
+	/** Whole payload, JSON-serialised. */
+	bytes: 524288
+};
+function str(v, max = PANEL_CONTENT_LIMITS.textChars) {
+	return typeof v === "string" ? v.length > max ? `${v.slice(0, max - 1)}…` : v : void 0;
+}
+/**
+* Coerce whatever `load()` returned into a well-formed `PanelContent`:
+* unknown item kinds and malformed entries are dropped, strings are
+* trimmed to the caps, and the whole thing is size-bounded. Never throws.
+*/
+function normalizePanelContent(input) {
+	const empty = { sections: [] };
+	if (!input || typeof input !== "object") return empty;
+	const o = input;
+	const sections = [];
+	if (Array.isArray(o.sections)) for (const raw of o.sections.slice(0, PANEL_CONTENT_LIMITS.sections)) {
+		const s = normalizeSection(raw, sections.length);
+		if (s) sections.push(s);
+	}
+	const actions = [];
+	if (Array.isArray(o.actions)) {
+		for (const raw of o.actions.slice(0, PANEL_CONTENT_LIMITS.actions)) if (raw && typeof raw === "object") {
+			const a = raw;
+			const id = str(a.id, 200);
+			const label = str(a.label, 200);
+			if (id && label) actions.push({
+				id,
+				label,
+				...a.tone === "danger" ? { tone: "danger" } : {}
+			});
+		}
+	}
+	const out = { sections };
+	const title = str(o.title, 200);
+	if (title) out.title = title;
+	if (typeof o.badge === "number" && Number.isFinite(o.badge)) out.badge = o.badge;
+	else if (typeof o.badge === "string" && o.badge) out.badge = o.badge.slice(0, 12);
+	if (actions.length > 0) out.actions = actions;
+	const emptyText = str(o.empty, 500);
+	if (emptyText) out.empty = emptyText;
+	return enforceBytes(out);
+}
+function normalizeSection(raw, index) {
+	if (!raw || typeof raw !== "object") return null;
+	const s = raw;
+	const items = [];
+	if (Array.isArray(s.items)) for (const item of s.items.slice(0, PANEL_CONTENT_LIMITS.itemsPerSection)) {
+		const n = normalizeItem(item);
+		if (n) items.push(n);
+	}
+	const out = {
+		id: str(s.id, 200) ?? `section-${index}`,
+		items
+	};
+	const title = str(s.title, 200);
+	if (title) out.title = title;
+	if (s.collapsed === true) out.collapsed = true;
+	return out;
+}
+function normalizeItem(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const i = raw;
+	switch (i.kind) {
+		case "row": {
+			const title = str(i.title, 500);
+			if (!title) return null;
+			const out = {
+				kind: "row",
+				title
+			};
+			const id = str(i.id, 200);
+			const subtitle = str(i.subtitle, 1e3);
+			const href = str(i.href, 2e3);
+			const status = str(i.status, 60);
+			const actionId = str(i.actionId, 200);
+			if (id) out.id = id;
+			if (subtitle) out.subtitle = subtitle;
+			if (href) out.href = href;
+			if (status) out.status = status;
+			if (actionId) out.actionId = actionId;
+			if (Array.isArray(i.badges)) out.badges = i.badges.filter(isBadge).slice(0, 8);
+			if (i.payload !== void 0 && isJsonValue(i.payload)) out.payload = i.payload;
+			return out;
+		}
+		case "markdown": {
+			const text = str(i.text);
+			return text === void 0 ? null : {
+				kind: "markdown",
+				text
+			};
+		}
+		case "kv":
+			if (!Array.isArray(i.rows)) return null;
+			return {
+				kind: "kv",
+				rows: i.rows.map((r) => {
+					if (!r || typeof r !== "object") return null;
+					const row = r;
+					const label = str(row.label, 200);
+					const value = str(row.value, 2e3);
+					return label !== void 0 && value !== void 0 ? {
+						label,
+						value
+					} : null;
+				}).filter((r) => r !== null).slice(0, PANEL_CONTENT_LIMITS.itemsPerSection)
+			};
+		case "custom": {
+			const renderer = str(i.renderer, 200);
+			const fallback = str(i.fallback);
+			if (!renderer || fallback === void 0) return null;
+			const out = {
+				kind: "custom",
+				renderer,
+				fallback
+			};
+			if (i.data !== void 0 && isJsonValue(i.data)) out.data = i.data;
+			return out;
+		}
+		default: return null;
+	}
+}
+function isBadge(v) {
+	return Boolean(v && typeof v === "object" && typeof v.text === "string");
+}
+function isJsonValue(v) {
+	try {
+		JSON.stringify(v);
+		return v !== void 0 && typeof v !== "function" && typeof v !== "symbol";
+	} catch {
+		return false;
+	}
+}
+/**
+* Trim sections from the end until the payload fits the byte budget. A
+* panel that overflows keeps its first sections and gets an `empty`-style
+* note appended so the truncation is visible.
+*/
+function enforceBytes(content) {
+	const size = (c) => JSON.stringify(c).length;
+	if (size(content) <= PANEL_CONTENT_LIMITS.bytes) return content;
+	const sections = [...content.sections];
+	while (sections.length > 0 && size({
+		...content,
+		sections
+	}) > PANEL_CONTENT_LIMITS.bytes) sections.pop();
+	return {
+		...content,
+		sections: [...sections, {
+			id: "truncated",
+			items: [{
+				kind: "markdown",
+				text: "_Panel content truncated (too large)._"
+			}]
+		}]
+	};
+}
+/** Tab badge as shown next to the label; `undefined` when nothing to show. */
+function panelBadgeText(badge) {
+	if (badge === void 0 || badge === 0 || badge === "") return void 0;
+	if (typeof badge === "number") return badge > 99 ? "99+" : String(badge);
+	return badge;
+}
+//#endregion
+//#region src/chat/context-breakdown.ts
+const LABELS = {
+	systemPrompt: "System prompt",
+	rules: "Rules (AGENTS.md)",
+	tools: "Tool definitions",
+	mcpTools: "MCP tools",
+	mcpInstructions: "MCP instructions",
+	skills: "Skills",
+	subagentDefs: "Searchable tools catalog",
+	conversation: "Conversation",
+	mcpToolsDeferred: "MCP tools (deferred)",
+	toolsDeferred: "System tools (deferred)",
+	autocompactBuffer: "Autocompact buffer",
+	freeSpace: "Free space"
+};
+/** Sum the heuristic token sizes of a list of strings. */
+function sumEstimate(parts) {
+	let total = 0;
+	for (const p of parts) total += estimateTokens(p);
+	return total;
+}
+function mcpGroupTokens(group) {
+	const items = group.tools.map((t) => ({
+		id: `${group.server}:${t.name}`,
+		label: t.name,
+		tokens: estimateTokens(t.json),
+		estimated: true,
+		...t.description ? { description: t.description } : {},
+		group: group.server
+	}));
+	let total = 0;
+	for (const it of items) total += it.tokens;
+	return {
+		total,
+		items
+	};
+}
+/**
+* Shape a {@link ContextSnapshot} into a render-ready {@link ContextBreakdown}.
+*
+* Live categories (system prompt, tools, MCP tools/instructions, skills,
+* memory, searchable-tools catalog, conversation) sum to `snapshot.used` — `conversation`
+* absorbs the remainder so the bar matches the provider-reported total exactly.
+* Deferred + autocompact + free-space buckets follow.
+*
+* When `snapshot.exact` carries provider counts, the matching categories use
+* them (system, tools) and drop their `estimated` flag; everything else stays
+* on the heuristic.
+*/
+function buildContextBreakdown(snapshot) {
+	const exact = snapshot.exact;
+	const systemExact = typeof exact?.system === "number";
+	const rulesTokens = snapshot.rulesBlock ? estimateTokens(snapshot.rulesBlock) : 0;
+	const rulesItems = (snapshot.rulesFiles ?? []).map((f) => ({
+		id: f.path,
+		label: f.path,
+		tokens: 0,
+		estimated: false
+	}));
+	const skillsTokens = snapshot.skillsCatalog ? estimateTokens(snapshot.skillsCatalog) : 0;
+	const mcpInstructionsTokens = snapshot.mcpInstructions ? estimateTokens(snapshot.mcpInstructions) : 0;
+	const subagentTokens = snapshot.subagentDefs ? estimateTokens(snapshot.subagentDefs) : 0;
+	const embeddedSubsections = rulesTokens + skillsTokens + mcpInstructionsTokens + subagentTokens;
+	const systemTotal = systemExact ? exact.system : estimateTokens(snapshot.system);
+	const baseSystemTokens = Math.max(0, systemTotal - embeddedSubsections);
+	const nativeToolsEst = sumEstimate(snapshot.toolsJson);
+	const mcpDisclosed = snapshot.mcpGroups.map(mcpGroupTokens);
+	const mcpToolsEst = mcpDisclosed.reduce((a, g) => a + g.total, 0);
+	let nativeToolsTokens = nativeToolsEst;
+	let mcpToolsTokens = mcpToolsEst;
+	let toolsEstimated = true;
+	if (systemExact && typeof exact?.systemAndTools === "number") {
+		const exactToolsTotal = Math.max(0, exact.systemAndTools - exact.system);
+		const estTotal = nativeToolsEst + mcpToolsEst;
+		if (estTotal > 0) {
+			nativeToolsTokens = Math.round(exactToolsTotal * (nativeToolsEst / estTotal));
+			mcpToolsTokens = exactToolsTotal - nativeToolsTokens;
+		} else {
+			nativeToolsTokens = exactToolsTotal;
+			mcpToolsTokens = 0;
+		}
+		toolsEstimated = false;
+	}
+	const live = [];
+	const push = (id, tokens, estimated, items) => {
+		if (tokens <= 0 && !items?.length) return;
+		live.push({
+			id,
+			label: LABELS[id],
+			tokens: Math.max(0, tokens),
+			estimated,
+			...items?.length ? { items } : {}
+		});
+	};
+	push("systemPrompt", baseSystemTokens, !systemExact);
+	push("rules", rulesTokens, true, rulesItems);
+	push("skills", skillsTokens, true);
+	push("mcpInstructions", mcpInstructionsTokens, true);
+	push("subagentDefs", subagentTokens, true);
+	push("tools", nativeToolsTokens, toolsEstimated, snapshot.toolItems?.map((t) => ({
+		id: t.name,
+		label: t.name,
+		tokens: estimateTokens(t.json),
+		estimated: true,
+		...t.description ? { description: t.description } : {}
+	})));
+	push("mcpTools", mcpToolsTokens, toolsEstimated, mcpDisclosed.flatMap((g) => g.items));
+	const accountedStatic = live.reduce((a, c) => a + c.tokens, 0);
+	push("conversation", Math.max(0, snapshot.used - accountedStatic), !(systemExact && !toolsEstimated));
+	const deferred = [];
+	const deferredNativeTools = sumEstimate(snapshot.deferredToolsJson);
+	if (deferredNativeTools > 0) deferred.push({
+		id: "toolsDeferred",
+		label: LABELS.toolsDeferred,
+		tokens: deferredNativeTools,
+		estimated: true,
+		deferred: true
+	});
+	const deferredMcp = snapshot.deferredMcpGroups.map(mcpGroupTokens);
+	const deferredMcpTotal = deferredMcp.reduce((a, g) => a + g.total, 0);
+	if (deferredMcpTotal > 0) deferred.push({
+		id: "mcpToolsDeferred",
+		label: LABELS.mcpToolsDeferred,
+		tokens: deferredMcpTotal,
+		estimated: true,
+		deferred: true,
+		items: deferredMcp.flatMap((g) => g.items)
+	});
+	if (snapshot.autocompactBuffer > 0) deferred.push({
+		id: "autocompactBuffer",
+		label: LABELS.autocompactBuffer,
+		tokens: snapshot.autocompactBuffer,
+		estimated: false,
+		deferred: true
+	});
+	const free = Math.max(0, snapshot.effectiveWindow - snapshot.used);
+	deferred.push({
+		id: "freeSpace",
+		label: LABELS.freeSpace,
+		tokens: free,
+		estimated: false,
+		deferred: true
+	});
+	const categories = [...live, ...deferred];
+	const hasEstimates = live.some((c) => c.estimated && c.tokens > 0);
+	const fraction = snapshot.effectiveWindow > 0 ? Math.max(0, Math.min(1, snapshot.used / snapshot.effectiveWindow)) : 0;
+	return {
+		modelId: snapshot.modelId,
+		used: snapshot.used,
+		effectiveWindow: snapshot.effectiveWindow,
+		fraction,
+		categories,
+		hasEstimates,
+		...snapshot.usage ? { usage: snapshot.usage } : {},
+		...snapshot.extensionSections?.length ? { extensionSections: snapshot.extensionSections } : {},
+		...snapshot.activeSkills?.length ? { activeSkills: snapshot.activeSkills } : {}
+	};
+}
+//#endregion
+//#region src/chat/context-segments.ts
+/**
+* Context segments — pure transforms.
+*
+* Sibling to `context-breakdown.ts`: where that module answers "how many
+* tokens is each part of my context", this one answers "what IS each part,
+* and where did it come from". It turns the same assembled-prompt pieces into
+* a flat list of {@link ContextSegment}s carrying the actual TEXT plus its
+* provenance, so a UI can list every chunk loaded by default in a session,
+* let the user read it, and open the file behind it when there is one.
+*
+* No React, no node — a browser-context renderer imports these via
+* `zidane/chat/pure`.
+*
+* Provenance is honest about what can and can't be opened:
+*   - `'file'`      — a real path on disk (AGENTS.md / CLAUDE.md / ruler md).
+*                     The only origin that carries `path`, hence the only one
+*                     a host can hand to `$EDITOR`.
+*   - `'built-in'`  — compiled into the binary (base doctrine).
+*   - `'generated'` — assembled at prompt time from discovered state (the
+*                     skills catalog is rendered from the skill manifests,
+*                     the searchable-tools catalog from lazy MCP tools).
+*   - `'mcp'`       — served by a remote MCP server at connect time.
+*/
+/**
+* Remove the first occurrence of `part` from `whole`, collapsing the blank-line
+* run left AT THE JOIN.
+*
+* Used to carve the rules block out of the base system so the "System prompt"
+* segment reports only doctrine + env. Substring-based because that's the
+* contract the assembly documents (`rulesBlock` IS a substring of
+* `baseSystem`); a miss leaves `whole` untouched, which degrades to
+* over-reporting the base row rather than dropping text on the floor.
+*
+* The collapse is deliberately scoped to the seam. An earlier version ran
+* `/\n{3,}/g` over the whole result, which rewrote blank-line runs ANYWHERE in
+* the doctrine — and this tab exists precisely so the user can read what is in
+* context, not a reflowed approximation of it. Interior bytes now survive
+* verbatim; only the newlines that met when `part` was excised are normalized,
+* plus a `trim()` so a segment can't open or close on blank lines.
+*/
+function removeFirst(whole, part) {
+	if (!part) return whole;
+	const at = whole.indexOf(part);
+	if (at < 0) return whole;
+	const before = whole.slice(0, at);
+	const after = whole.slice(at + part.length);
+	const trailing = /\n*$/.exec(before)?.[0] ?? "";
+	const leading = /^\n*/.exec(after)?.[0] ?? "";
+	const seam = trailing.length + leading.length >= 2 ? "\n\n" : `${trailing}${leading}`;
+	return `${before.slice(0, before.length - trailing.length)}${seam}${after.slice(leading.length)}`.trim();
+}
+/**
+* Best-effort display name for an instruction file: its basename, with the
+* parent directory prefixed when the basename alone would be ambiguous
+* (`AGENTS.md` appears at up to four paths per scope). Path-separator handling
+* covers both POSIX and Windows so this stays node-free.
+*/
+function fileLabel(path) {
+	const parts = path.split(/[/\\]/).filter(Boolean);
+	const base = parts.at(-1) ?? path;
+	const parent = parts.at(-2);
+	return parent?.startsWith(".") ? `${parent}/${base}` : base;
+}
+/**
+* Shape assembled-prompt pieces into a flat, render-ready segment list.
+*
+* Order is prompt order — base doctrine, then instruction files (broadest
+* scope first, as `discoverAgentsMd` returns them), then the appended
+* catalogs. Empty / whitespace-only pieces are dropped so the list never
+* shows a zero-byte row.
+*/
+function buildContextSegments(input) {
+	const segments = [];
+	const push = (seg) => {
+		if (!seg.text.trim()) return;
+		segments.push({
+			...seg,
+			tokens: estimateTokens(seg.text)
+		});
+	};
+	const base = input.baseSystem ?? input.system ?? "";
+	const overridden = input.systemPath !== void 0;
+	push({
+		id: "system",
+		label: "System prompt",
+		origin: overridden ? "file" : "built-in",
+		detail: overridden ? "SYSTEM.md override + environment" : "doctrine + environment",
+		text: input.rulesBlock ? removeFirst(base, input.rulesBlock) : base,
+		...input.systemPath !== void 0 ? { path: input.systemPath } : {}
+	});
+	for (const file of input.rulesFiles ?? []) push({
+		id: `rules:${file.path}`,
+		label: fileLabel(file.path),
+		origin: "file",
+		...file.source ? { detail: file.source } : {},
+		text: file.contents,
+		path: file.path
+	});
+	push({
+		id: "skills",
+		label: "Skills catalog",
+		origin: "generated",
+		detail: "name + description per skill (bodies load on activation)",
+		text: input.skillsCatalog ?? ""
+	});
+	push({
+		id: "mcp-instructions",
+		label: "MCP instructions",
+		origin: "mcp",
+		detail: "served by the connected servers",
+		text: input.mcpInstructions ?? ""
+	});
+	push({
+		id: "subagent-defs",
+		label: "Searchable tools",
+		origin: "generated",
+		detail: "name + description per lazy MCP tool (schemas load via tool_search)",
+		text: input.subagentDefs ?? ""
+	});
+	return segments;
+}
+//#endregion
+export { normalizeBadgeTarget as C, normalizeBadgeEffect as S, sessionBadgeTarget as T, badgePromptText as _, normalizePanelLoadContext as a, extensionBadgeActions as b, createReferenceResolver as c, bindingAlternatives as d, canonicalKeyName as f, badgeMenu as g, artifactBadgeTarget as h, normalizePanelContent as i, findReferences as l, parseBindingSpecs as m, buildContextBreakdown as n, panelBadgeText as o, parseBindingSpec as p, PANEL_CONTENT_LIMITS as r, compileReferencePattern as s, buildContextSegments as t, referenceProviderWires as u, builtinBadgeActions as v, runBadgeAction as w, mergeBadgeMenu as x, builtinBadgeEffect as y };
+
+//# sourceMappingURL=context-segments-BHKlagL6.js.map