zidane 7.2.5 → 8.0.4

package/dist/panels-B6gRk4bf.js

@@ -1,789 +0,0 @@
-import { n as estimateTokens } from "./utils-ngQzYzZD.js";
-//#region src/tools/edit-utils.ts
-/**
-* Internal helpers shared between the `edit` and `multi_edit` tools.
-*
-* Not part of the public API — intentionally not re-exported from `tools/index.ts`
-* or the package barrel.
-*/
-/**
-* Count exact (non-overlapping) occurrences of `needle` in `haystack`.
-* Returns 0 for an empty needle — both edit tools reject empty `old_string`
-* up front, so this branch is defensive rather than semantic.
-*/
-function countExactMatches(haystack, needle) {
-	if (needle.length === 0) return 0;
-	let count = 0;
-	let idx = 0;
-	while (true) {
-		const next = haystack.indexOf(needle, idx);
-		if (next === -1) break;
-		count++;
-		idx = next + needle.length;
-	}
-	return count;
-}
-/** Map curly quotes (any of the four) to their straight ASCII equivalents. */
-function normalizeQuotes(str) {
-	return str.replaceAll("‘", "'").replaceAll("’", "'").replaceAll("“", "\"").replaceAll("”", "\"");
-}
-/**
-* Substitutions Anthropic's API applies to assistant output before the model
-* sees it. The model emits the sanitized form; the file on disk contains the
-* unsanitized form. We undo the substitutions on `old_string` so the search
-* lands on the actual file contents.
-*
-* Verbatim from `claude-code/tools/FileEditTool/utils.ts`.
-*/
-const DESANITIZATIONS = [
-	["<fnr>", "<function_results>"],
-	["<n>", "<name>"],
-	["</n>", "</name>"],
-	["<o>", "<output>"],
-	["</o>", "</output>"],
-	["<e>", "<error>"],
-	["</e>", "</error>"],
-	["<s>", "<system>"],
-	["</s>", "</system>"],
-	["<r>", "<result>"],
-	["</r>", "</result>"],
-	["< META_START >", "<META_START>"],
-	["< META_END >", "<META_END>"],
-	["< EOT >", "<EOT>"],
-	["< META >", "<META>"],
-	["< SOS >", "<SOS>"],
-	["\n\nH:", "\n\nHuman:"],
-	["\n\nA:", "\n\nAssistant:"]
-];
-/**
-* Apply the SDK desanitization table to a string. Exported so the edit tools
-* can apply it to `new_string` whenever `old_string` matched via a
-* desanitize-class fallback — keeps the file's unsanitized form on disk
-* instead of writing the model's abbreviated form back.
-*/
-function desanitize(s) {
-	let out = s;
-	for (const [from, to] of DESANITIZATIONS) out = out.replaceAll(from, to);
-	return out;
-}
-/**
-* Strip line-number prefixes from each line of a needle, used as a recovery
-* fallback when the model pastes a `read_file` chunk verbatim into
-* `old_string` — the on-disk file doesn't carry the metadata prefix.
-*
-* Accepts three separator characters so a model that learned on a different
-* agent stack still works here: `\t` (Claude Code compact, our default),
-* `|`, and `→`. Pattern: optional leading whitespace, 1-9 digits, then one
-* of `\t | →`. The 9-digit ceiling covers files up to ~1B lines without
-* overshooting into legitimate `\d{N}<sep>` content like Markdown table
-* cells with long numeric IDs.
-*/
-const LINE_NUMBER_PREFIX_RE = /^[ \t]*\d{1,9}[\t|\u2192]/gm;
-function stripLineNumberPrefixes(s) {
-	return s.replace(LINE_NUMBER_PREFIX_RE, "");
-}
-/**
-* Search `target` in `normFile` and slice the matching span out of the
-* original `haystack`, counting all non-overlapping occurrences. `normFile`
-* is the haystack with whatever transform (quotes / desanitize / combined)
-* was applied to make the indices align — slicing the original haystack
-* preserves the file's actual typography so `replace_all` writes back the
-* file's form, not the model's.
-*
-* Pre-condition: `normFile.length === haystack.length` (every transform
-* we use is one-to-one). Returns null on miss.
-*/
-function locateAndCount(haystack, normFile, target, via) {
-	const idx = normFile.indexOf(target);
-	if (idx === -1) return null;
-	const actual = haystack.slice(idx, idx + target.length);
-	let occ = 0;
-	let cursor = 0;
-	while (true) {
-		const next = normFile.indexOf(target, cursor);
-		if (next === -1) break;
-		occ++;
-		cursor = next + target.length;
-	}
-	return {
-		actual,
-		occurrences: occ,
-		via
-	};
-}
-function resolveOldString(haystack, needle) {
-	const exact = countExactMatches(haystack, needle);
-	if (exact > 0) return {
-		actual: needle,
-		occurrences: exact,
-		via: "exact"
-	};
-	const normNeedle = normalizeQuotes(needle);
-	const normFile = normalizeQuotes(haystack);
-	if (normNeedle !== needle || normFile !== haystack) {
-		const m = locateAndCount(haystack, normFile, normNeedle, "quotes");
-		if (m) return m;
-	}
-	const desan = desanitize(needle);
-	if (desan !== needle) {
-		const desanCount = countExactMatches(haystack, desan);
-		if (desanCount === 1) return {
-			actual: desan,
-			occurrences: desanCount,
-			via: "desanitize"
-		};
-	}
-	const combo = desanitize(normNeedle);
-	if (combo !== needle) {
-		const m = locateAndCount(haystack, normFile, combo, "quotes+desanitize");
-		if (m && m.occurrences === 1) return m;
-	}
-	const stripped = stripLineNumberPrefixes(needle);
-	if (stripped !== needle && stripped.trim().length > 0) {
-		const count = countExactMatches(haystack, stripped);
-		if (count > 0) return {
-			actual: stripped,
-			occurrences: count,
-			via: "line-numbers"
-		};
-		const strippedNorm = normalizeQuotes(stripped);
-		if (strippedNorm !== stripped || normFile !== haystack) {
-			const m = locateAndCount(haystack, normFile, strippedNorm, "quotes+line-numbers");
-			if (m) return m;
-		}
-	}
-	return null;
-}
-/**
-* Short human-readable label for a recovery path, used by `edit` /
-* `multi_edit` to flag non-exact matches in their result messages — when a
-* fallback mistargets, the model (and the user reading the transcript) can
-* see WHICH transform fired instead of silently trusting the edit.
-*/
-function describeVia(via) {
-	switch (via) {
-		case "exact": return "exact match";
-		case "quotes": return "curly-quote normalization";
-		case "desanitize": return "sanitization recovery (e.g. <n> → <name>)";
-		case "quotes+desanitize": return "sanitization recovery + curly-quote normalization";
-		case "line-numbers": return "line-number-prefix stripping";
-		case "quotes+line-numbers": return "line-number-prefix stripping + curly-quote normalization";
-	}
-}
-/**
-* Apply the same recovery transforms used to find `old_string` to
-* `new_string`, so the file gets back its native form: desanitize when
-* the model emitted `<n>` for `<name>`, strip line-number prefixes when
-* the match required them, then re-curlify when the match required
-* quote normalization. Shared between `edit` and `multi_edit`.
-*/
-function styleReplacementForVia(replacement, via, actual) {
-	let out = replacement;
-	if (via === "desanitize" || via === "quotes+desanitize") out = desanitize(out);
-	if (via === "line-numbers" || via === "quotes+line-numbers") out = stripLineNumberPrefixes(out);
-	if (via === "quotes" || via === "quotes+desanitize" || via === "quotes+line-numbers") out = preserveQuoteStyle(actual, out);
-	return out;
-}
-/**
-* When `old_string` matched via curly-quote normalization, re-style
-* `new_string` so the file's typography is preserved across the edit.
-* Detects whether the matched file region had curly singles, doubles, or
-* both, and applies the matching curlification to the replacement.
-*
-* Apostrophes in contractions (`don't`, `it's`) get the right-single curly
-* quote regardless of opening context — that's the canonical typographer's
-* convention for English. Other quotes use a simple
-* preceded-by-whitespace-or-opening-punctuation heuristic.
-*/
-function preserveQuoteStyle(actual, replacement) {
-	const hasDouble = actual.includes("“") || actual.includes("”");
-	const hasSingle = actual.includes("‘") || actual.includes("’");
-	if (!hasDouble && !hasSingle) return replacement;
-	let out = replacement;
-	if (hasDouble) out = applyCurly(out, "\"", "“", "”", false);
-	if (hasSingle) out = applyCurly(out, "'", "‘", "’", true);
-	return out;
-}
-function applyCurly(s, straight, left, right, contractionAware) {
-	const chars = [...s];
-	const result = [];
-	for (let i = 0; i < chars.length; i++) {
-		if (chars[i] !== straight) {
-			result.push(chars[i]);
-			continue;
-		}
-		if (contractionAware) {
-			const prev = i > 0 ? chars[i - 1] : "";
-			const next = i < chars.length - 1 ? chars[i + 1] : "";
-			if (/\p{L}/u.test(prev) && /\p{L}/u.test(next)) {
-				result.push(right);
-				continue;
-			}
-		}
-		result.push(isOpeningContext(chars, i) ? left : right);
-	}
-	return result.join("");
-}
-function isOpeningContext(chars, i) {
-	if (i === 0) return true;
-	const prev = chars[i - 1];
-	return prev === " " || prev === "	" || prev === "\n" || prev === "\r" || prev === "(" || prev === "[" || prev === "{" || prev === "—" || prev === "–";
-}
-//#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: "Subagent definitions",
-	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, subagent defs, 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, subagent defs).
-*   - `'generated'` — assembled at prompt time from discovered state (the
-*                     skills catalog is rendered from the skill manifests).
-*   - `'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: "Subagent definitions",
-		origin: "built-in",
-		text: input.subagentDefs ?? ""
-	});
-	return segments;
-}
-//#endregion
-//#region src/chat/cred-keys.ts
-/**
-* Credential-file key arithmetic, split from `./credentials` so the rules can
-* be enforced where credentials themselves must not be pulled in.
-*
-* `./credentials` reaches the provider registry (and through it the pi-ai
-* factories) for `credKeyOf`; the extension loader — an edge entrypoint that
-* validates descriptor keys at registration time — must stay clear of that
-* graph. This module is string arithmetic with no imports.
-*/
-/**
-* Separator between a provider's canonical key and a slot qualifier. Every
-* non-canonical slot (`#alt`, `#account:N`) starts with it, so the character is
-* reserved in descriptor credential keys outright.
-*/
-const CRED_KEY_SLOT_SEPARATOR = "#";
-/**
-* Reserved suffix marking a provider's SECOND credential slot.
-*
-* Not usable as (or as the tail of) a descriptor's credential key: `foo#alt`
-* holds `foo`'s alternate credential, so a provider claiming that name would
-* share storage with it.
-*/
-const ALTERNATE_CRED_KEY_SUFFIX = "#alt";
-/**
-* Reserved infix marking one of a provider's ADDITIONAL OAuth accounts:
-* `foo#account:1`, `foo#account:2`, …
-*/
-const ACCOUNT_CRED_KEY_INFIX = "#account:";
-/**
-* File key holding a provider's second credential, when it has one of each kind.
-*
-* The canonical key always holds the credential the user prefers; this sibling
-* holds the other. That one invariant is what makes preference selection free:
-* every existing reader (`applyApiKeyEnv`, the harness provider factories)
-* already resolves the canonical key, so "switch priority" is just moving two
-* objects between two keys — no precedence flag to interpret, no resolution
-* order to keep in sync across layers.
-*
-* A sibling key rather than a nested field because the canonical entry gets
-* REPLACED wholesale on token refresh; anything nested inside it would be
-* dropped by the next rotation. And older zidane versions look credentials up
-* by `credKeyOf`, so a suffixed key is simply invisible to them — they read the
-* preferred credential and behave exactly as before, which is why this needs no
-* migration or schema version.
-*/
-function alternateCredKey(fileKey) {
-	return `${fileKey}${ALTERNATE_CRED_KEY_SUFFIX}`;
-}
-/**
-* File key holding one of a provider's non-active OAuth accounts.
-*
-* Same sibling-key reasoning as {@link alternateCredKey}: the canonical key is
-* the active one, so a provider with three OAuth grants stores the active one
-* canonically and the other two under `#account:N`. `#alt` stays dedicated to
-* the other-kind (API key) alternate so files written by builds that predate
-* multi-account keep meaning the same thing.
-*/
-function accountCredKey(fileKey, n) {
-	return `${fileKey}${ACCOUNT_CRED_KEY_INFIX}${n}`;
-}
-/** True when `key` is one of `fileKey`'s `#account:N` slots. */
-function isAccountCredKey(fileKey, key) {
-	const prefix = `${fileKey}${ACCOUNT_CRED_KEY_INFIX}`;
-	return key.startsWith(prefix) && /^\d+$/.test(key.slice(prefix.length));
-}
-/**
-* Smallest `#account:N` key of `fileKey` not present in `existing`.
-*
-* Deterministic rather than random so a file hand-edited or written by two
-* processes in sequence stays readable; the write lock keeps it collision-free.
-*/
-function nextAccountCredKey(fileKey, existing) {
-	const taken = new Set(existing);
-	for (let n = 1;; n++) {
-		const key = accountCredKey(fileKey, n);
-		if (!taken.has(key)) return key;
-	}
-}
-/**
-* Name shown for an OAuth account that was never given one.
-*
-* Also what a first OAuth login is stored under, so a second account has
-* something to be told apart from. Pre-multi-account files hold unnamed
-* grants; {@link oauthAccountLabel} makes them read the same.
-*/
-const DEFAULT_OAUTH_ACCOUNT_LABEL = "Default";
-/** Trimmed user-given account name, or {@link DEFAULT_OAUTH_ACCOUNT_LABEL}. */
-function oauthAccountLabel(credential) {
-	return (typeof credential.label === "string" ? credential.label.trim() : "") || "Default";
-}
-/**
-* True when a key claims a reserved slot namespace.
-*
-* Built-in keys are plain identifiers (`anthropic`, `openai-codex`), but
-* `ProviderDescriptor.key` / `credentialFileKey` are open strings — so the
-* reservation is checked, not assumed.
-*/
-function isReservedCredKey(fileKey) {
-	return fileKey.includes("#");
-}
-//#endregion
-//#region src/extensions/panels.ts
-/** 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: 512 * 1024
-};
-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
-export { resolveOldString as _, ALTERNATE_CRED_KEY_SUFFIX as a, accountCredKey as c, isReservedCredKey as d, nextAccountCredKey as f, describeVia as g, buildContextBreakdown as h, ACCOUNT_CRED_KEY_INFIX as i, alternateCredKey as l, buildContextSegments as m, normalizePanelContent as n, CRED_KEY_SLOT_SEPARATOR as o, oauthAccountLabel as p, panelBadgeText as r, DEFAULT_OAUTH_ACCOUNT_LABEL as s, PANEL_CONTENT_LIMITS as t, isAccountCredKey as u, stripLineNumberPrefixes as v, styleReplacementForVia as y };
-
-//# sourceMappingURL=panels-B6gRk4bf.js.map