@agimon-ai/po-ui 0.0.0-alpha.0

package/dist/index-Dpzvl-vg.d.mts

@@ -0,0 +1,103 @@
+import { FooterTextColor } from "@agimon-ai/po-core/footer";
+//#region src/services/theme/index.d.ts
+declare const DEFAULT_THEME_NAME = "po-dark";
+/** Stable semantic color shared by every UI surface that identifies an agent run. */
+declare function agentIdentityColor(identity: string): FooterTextColor;
+/**
+ * Prefer the identity's stable color, then walk the palette to avoid reusing a
+ * color already visible on the same surface. Once every color is occupied,
+ * reuse the stable preference rather than changing existing assignments.
+ */
+declare function allocateAgentIdentityColor(identity: string, occupied: ReadonlySet<FooterTextColor>): FooterTextColor;
+declare const DEFAULT_THEME: {
+  readonly $schema: 'https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json';
+  readonly name: "po-dark";
+  readonly vars: {
+    readonly bg: '#1c1c1c';
+    readonly bgAlt: '#171717';
+    readonly bgActive: '#2b2b2b';
+    readonly bgHover: '#2b2b2b';
+    readonly fg: '#dedede';
+    readonly fgAlt: '#b0b0b0';
+    readonly grey: '#343434';
+    readonly greyAlt: '#555555';
+    readonly blue: '#8cb5cc';
+    readonly darkBlue: '#284b64';
+    readonly cyan: '#8fc8c7';
+    readonly green: '#81cca3';
+    readonly lightGreen: '#a5d9b5';
+    readonly teal: '#8ec1ab';
+    readonly orange: '#d3ad83';
+    readonly red: '#e99185';
+    readonly violet: '#b0a0ce';
+    readonly magenta: '#c19aae';
+    readonly yellow: '#d6be82';
+    readonly lightYellow: '#e1cf9e';
+    readonly comment: '#a4a4a4';
+    readonly diffAddedBg: '#152d20';
+    readonly diffRemovedBg: '#35201b';
+  };
+  readonly colors: {
+    readonly accent: 'green';
+    readonly border: 'greyAlt';
+    readonly borderAccent: 'green';
+    readonly borderMuted: 'grey';
+    readonly success: 'green';
+    readonly error: 'red';
+    readonly warning: 'yellow';
+    readonly muted: 'fgAlt';
+    readonly dim: 'comment';
+    readonly text: 'fg';
+    readonly thinkingText: 'fgAlt';
+    readonly selectedBg: 'bgHover';
+    readonly userMessageBg: 'bgActive';
+    readonly userMessageText: 'fg';
+    readonly customMessageBg: '#292c2a';
+    readonly customMessageText: 'fg';
+    readonly customMessageLabel: 'green';
+    readonly toolPendingBg: 'bgAlt';
+    readonly toolSuccessBg: 'diffAddedBg';
+    readonly toolErrorBg: 'diffRemovedBg';
+    readonly toolTitle: 'green';
+    readonly toolOutput: 'fg';
+    readonly mdHeading: 'magenta';
+    readonly mdLink: 'blue';
+    readonly mdLinkUrl: 'comment';
+    readonly mdCode: 'cyan';
+    readonly mdCodeBlock: 'lightYellow';
+    readonly mdCodeBlockBorder: 'greyAlt';
+    readonly mdQuote: 'fgAlt';
+    readonly mdQuoteBorder: 'greyAlt';
+    readonly mdHr: 'greyAlt';
+    readonly mdListBullet: 'green';
+    readonly toolDiffAdded: 'lightGreen';
+    readonly toolDiffRemoved: 'red';
+    readonly toolDiffContext: 'fgAlt';
+    readonly syntaxComment: 'comment';
+    readonly syntaxKeyword: 'blue';
+    readonly syntaxFunction: 'magenta';
+    readonly syntaxVariable: 'violet';
+    readonly syntaxString: 'green';
+    readonly syntaxNumber: 'orange';
+    readonly syntaxType: 'yellow';
+    readonly syntaxOperator: 'orange';
+    readonly syntaxPunctuation: 'fgAlt';
+    readonly thinkingOff: 'grey';
+    readonly thinkingMinimal: 'fgAlt';
+    readonly thinkingLow: 'darkBlue';
+    readonly thinkingMedium: 'blue';
+    readonly thinkingHigh: 'teal';
+    readonly thinkingXhigh: 'magenta';
+    readonly thinkingMax: 'red';
+    readonly bashMode: 'lightGreen';
+  };
+  readonly export: {
+    readonly pageBg: 'bg';
+    readonly cardBg: 'bgAlt';
+    readonly infoBg: '#3b3526';
+  };
+};
+declare function writeDefaultTheme(temporaryDirectory: string): Promise<string>;
+//#endregion
+export { writeDefaultTheme as a, allocateAgentIdentityColor as i, DEFAULT_THEME_NAME as n, agentIdentityColor as r, DEFAULT_THEME as t };
+//# sourceMappingURL=index-Dpzvl-vg.d.mts.map

package/dist/index-Dpzvl-vg.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Dpzvl-vg.d.mts","names":[],"sources":["../src/services/theme/index.ts"],"mappings":";;cAKa;;iBAqBG,mBAAmB,mBAAmB;;;;;;iBAStC,2BAA2B,kBAAkB,UAAU,YAAY,mBAAmB;cASzF;WACX;WAEA;WAGA;aACE;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aAEA;aACA;;WAEF;aACE;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aAEA;aACA;aACA;aACA;aACA;aACA;aACA;aAGA;aACA;aACA;aACA;aAEA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aAEA;aACA;aACA;aAEA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aACA;aAGA;aACA;aACA;aACA;aACA;aACA;aACA;aAEA;;WAEF;aACE;aACA;aACA;;;iBAIkB,kBAAkB,6BAA6B"}

package/dist/index.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_harnessMetadata = require("./harnessMetadata-Dw9Rb1nW.cjs");
+const require_telemetry = require("./telemetry-DMR6cIT1.cjs");
+const require_uiState = require("./uiState-rUwgKslb.cjs");
+const require_theme = require("./theme-2wveit5V.cjs");
+exports.DEFAULT_THEME = require_theme.DEFAULT_THEME;
+exports.DEFAULT_THEME_NAME = require_theme.DEFAULT_THEME_NAME;
+exports.DoomUiState = require_uiState.DoomUiState;
+exports.UI_EVENT = require_telemetry.UI_EVENT;
+exports.createUiTelemetry = require_telemetry.createUiTelemetry;
+exports.readDoomHarnessMetadata = require_harnessMetadata.readDoomHarnessMetadata;
+exports.writeDefaultTheme = require_theme.writeDefaultTheme;

package/dist/index.d.mts

@@ -0,0 +1,8 @@
+import { n as readDoomHarnessMetadata, t as DoomHarnessMetadata } from "./harnessMetadata-CzsdGAxL.mjs";
+import { a as UiTelemetryOptions, i as UiTelemetry, n as UiEventAttributes, o as createUiTelemetry, r as UiEventName, t as UI_EVENT } from "./index-Bx49wmE7.mjs";
+import { n as LeaderOption, r as LeaderSnapshot, t as DoomUiState } from "./uiState-Binu4nUb.mjs";
+import { a as writeDefaultTheme, n as DEFAULT_THEME_NAME, t as DEFAULT_THEME } from "./index-Dpzvl-vg.mjs";
+import { ConfigChoice, ConfigField, ConfigSection, ConfigStep, DoomConfigActionInput, DoomConfigContributionHandle, DoomConfigContributionOptions } from "@agimon-ai/po-core/config";
+import { DoomFooterContributionDefinition, DoomFooterContributionHandle, DoomFooterContributionValue } from "@agimon-ai/po-core/footer";
+import { DoomLeaderContributionHandle, LeaderBinding as DoomLeaderBinding, LeaderCommand as DoomLeaderCommand, LeaderContribution as DoomLeaderContribution, LeaderSegment as DoomLeaderSegment } from "@agimon-ai/po-core/leader";
+export { type ConfigChoice, type ConfigField, type ConfigSection, type ConfigStep, DEFAULT_THEME, DEFAULT_THEME_NAME, type DoomConfigActionInput, type DoomConfigContributionHandle, type DoomConfigContributionOptions, type DoomFooterContributionDefinition, type DoomFooterContributionHandle, type DoomFooterContributionValue, type DoomHarnessMetadata, type DoomLeaderBinding, type DoomLeaderCommand, type DoomLeaderContribution, type DoomLeaderContributionHandle, type DoomLeaderSegment, DoomUiState, type LeaderOption, type LeaderSnapshot, UI_EVENT, type UiEventAttributes, type UiEventName, type UiTelemetry, type UiTelemetryOptions, createUiTelemetry, readDoomHarnessMetadata, writeDefaultTheme };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { t as readDoomHarnessMetadata } from "./harnessMetadata-DkMSJutN.mjs";
+import { n as createUiTelemetry, t as UI_EVENT } from "./telemetry--EgKB9ei.mjs";
+import { t as DoomUiState } from "./uiState-G_Pso-5i.mjs";
+import { a as writeDefaultTheme, n as DEFAULT_THEME_NAME, t as DEFAULT_THEME } from "./theme-Byj_dBlT.mjs";
+export { DEFAULT_THEME, DEFAULT_THEME_NAME, DoomUiState, UI_EVENT, createUiTelemetry, readDoomHarnessMetadata, writeDefaultTheme };

package/dist/leader.d.mts

@@ -0,0 +1,2 @@
+import { DoomLeaderActionHandlerOptions, DoomLeaderContributionHandle, LeaderAction as DoomLeaderExtensionAction, LeaderBinding as DoomLeaderBinding, LeaderCommand as DoomLeaderCommand, LeaderContribution as DoomLeaderContribution, LeaderSegment as DoomLeaderSegment } from "@agimon-ai/po-core/leader";
+export type { DoomLeaderActionHandlerOptions, DoomLeaderBinding, DoomLeaderCommand, DoomLeaderContribution, DoomLeaderContributionHandle, DoomLeaderExtensionAction, DoomLeaderSegment };

package/dist/leader.mjs

@@ -0,0 +1 @@
+export {};

package/dist/leaderRegistry.cjs

@@ -0,0 +1,515 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/services/leaderRegistry/index.ts
+const CORE_SOURCE = "@agimon-ai/po-ui";
+const UNKNOWN_SOURCE = "unknown";
+const ROOT_LABEL = "leader";
+const DEFAULT_OPTION_ORDER = 500;
+const MAX_OPTION_ORDER = 1e3;
+const MAX_PATH_LENGTH = 4;
+const MAX_SOURCE_LENGTH = 128;
+const MAX_BINDING_ID_LENGTH = 128;
+const MAX_LABEL_LENGTH = 32;
+const MAX_DETAIL_LENGTH = 80;
+const MAX_COMMAND_NAME_LENGTH = 64;
+const MAX_COMMAND_ARGUMENT_LENGTH = 256;
+const MAX_ACTION_NAME_LENGTH = 128;
+const SAFE_KEY = /^[a-z0-9]$/;
+const SAFE_IDENTIFIER = /^[a-z0-9][a-z0-9._:-]*$/;
+const SAFE_SOURCE = /^[A-Za-z0-9@][A-Za-z0-9@/._:-]*$/;
+const SAFE_COMMAND_NAME = /^[a-z0-9][a-z0-9:_-]*$/;
+const C0_CONTROL_MAX = 31;
+const DELETE_CHARACTER = 127;
+const MODEL_GROUP = {
+	key: "m",
+	label: "models",
+	detail: "model and thinking level",
+	order: 10
+};
+const SESSION_GROUP = {
+	key: "s",
+	label: "sessions",
+	detail: "history, forks and branches",
+	order: 30
+};
+const EXTENSION_GROUP = {
+	key: "e",
+	label: "extension",
+	detail: "tools, skills and config",
+	order: 50
+};
+const HELP_GROUP = {
+	key: "h",
+	label: "help",
+	detail: "package docs and logs",
+	order: 70
+};
+const QUIT_GROUP = {
+	key: "q",
+	label: "quit",
+	detail: "leave the session",
+	order: 90
+};
+function coreBinding(id, path, action) {
+	return {
+		id,
+		source: CORE_SOURCE,
+		path,
+		action
+	};
+}
+const CORE_BINDINGS = [
+	coreBinding("model.select", [MODEL_GROUP, {
+		key: "m",
+		label: "select",
+		detail: "choose model",
+		order: 10
+	}], {
+		type: "app",
+		action: "app.model.select"
+	}),
+	coreBinding("model.next", [MODEL_GROUP, {
+		key: "n",
+		label: "next",
+		detail: "cycle model",
+		order: 20
+	}], {
+		type: "app",
+		action: "app.model.cycleForward"
+	}),
+	coreBinding("thinking.cycle", [MODEL_GROUP, {
+		key: "t",
+		label: "thinking",
+		detail: "cycle level",
+		order: 30
+	}], {
+		type: "app",
+		action: "app.thinking.cycle"
+	}),
+	coreBinding("tools.open", [EXTENSION_GROUP, {
+		key: "t",
+		label: "tools",
+		detail: "browse tools",
+		order: 20
+	}], {
+		type: "command",
+		command: { name: "tools" }
+	}),
+	coreBinding("config.open", [EXTENSION_GROUP, {
+		key: "c",
+		label: "config",
+		detail: "settings",
+		order: 30
+	}], {
+		type: "command",
+		command: { name: "config" }
+	}),
+	coreBinding("session.new", [SESSION_GROUP, {
+		key: "n",
+		label: "new",
+		detail: "fresh session",
+		order: 10
+	}], {
+		type: "app",
+		action: "app.session.new"
+	}),
+	coreBinding("session.resume", [SESSION_GROUP, {
+		key: "r",
+		label: "resume",
+		detail: "open history",
+		order: 20
+	}], {
+		type: "app",
+		action: "app.session.resume"
+	}),
+	coreBinding("session.tree", [SESSION_GROUP, {
+		key: "t",
+		label: "tree",
+		detail: "branch view",
+		order: 30
+	}], {
+		type: "app",
+		action: "app.session.tree"
+	}),
+	coreBinding("session.fork", [SESSION_GROUP, {
+		key: "f",
+		label: "fork",
+		detail: "from selection",
+		order: 40
+	}], {
+		type: "app",
+		action: "app.session.fork"
+	}),
+	coreBinding("help.hotkeys", [HELP_GROUP, {
+		key: "h",
+		label: "hotkeys",
+		detail: "show bindings"
+	}], {
+		type: "command",
+		command: { name: "hotkeys" }
+	}),
+	coreBinding("app.exit", [QUIT_GROUP, {
+		key: "q",
+		label: "quit",
+		detail: "exit Pi"
+	}], {
+		type: "app",
+		action: "app.exit"
+	})
+];
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function diagnostic(source, message, bindingId) {
+	return {
+		source,
+		message,
+		...bindingId ? { bindingId } : {}
+	};
+}
+function containsControlCharacter(value) {
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit <= C0_CONTROL_MAX || codeUnit === DELETE_CHARACTER) return true;
+	}
+	return false;
+}
+function readRequiredText(value, field, maximumLength, source, diagnostics, bindingId) {
+	if (typeof value !== "string" || !value.trim()) {
+		diagnostics.push(diagnostic(source, `${field} must be a non-empty string.`, bindingId));
+		return;
+	}
+	const text = value.trim();
+	if (text.length > maximumLength || containsControlCharacter(text)) {
+		diagnostics.push(diagnostic(source, `${field} must be at most ${maximumLength} characters and contain no control characters.`, bindingId));
+		return;
+	}
+	return text;
+}
+function readOptionalText(value, field, maximumLength, source, diagnostics, bindingId) {
+	if (value === void 0) return void 0;
+	return readRequiredText(value, field, maximumLength, source, diagnostics, bindingId);
+}
+function parseSegment(value, source, bindingId, index, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(diagnostic(source, `bindings[].path[${index}] must be an object.`, bindingId));
+		return;
+	}
+	const key = readRequiredText(value.key, `bindings[].path[${index}].key`, 1, source, diagnostics, bindingId);
+	const label = readRequiredText(value.label, `bindings[].path[${index}].label`, MAX_LABEL_LENGTH, source, diagnostics, bindingId);
+	const detail = readOptionalText(value.detail, `bindings[].path[${index}].detail`, MAX_DETAIL_LENGTH, source, diagnostics, bindingId);
+	const tone = value.tone === "default" || value.tone === "exit" ? value.tone : void 0;
+	let order;
+	if (value.order !== void 0) {
+		if (!Number.isInteger(value.order) || value.order < 0 || value.order > MAX_OPTION_ORDER) diagnostics.push(diagnostic(source, `bindings[].path[${index}].order must be an integer from 0 to ${MAX_OPTION_ORDER}.`, bindingId));
+		else order = value.order;
+	}
+	if (!key || !label || !SAFE_KEY.test(key)) {
+		if (key && !SAFE_KEY.test(key)) diagnostics.push(diagnostic(source, `bindings[].path[${index}].key must match ${SAFE_KEY}.`, bindingId));
+		return;
+	}
+	return {
+		key,
+		label,
+		...detail ? { detail } : {},
+		...tone ? { tone } : {},
+		...order === void 0 ? {} : { order }
+	};
+}
+function parseCommand(value, source, bindingId, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(diagnostic(source, "bindings[].command must be an object.", bindingId));
+		return;
+	}
+	const name = readRequiredText(value.name, "bindings[].command.name", MAX_COMMAND_NAME_LENGTH, source, diagnostics, bindingId);
+	const args = readOptionalText(value.args, "bindings[].command.args", MAX_COMMAND_ARGUMENT_LENGTH, source, diagnostics, bindingId);
+	if (!name || !SAFE_COMMAND_NAME.test(name)) {
+		if (name && !SAFE_COMMAND_NAME.test(name)) diagnostics.push(diagnostic(source, `bindings[].command.name must match ${SAFE_COMMAND_NAME}.`, bindingId));
+		return;
+	}
+	return {
+		name,
+		...args ? { args } : {}
+	};
+}
+function parseExtensionAction(value, source, bindingId, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(diagnostic(source, "bindings[].action must be an object.", bindingId));
+		return;
+	}
+	const name = readRequiredText(value.name, "bindings[].action.name", MAX_ACTION_NAME_LENGTH, source, diagnostics, bindingId);
+	if (!name || !SAFE_IDENTIFIER.test(name)) {
+		if (name && !SAFE_IDENTIFIER.test(name)) diagnostics.push(diagnostic(source, `bindings[].action.name must match ${SAFE_IDENTIFIER}.`, bindingId));
+		return;
+	}
+	return { name };
+}
+function parseBinding(value, source, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(diagnostic(source, "bindings[] must be an object."));
+		return;
+	}
+	const bindingId = readRequiredText(value.id, "bindings[].id", MAX_BINDING_ID_LENGTH, source, diagnostics);
+	if (!bindingId) return void 0;
+	if (!SAFE_IDENTIFIER.test(bindingId)) {
+		diagnostics.push(diagnostic(source, `bindings[].id must match ${SAFE_IDENTIFIER}.`, bindingId));
+		return;
+	}
+	if (!Array.isArray(value.path) || value.path.length === 0 || value.path.length > MAX_PATH_LENGTH) {
+		diagnostics.push(diagnostic(source, `bindings[].path must contain between 1 and ${MAX_PATH_LENGTH} segments.`, bindingId));
+		return;
+	}
+	const path = value.path.map((segment, index) => parseSegment(segment, source, bindingId, index, diagnostics));
+	const hasCommand = Object.hasOwn(value, "command");
+	if (hasCommand === Object.hasOwn(value, "action")) {
+		diagnostics.push(diagnostic(source, "bindings[] must contain exactly one of command or action.", bindingId));
+		return;
+	}
+	const target = hasCommand ? { command: parseCommand(value.command, source, bindingId, diagnostics) } : { action: parseExtensionAction(value.action, source, bindingId, diagnostics) };
+	if (path.some((segment) => segment === void 0)) return void 0;
+	if ("command" in target) {
+		if (!target.command) return void 0;
+		return {
+			id: bindingId,
+			path,
+			command: target.command
+		};
+	}
+	if (!target.action) return void 0;
+	return {
+		id: bindingId,
+		path,
+		action: target.action
+	};
+}
+function parseContribution(value) {
+	const diagnostics = [];
+	if (!isRecord(value)) return { diagnostics: [diagnostic(UNKNOWN_SOURCE, "Leader contribution must be an object.")] };
+	const source = readRequiredText(value.source, "source", MAX_SOURCE_LENGTH, UNKNOWN_SOURCE, diagnostics);
+	if (!source) return { diagnostics };
+	if (!SAFE_SOURCE.test(source)) {
+		diagnostics.push(diagnostic(source, `source must match ${SAFE_SOURCE}.`));
+		return { diagnostics };
+	}
+	if (!Array.isArray(value.bindings)) return { diagnostics: [diagnostic(source, "bindings must be an array.")] };
+	const bindings = value.bindings.map((binding) => parseBinding(binding, source, diagnostics));
+	const duplicateIds = bindings.flatMap((binding) => binding ? [binding.id] : []).filter((id, index, ids) => ids.indexOf(id) !== index);
+	for (const id of new Set(duplicateIds)) diagnostics.push(diagnostic(source, `Binding id '${id}' is duplicated.`, id));
+	if (diagnostics.length > 0 || bindings.some((binding) => binding === void 0)) return { diagnostics };
+	return {
+		contribution: {
+			source,
+			bindings
+		},
+		diagnostics
+	};
+}
+function optionOrder(segment) {
+	return segment.order ?? DEFAULT_OPTION_ORDER;
+}
+function cloneAction(action) {
+	if (action.type === "command") return {
+		type: "command",
+		command: { ...action.command }
+	};
+	if (action.type === "app") return {
+		type: "app",
+		action: action.action
+	};
+	return {
+		type: "extension",
+		source: action.source,
+		action: { ...action.action }
+	};
+}
+function createRootNode() {
+	return {
+		key: "",
+		label: ROOT_LABEL,
+		order: 0,
+		owner: CORE_SOURCE,
+		children: /* @__PURE__ */ new Map()
+	};
+}
+function pathLabel(path) {
+	return `SPC ${path.map((segment) => segment.key).join(" ")}`;
+}
+/**
+* Whether a shared group prefix is worded the same way by both contributors.
+*
+* `detail` is left out on purpose: it is a subtitle, and these packages ship on
+* independent npm versions, so comparing it means one upgraded package disagrees
+* with every package that has not caught up.
+*
+* A mismatch is REPORTED, never fatal. Losing `SPC e s` because two packages
+* spell the `SPC e` group differently costs the user a key they can no longer
+* press, which is worse than a menu row worded by whoever registered first.
+*/
+function metadataMatches(node, segment) {
+	return node.label === segment.label && node.order === optionOrder(segment);
+}
+/** Every binding under a node, for a takeover message that says what it displaced. */
+function leafCount(node) {
+	if (node.children.size === 0) return node.action ? 1 : 0;
+	let total = 0;
+	for (const child of node.children.values()) total += leafCount(child);
+	return total;
+}
+/**
+* Inserts one binding, taking a key over from whoever holds it.
+*
+* LAST REGISTRATION WINS, and the diagnostics say who lost what. The rule this
+* replaced rejected the newcomer, which read as "warning plus nothing happened":
+* the key stayed bound to the first registrant, or - when the clash was only a
+* group label - to nobody at all. A takeover is recoverable in a way a dropped
+* binding is not: the tree is rebuilt from every stored contribution, so when
+* the winner unregisters, the displaced binding comes back on the next rebuild.
+*
+* Returns diagnostics rather than one issue, because a single insert can both
+* disagree about a group's wording and take a key from someone.
+*/
+function insertBinding(root, binding) {
+	const diagnostics = [];
+	let current = root;
+	let firstMissing = -1;
+	for (const [index, segment] of binding.path.entries()) {
+		const existing = current.children.get(segment.key);
+		if (!existing) {
+			firstMissing = index;
+			break;
+		}
+		if (!metadataMatches(existing, segment)) diagnostics.push(diagnostic(binding.source, `${pathLabel(binding.path.slice(0, index + 1))} keeps the label from ${existing.owner}; the binding is registered.`, binding.id));
+		if (!existing.detail && segment.detail) existing.detail = segment.detail;
+		const isLeaf = index === binding.path.length - 1;
+		const displaced = leafCount(existing);
+		if (isLeaf && displaced > 0) {
+			diagnostics.push(diagnostic(binding.source, `${pathLabel(binding.path)} taken over from ${existing.owner}${displaced > 1 ? `, displacing ${displaced} bindings` : ""}.`, binding.id));
+			existing.children.clear();
+			delete existing.action;
+			delete existing.bindingId;
+		} else if (!isLeaf && existing.action) {
+			diagnostics.push(diagnostic(binding.source, `${pathLabel(binding.path.slice(0, index + 1))} taken over from ${existing.owner} to open a group.`, binding.id));
+			delete existing.action;
+			delete existing.bindingId;
+		}
+		if (isLeaf || existing.action === void 0) existing.owner = binding.source;
+		current = existing;
+	}
+	const start = firstMissing === -1 ? binding.path.length : firstMissing;
+	for (let index = start; index < binding.path.length; index += 1) {
+		const segment = binding.path[index];
+		const node = {
+			key: segment.key,
+			label: segment.label,
+			...segment.detail ? { detail: segment.detail } : {},
+			...segment.tone ? { tone: segment.tone } : {},
+			order: optionOrder(segment),
+			owner: binding.source,
+			children: /* @__PURE__ */ new Map()
+		};
+		current.children.set(segment.key, node);
+		current = node;
+	}
+	current.action = cloneAction(binding.action);
+	current.bindingId = binding.id;
+	current.owner = binding.source;
+	return diagnostics;
+}
+var DoomLeaderRegistry = class {
+	root = createRootNode();
+	contributions = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	diagnostics = [];
+	dirty = false;
+	constructor() {
+		this.rebuild();
+	}
+	register(value) {
+		const result = this.apply(value);
+		if (!result.accepted) return result;
+		this.rebuild();
+		return {
+			accepted: true,
+			diagnostics: this.getDiagnostics()
+		};
+	}
+	/** Records a contribution without rebuilding the whole tree immediately. */
+	registerDeferred(value) {
+		return this.apply(value);
+	}
+	apply(value) {
+		const parsed = parseContribution(value);
+		if (!parsed.contribution) return {
+			accepted: false,
+			diagnostics: parsed.diagnostics
+		};
+		this.contributions.delete(parsed.contribution.source);
+		if (parsed.contribution.bindings.length > 0) this.contributions.set(parsed.contribution.source, parsed.contribution.bindings);
+		this.dirty = true;
+		return {
+			accepted: true,
+			diagnostics: parsed.diagnostics
+		};
+	}
+	/** Rebuilds one batch and returns its deterministic conflict diagnostics. */
+	flush() {
+		if (this.dirty) this.rebuild();
+		return this.diagnostics.map((item) => ({ ...item }));
+	}
+	getGroup(path) {
+		this.flush();
+		let current = this.root;
+		for (const key of path) {
+			const next = current.children.get(key);
+			if (!next || next.action) return void 0;
+			current = next;
+		}
+		const options = [...current.children.values()].sort((left, right) => left.key.localeCompare(right.key)).map((node) => ({
+			key: node.key,
+			label: node.label,
+			...node.detail ? { detail: node.detail } : {},
+			...node.tone ? { tone: node.tone } : {},
+			hasChildren: node.children.size > 0,
+			...node.action ? { action: cloneAction(node.action) } : {}
+		}));
+		return {
+			label: current.label,
+			options
+		};
+	}
+	getDiagnostics() {
+		return this.flush();
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	rebuild() {
+		const nextRoot = createRootNode();
+		const diagnostics = [];
+		for (const binding of CORE_BINDINGS) {
+			const [issue] = insertBinding(nextRoot, binding);
+			if (issue) throw new Error(`Invalid core leader binding: ${issue.message}`);
+		}
+		for (const [source, bindings] of this.contributions.entries()) for (const binding of [...bindings].sort((left, right) => left.id.localeCompare(right.id))) diagnostics.push(...insertBinding(nextRoot, {
+			id: binding.id,
+			source,
+			path: binding.path,
+			action: "command" in binding ? {
+				type: "command",
+				command: binding.command
+			} : {
+				type: "extension",
+				source,
+				action: binding.action
+			}
+		}));
+		this.root = nextRoot;
+		this.diagnostics = diagnostics;
+		this.dirty = false;
+		for (const listener of this.listeners) listener();
+	}
+};
+//#endregion
+exports.DoomLeaderRegistry = DoomLeaderRegistry;
+
+//# sourceMappingURL=leaderRegistry.cjs.map