@agimon-ai/po-web-dashboard 0.0.0-alpha.0

package/dist/web/lib/pluginRegistry.cjs

@@ -0,0 +1,675 @@
+const require_leaderTree = require("./leaderTree.cjs");
+const require_pluginScopes = require("./pluginScopes.cjs");
+const require_templateCatalog = require("./templateCatalog.cjs");
+//#region src/web/lib/pluginRegistry.ts
+/** The slots the host itself declares; a plugin's own slots are namespaced by its id instead. */
+const HOST_SLOTS = {
+	overlay: "overlay",
+	rail: "rail",
+	context: "context",
+	selectionBar: "selection-bar",
+	activity: "activity",
+	composerActions: "composer-actions",
+	composerMenu: "composer-menu",
+	sessionMenu: "session-menu",
+	/** A workspace plugin fill here replaces the host's new-session dialog for that workspace. */
+	newSession: "new-session"
+};
+const SLOT_SEPARATOR = ".";
+const DEFAULT_FILL_ORDER = 1e3;
+const RESERVED_PLUGIN_IDS = new Set(Object.values(HOST_SLOTS));
+/** The keyed slot an activity group opens: sections fill it and render as the group's body. */
+function activityGroupSlot(name) {
+	return `${HOST_SLOTS.activity}${SLOT_SEPARATOR}${name}`;
+}
+function emptyState() {
+	return {
+		plugins: [],
+		tabs: [],
+		dockFaces: [],
+		channels: /* @__PURE__ */ new Map(),
+		commands: [],
+		contextActions: [],
+		userMessageActions: [],
+		leaderBindings: [],
+		selectionAxes: [],
+		minorModes: [],
+		activityGroups: [],
+		settingsSections: [],
+		settingsPanels: [],
+		toolRenderers: /* @__PURE__ */ new Map(),
+		toolMatchers: [],
+		slots: /* @__PURE__ */ new Map(),
+		fills: /* @__PURE__ */ new Map(),
+		fileLinks: [],
+		diagnostics: []
+	};
+}
+let defaultState = emptyState();
+let installingState = defaultState;
+let defaultInstalled = false;
+const sessionStates = /* @__PURE__ */ new Map();
+const workspaceStates = /* @__PURE__ */ new Map();
+const sessionPlugins = /* @__PURE__ */ new Map();
+const sessionWorkspaces = /* @__PURE__ */ new Map();
+let activeWorkspaceId = null;
+const pendingSessionFrames = /* @__PURE__ */ new Map();
+const MAX_PENDING_CHANNEL_TYPES = 64;
+let activeSessionId = null;
+/** Slots each mount could not load, keyed `global`, `workspace:<id>` or `session:<id>`. */
+const loadDiagnostics = /* @__PURE__ */ new Map();
+let registryRevision = 0;
+const registryListeners = /* @__PURE__ */ new Set();
+function activeState() {
+	return (activeSessionId === null ? void 0 : sessionStates.get(activeSessionId)) ?? workspaceState() ?? defaultState;
+}
+function workspaceState() {
+	return activeWorkspaceId === null ? void 0 : workspaceStates.get(activeWorkspaceId);
+}
+/** Settings requests an explicit scope; the cockpit reads its active session composition. */
+function webTemplateCatalog(mount) {
+	if (mount === void 0) {
+		const scope = activeSessionId === null ? activeWorkspaceId === null ? "global" : "workspace" : "session";
+		return require_templateCatalog.collectWebTemplates(activeState().plugins, scope);
+	}
+	if (mount.scope === "global") return require_templateCatalog.collectWebTemplates(defaultState.plugins, "global");
+	const workspace = workspaceStates.get(mount.workspaceId);
+	const plugins = mount.scope === "session" ? sessionStates.get(mount.sessionId)?.plugins : void 0;
+	return require_templateCatalog.collectWebTemplates(plugins ?? require_pluginScopes.mergeScopedPlugins(defaultState.plugins, workspace?.plugins ?? []), mount.scope);
+}
+/** The phone app's layouts at the server-resolved `native.template` mount. */
+function nativeTemplateCatalog(mount) {
+	if (mount.scope === "global") return require_templateCatalog.collectNativeTemplates(defaultState.plugins, "global");
+	const workspace = workspaceStates.get(mount.workspaceId);
+	const plugins = mount.scope === "session" ? sessionStates.get(mount.sessionId)?.plugins : void 0;
+	return require_templateCatalog.collectNativeTemplates(plugins ?? require_pluginScopes.mergeScopedPlugins(defaultState.plugins, workspace?.plugins ?? []), mount.scope);
+}
+function rebuildSession(sessionId) {
+	const previous = sessionStates.get(sessionId);
+	const workspaceId = sessionWorkspaces.get(sessionId);
+	const workspace = workspaceId === void 0 ? void 0 : workspaceStates.get(workspaceId);
+	const state = buildWebPluginState(require_pluginScopes.mergeScopedPlugins(defaultState.plugins, workspace?.plugins ?? [], sessionPlugins.get(sessionId) ?? []));
+	sessionStates.set(sessionId, state);
+	for (const [type, channel] of previous?.channels.entries() ?? []) if (state.channels.get(type) !== channel) channel.drop(sessionId);
+	const pending = pendingSessionFrames.get(sessionId);
+	if (pending !== void 0) {
+		for (const [type, frame] of pending) if (dispatchFrameToState(state, frame)) pending.delete(type);
+		if (pending.size === 0) pendingSessionFrames.delete(sessionId);
+	}
+	return state;
+}
+function installGlobalWebPlugins(plugins) {
+	defaultState = buildWebPluginState(require_pluginScopes.pluginsAtScope(plugins, "global"));
+	for (const id of sessionPlugins.keys()) rebuildSession(id);
+	emitRegistryChange();
+}
+function installWorkspaceWebPlugins(workspaceId, plugins) {
+	const state = buildWebPluginState(require_pluginScopes.pluginsAtScope(plugins, "workspace"));
+	workspaceStates.set(workspaceId, state);
+	for (const [id, owner] of sessionWorkspaces) if (owner === workspaceId) rebuildSession(id);
+	emitRegistryChange();
+}
+function removeWorkspaceWebPlugins(workspaceId) {
+	workspaceStates.delete(workspaceId);
+	loadDiagnostics.delete(`workspace:${workspaceId}`);
+	for (const [id, owner] of sessionWorkspaces) if (owner === workspaceId) rebuildSession(id);
+	if (activeWorkspaceId === workspaceId) activeWorkspaceId = null;
+	emitRegistryChange();
+}
+function activateWebPluginWorkspace(workspaceId) {
+	if (activeWorkspaceId === workspaceId) return;
+	activeWorkspaceId = workspaceId;
+	emitRegistryChange();
+}
+function bindSessionWebWorkspace(sessionId, workspaceId) {
+	sessionWorkspaces.set(sessionId, workspaceId);
+	if (sessionPlugins.has(sessionId)) rebuildSession(sessionId);
+}
+function emitRegistryChange() {
+	registryRevision += 1;
+	for (const listener of registryListeners) listener();
+}
+/** The TUI's leader alphabet: one lowercase letter or digit per segment. */
+const LEADER_KEY = /^[a-z0-9]$/;
+const MAX_LEADER_PATH = 4;
+/**
+* A malformed binding fails the install rather than the keypress: the plugin
+* set is generated at build time, so this is a developer error, and the TUI's
+* registry refuses the same shapes.
+*/
+function checkLeaderBinding(pluginId, binding) {
+	if (binding.path.length === 0 || binding.path.length > MAX_LEADER_PATH) throw new Error(`Web plugin '${pluginId}' leader binding '${binding.id}' needs 1 to ${MAX_LEADER_PATH} path segments.`);
+	for (const segment of binding.path) {
+		if (!LEADER_KEY.test(segment.key)) throw new Error(`Web plugin '${pluginId}' leader binding '${binding.id}' key '${segment.key}' must be one lowercase letter or digit.`);
+		if (segment.label.trim() === "") throw new Error(`Web plugin '${pluginId}' leader binding '${binding.id}' has an unlabeled segment.`);
+	}
+}
+/**
+* Claims `id` in one shared namespace: false, with a diagnostic, when another
+* plugin already holds it; a throw when this plugin declared it twice, which
+* is a developer error rather than a composition.
+*/
+function claim(owners, thing, id, pluginId) {
+	const holder = owners.get(id);
+	if (holder === pluginId) throw new Error(`Web plugin '${pluginId}' declares ${thing.replace("-", " ")} '${id}' twice.`);
+	if (holder !== void 0) {
+		installingState.diagnostics.push({
+			pluginId,
+			kind: `duplicate-${thing}`,
+			message: `Web plugin '${pluginId}' ${thing.replace("-", " ")} '${id}' is already provided by '${holder}'; keeping the first.`
+		});
+		return false;
+	}
+	owners.set(id, pluginId);
+	return true;
+}
+function surfaceFill(slot, surface) {
+	return {
+		slot,
+		id: surface.id,
+		component: surface.component
+	};
+}
+function checkSlotDeclaration(pluginId, declared, declaration) {
+	const prefix = `${pluginId}${SLOT_SEPARATOR}`;
+	if (!declaration.slot.startsWith(prefix) || declaration.slot.length === prefix.length) throw new Error(`Web plugin '${pluginId}' declares slot '${declaration.slot}', which must be named '${prefix}<name>'.`);
+	if (declared.has(declaration.slot)) throw new Error(`Web plugin '${pluginId}' declares slot '${declaration.slot}' twice.`);
+	declared.add(declaration.slot);
+}
+function checkFill(pluginId, seen, fill) {
+	if (fill.id === "") throw new Error(`Web plugin '${pluginId}' has a fill into '${fill.slot}' with an empty id.`);
+	if (fill.component === void 0 && fill.data === void 0) throw new Error(`Web plugin '${pluginId}' fill '${fill.id}' into '${fill.slot}' has neither a component nor data.`);
+	const key = `${fill.slot} ${fill.id}`;
+	if (seen.has(key)) throw new Error(`Web plugin '${pluginId}' fills '${fill.slot}' with id '${fill.id}' twice.`);
+	seen.add(key);
+}
+function checkContextAction(pluginId, seen, action) {
+	if (action.id.trim() === "") throw new Error(`Web plugin '${pluginId}' has a context action with an empty id.`);
+	if (seen.has(action.id)) throw new Error(`Web plugin '${pluginId}' declares context action '${action.id}' twice.`);
+	if (action.label.trim() === "") throw new Error(`Web plugin '${pluginId}' context action '${action.id}' has an empty label.`);
+	if (action.kinds.length === 0 || action.kinds.some((kind) => kind.trim() === "")) throw new Error(`Web plugin '${pluginId}' context action '${action.id}' needs non-empty kinds.`);
+	seen.add(action.id);
+}
+function checkUserMessageAction(pluginId, seen, action) {
+	if (action.id.trim() === "") throw new Error(`Web plugin '${pluginId}' has a user message action with an empty id.`);
+	if (seen.has(action.id)) throw new Error(`Web plugin '${pluginId}' declares user message action '${action.id}' twice.`);
+	if (action.label.trim() === "") throw new Error(`Web plugin '${pluginId}' user message action '${action.id}' has an empty label.`);
+	seen.add(action.id);
+}
+const byFillOrder = (left, right) => left.order - right.order || left.pluginId.localeCompare(right.pluginId) || left.id.localeCompare(right.id);
+const byDisplayOrder = (left, right) => (left.order ?? DEFAULT_FILL_ORDER) - (right.order ?? DEFAULT_FILL_ORDER) || left.name.localeCompare(right.name);
+function placeFill(pluginId, fill) {
+	const declaration = installingState.slots.get(fill.slot);
+	if (declaration === void 0) {
+		installingState.diagnostics.push({
+			pluginId,
+			kind: "orphan-fill",
+			message: `Web plugin '${pluginId}' fills slot '${fill.slot}', which no installed plugin declares; nothing is placed.`
+		});
+		return;
+	}
+	let data = fill.data;
+	if (data !== void 0 && declaration.parse !== void 0) {
+		const parsed = declaration.parse(data);
+		if (parsed === null) {
+			installingState.diagnostics.push({
+				pluginId,
+				kind: "rejected-fill",
+				message: `Web plugin '${pluginId}' fill '${fill.id}' into '${fill.slot}' was rejected by the slot's parse gate.`
+			});
+			return;
+		}
+		data = parsed;
+	}
+	const placed = {
+		slot: fill.slot,
+		pluginId,
+		id: fill.id,
+		order: fill.order ?? DEFAULT_FILL_ORDER,
+		...data === void 0 ? {} : { data },
+		...fill.component === void 0 ? {} : { component: fill.component }
+	};
+	const list = installingState.fills.get(fill.slot);
+	if (list === void 0) installingState.fills.set(fill.slot, [placed]);
+	else list.push(placed);
+}
+function resolveLeaderConflicts(bindings) {
+	const owner = new Map(bindings.map((entry) => [entry.binding, entry.pluginId]));
+	for (const conflict of require_leaderTree.leaderConflicts(bindings.map((entry) => entry.binding))) {
+		const winner = owner.get(conflict.winner) ?? "";
+		const loser = owner.get(conflict.loser) ?? "";
+		if (winner === loser) throw new Error(`Web plugin '${winner}' binds Leader Space '${conflict.path}' twice ('${conflict.loser.id}' and '${conflict.winner.id}').`);
+		if (conflict.kind === "leaf-override") installingState.diagnostics.push({
+			pluginId: loser,
+			kind: "leader-leaf-override",
+			message: `Web plugin '${loser}' Leader Space leaf '${conflict.path}' ('${conflict.loser.id}') is taken over by '${winner}' ('${conflict.winner.id}').`
+		});
+		else installingState.diagnostics.push({
+			pluginId: loser,
+			kind: "leader-group-label",
+			message: `Web plugin '${loser}' words Leader Space group '${conflict.path}' differently from '${winner}', which named it first; keeping the first label.`
+		});
+	}
+}
+function buildWebPluginState(plugins) {
+	const previous = installingState;
+	installingState = emptyState();
+	try {
+		const owners = {
+			plugin: /* @__PURE__ */ new Map(),
+			tab: /* @__PURE__ */ new Map(),
+			"dock-face": /* @__PURE__ */ new Map(),
+			channel: /* @__PURE__ */ new Map(),
+			tool: /* @__PURE__ */ new Map(),
+			"activity-group": /* @__PURE__ */ new Map(),
+			"minor-mode": /* @__PURE__ */ new Map(),
+			"selection-axis": /* @__PURE__ */ new Map(),
+			"palette-command": /* @__PURE__ */ new Map(),
+			"settings-section": /* @__PURE__ */ new Map()
+		};
+		const pendingFills = [];
+		const pendingSections = [];
+		const pendingBindings = [];
+		const pendingSlots = [];
+		for (const plugin of plugins) {
+			if (RESERVED_PLUGIN_IDS.has(plugin.id)) throw new Error(`Web plugin id '${plugin.id}' is reserved for a host slot.`);
+			if (owners.plugin.has(plugin.id)) {
+				installingState.diagnostics.push({
+					pluginId: plugin.id,
+					kind: "duplicate-plugin",
+					message: `Web plugin id '${plugin.id}' is declared twice; keeping the first definition.`
+				});
+				continue;
+			}
+			owners.plugin.set(plugin.id, plugin.id);
+			installingState.plugins.push(plugin);
+			for (const tab of plugin.tabs ?? []) if (claim(owners.tab, "tab", tab.id, plugin.id)) installingState.tabs.push(tab);
+			for (const face of plugin.dockFaces ?? []) {
+				if (face.id === "activity" || face.id === "context") throw new Error(`Web plugin '${plugin.id}' dock face '${face.id}' is reserved by the host.`);
+				if (face.id.trim() === "" || face.label.trim() === "") throw new Error(`Web plugin '${plugin.id}' has an unlabeled dock face.`);
+				if (claim(owners["dock-face"], "dock-face", face.id, plugin.id)) installingState.dockFaces.push(face);
+			}
+			for (const section of plugin.settingsSections ?? []) if (claim(owners["settings-section"], "settings-section", section.id, plugin.id)) installingState.settingsSections.push(section);
+			for (const panel of plugin.settingsPanels ?? []) if (claim(owners["settings-section"], "settings-section", panel.id, plugin.id)) installingState.settingsPanels.push({
+				pluginId: plugin.id,
+				...panel
+			});
+			for (const channel of plugin.channels ?? []) if (claim(owners.channel, "channel", channel.channel, plugin.id)) installingState.channels.set(channel.channel, channel);
+			for (const command of plugin.paletteCommands ?? []) if (claim(owners["palette-command"], "palette-command", command.id, plugin.id)) installingState.commands.push(command);
+			const contextActions = /* @__PURE__ */ new Set();
+			for (const action of plugin.contextActions ?? []) {
+				checkContextAction(plugin.id, contextActions, action);
+				installingState.contextActions.push({
+					pluginId: plugin.id,
+					...action
+				});
+			}
+			const userMessageActions = /* @__PURE__ */ new Set();
+			for (const action of plugin.userMessageActions ?? []) {
+				checkUserMessageAction(plugin.id, userMessageActions, action);
+				installingState.userMessageActions.push({
+					pluginId: plugin.id,
+					...action
+				});
+			}
+			for (const binding of plugin.leaderBindings ?? []) {
+				checkLeaderBinding(plugin.id, binding);
+				pendingBindings.push({
+					pluginId: plugin.id,
+					binding
+				});
+			}
+			for (const axis of plugin.selectionAxes ?? []) if (claim(owners["selection-axis"], "selection-axis", axis.name, plugin.id)) installingState.selectionAxes.push(axis);
+			for (const mode of plugin.minorModes ?? []) if (claim(owners["minor-mode"], "minor-mode", mode.name, plugin.id)) installingState.minorModes.push(mode);
+			for (const group of plugin.activityGroups ?? []) if (claim(owners["activity-group"], "activity-group", group.name, plugin.id)) installingState.activityGroups.push(group);
+			for (const renderer of plugin.toolRenderers ?? []) {
+				for (const tool of renderer.tools) if (claim(owners.tool, "tool", tool, plugin.id)) installingState.toolRenderers.set(tool, renderer);
+				if (renderer.matches !== void 0) installingState.toolMatchers.push(renderer);
+			}
+			const declared = /* @__PURE__ */ new Set();
+			for (const declaration of plugin.slots ?? []) {
+				checkSlotDeclaration(plugin.id, declared, declaration);
+				pendingSlots.push(declaration);
+			}
+			const filled = /* @__PURE__ */ new Set();
+			for (const fill of plugin.fills ?? []) {
+				checkFill(plugin.id, filled, fill);
+				pendingFills.push({
+					pluginId: plugin.id,
+					fill
+				});
+			}
+			for (const surface of plugin.overlays ?? []) pendingFills.push({
+				pluginId: plugin.id,
+				fill: surfaceFill(HOST_SLOTS.overlay, surface)
+			});
+			for (const surface of plugin.railSections ?? []) pendingFills.push({
+				pluginId: plugin.id,
+				fill: surfaceFill(HOST_SLOTS.rail, surface)
+			});
+			for (const surface of plugin.contextSections ?? []) pendingFills.push({
+				pluginId: plugin.id,
+				fill: surfaceFill(HOST_SLOTS.context, surface)
+			});
+			for (const surface of plugin.selectionBarItems ?? []) pendingFills.push({
+				pluginId: plugin.id,
+				fill: surfaceFill(HOST_SLOTS.selectionBar, surface)
+			});
+			for (const surface of plugin.composerActions ?? []) pendingFills.push({
+				pluginId: plugin.id,
+				fill: surfaceFill(HOST_SLOTS.composerActions, surface)
+			});
+			for (const surface of plugin.composerMenuItems ?? []) pendingFills.push({
+				pluginId: plugin.id,
+				fill: surfaceFill(HOST_SLOTS.composerMenu, surface)
+			});
+			for (const section of plugin.activitySections ?? []) pendingSections.push({
+				pluginId: plugin.id,
+				section
+			});
+			if (plugin.fileLinks !== void 0) installingState.fileLinks.push(plugin.fileLinks);
+		}
+		installingState.diagnostics.push(...require_templateCatalog.collectWebTemplates(installingState.plugins).diagnostics);
+		for (const slot of Object.values(HOST_SLOTS)) installingState.slots.set(slot, { slot });
+		for (const group of installingState.activityGroups) installingState.slots.set(activityGroupSlot(group.name), { slot: activityGroupSlot(group.name) });
+		for (const declaration of pendingSlots) installingState.slots.set(declaration.slot, declaration);
+		for (const { pluginId, section } of pendingSections) {
+			const keyed = activityGroupSlot(section.id);
+			pendingFills.push({
+				pluginId,
+				fill: surfaceFill(installingState.slots.has(keyed) ? keyed : HOST_SLOTS.activity, section)
+			});
+		}
+		for (const { pluginId, fill } of pendingFills) placeFill(pluginId, fill);
+		for (const list of installingState.fills.values()) list.sort(byFillOrder);
+		resolveLeaderConflicts(pendingBindings);
+		installingState.leaderBindings.push(...pendingBindings.map((entry) => entry.binding));
+		installingState.contextActions.sort((left, right) => (left.order ?? DEFAULT_FILL_ORDER) - (right.order ?? DEFAULT_FILL_ORDER) || left.pluginId.localeCompare(right.pluginId) || left.id.localeCompare(right.id));
+		installingState.userMessageActions.sort((left, right) => (left.order ?? DEFAULT_FILL_ORDER) - (right.order ?? DEFAULT_FILL_ORDER) || left.pluginId.localeCompare(right.pluginId) || left.id.localeCompare(right.id));
+		installingState.selectionAxes.sort(byDisplayOrder);
+		installingState.minorModes.sort(byDisplayOrder);
+		installingState.activityGroups.sort(byDisplayOrder);
+		installingState.dockFaces.sort((left, right) => (left.order ?? DEFAULT_FILL_ORDER) - (right.order ?? DEFAULT_FILL_ORDER) || left.id.localeCompare(right.id));
+		return installingState;
+	} finally {
+		installingState = previous;
+	}
+}
+function installWebPlugins(plugins) {
+	if (defaultInstalled) throw new Error("Web plugins are already installed.");
+	defaultState = buildWebPluginState(plugins);
+	installingState = defaultState;
+	defaultInstalled = true;
+}
+function webPluginsInstalled() {
+	return defaultInstalled;
+}
+/** Unit-test escape hatch; production installs exactly once. */
+function resetWebPlugins() {
+	defaultState = emptyState();
+	installingState = defaultState;
+	defaultInstalled = false;
+	sessionStates.clear();
+	workspaceStates.clear();
+	sessionPlugins.clear();
+	sessionWorkspaces.clear();
+	activeWorkspaceId = null;
+	pendingSessionFrames.clear();
+	loadDiagnostics.clear();
+	activeSessionId = null;
+	emitRegistryChange();
+}
+/** Installs or atomically replaces one session's independently synchronized plugin definitions. */
+function installSessionWebPlugins(sessionId, plugins) {
+	sessionPlugins.set(sessionId, plugins.flatMap((plugin) => plugin.session === void 0 ? [plugin] : require_pluginScopes.pluginsAtScope([plugin], "session")));
+	rebuildSession(sessionId);
+	if (sessionId === activeSessionId) emitRegistryChange();
+}
+/** Selects which session composition the no-argument contribution readers expose. */
+function activateWebPluginSession(sessionId) {
+	if (activeSessionId === sessionId) return;
+	activeSessionId = sessionId;
+	emitRegistryChange();
+}
+/** Removes one session registry after its plugin-owned stores have been dropped. */
+function removeSessionWebPlugins(sessionId) {
+	const sessionState = sessionStates.get(sessionId);
+	pendingSessionFrames.delete(sessionId);
+	loadDiagnostics.delete(`session:${sessionId}`);
+	if (sessionState === void 0) return;
+	for (const channel of sessionState.channels.values()) channel.drop(sessionId);
+	sessionStates.delete(sessionId);
+	sessionPlugins.delete(sessionId);
+	sessionWorkspaces.delete(sessionId);
+	if (sessionId === activeSessionId) emitRegistryChange();
+}
+function subscribeWebPluginRegistry(listener) {
+	registryListeners.add(listener);
+	return () => registryListeners.delete(listener);
+}
+function webPluginRegistryRevision() {
+	return registryRevision;
+}
+/**
+* Records the slots one mount could not load, replacing its previous record. The mount still
+* installs the slots that loaded, so one broken plugin never hides the others.
+*/
+function setWebPluginLoadDiagnostics(mount, diagnostics) {
+	const key = mount.scope === "global" ? "global" : mount.scope === "workspace" ? `workspace:${mount.workspaceId}` : `session:${mount.sessionId}`;
+	if (diagnostics.length === 0 && !loadDiagnostics.has(key)) return;
+	if (diagnostics.length === 0) loadDiagnostics.delete(key);
+	else loadDiagnostics.set(key, [...diagnostics]);
+	emitRegistryChange();
+}
+/**
+* What the install had to resolve between plugins, plus the slots the visible mounts could not
+* load; empty for a composition whose plugins all load and never collide.
+*/
+function webPluginDiagnostics() {
+	const workspaceId = (activeSessionId === null ? void 0 : sessionWorkspaces.get(activeSessionId)) ?? activeWorkspaceId;
+	const failed = [
+		"global",
+		...workspaceId === null ? [] : [`workspace:${workspaceId}`],
+		...activeSessionId === null ? [] : [`session:${activeSessionId}`]
+	].flatMap((key) => loadDiagnostics.get(key) ?? []);
+	const installed = activeState().diagnostics;
+	return failed.length === 0 ? installed : [...installed, ...failed];
+}
+/** Every installed plugin definition, in install order; the settings page lists them. */
+function installedWebPlugins() {
+	return activeState().plugins;
+}
+/** Package panels placed under the host's repository controls, in stable display order. */
+function pluginRepositorySettingsPanels() {
+	return (workspaceState() ?? emptyState()).plugins.flatMap((plugin) => plugin.repositorySettingsPanel === void 0 ? [] : [{
+		pluginId: plugin.id,
+		...plugin.repositorySettingsPanel
+	}]).sort((left, right) => (left.order ?? DEFAULT_FILL_ORDER) - (right.order ?? DEFAULT_FILL_ORDER) || left.pluginId.localeCompare(right.pluginId));
+}
+function webTabs() {
+	return activeState().tabs;
+}
+/** Optional right-dock faces from the active session composition, in display order. */
+function pluginDockFaces() {
+	return activeState().dockFaces;
+}
+/** UI discovery only. Requests still require a proof injected by Electron's main process. */
+function isDesktopClient() {
+	return typeof window !== "undefined" && window.poDesktop?.platform === "desktop";
+}
+/**
+* The settings pages plugins contribute, in menu order. Sorted here rather than
+* at the reader so the menu and the page agree without either sorting twice.
+*/
+function pluginSettingsSections(scope = "global") {
+	const sections = (scope === "global" ? defaultState : workspaceState())?.settingsSections ?? [];
+	return isDesktopClient() ? sections : sections.filter((section) => !section.desktopOnly);
+}
+/** The settings pages plugins draw themselves, in install order; the reader sorts them with the sections. */
+function pluginSettingsPanels() {
+	return defaultState.settingsPanels;
+}
+/** The fills placed into one slot, in slot order; empty for a slot nobody declared. */
+function slotFills(slot) {
+	return activeState().fills.get(slot) ?? [];
+}
+/** One workspace's own fills for a slot, whichever session or workspace is focused. */
+function workspaceSlotFills(workspaceId, slot) {
+	return workspaceStates.get(workspaceId)?.fills.get(slot) ?? [];
+}
+function paletteCommands() {
+	return activeState().commands;
+}
+/** Context actions from every installed plugin, in stable display order. */
+function pluginContextActions() {
+	return activeState().contextActions;
+}
+/** User-message actions from every installed plugin, in stable display order. */
+function pluginUserMessageActions() {
+	return activeState().userMessageActions;
+}
+/** Leader Space bindings from every installed plugin, in install order: a later binding on a bound leaf wins. */
+function pluginLeaderBindings() {
+	return activeState().leaderBindings;
+}
+/** Selection-axis declarations from every installed plugin, in display order. */
+function pluginSelectionAxes() {
+	return activeState().selectionAxes;
+}
+/** Minor-mode declarations from every installed plugin, in display order. */
+function pluginMinorModes() {
+	return activeState().minorModes;
+}
+/** Activity-dock group declarations from every installed plugin, in display order. */
+function pluginActivityGroups() {
+	const groups = activeState().activityGroups;
+	return isDesktopClient() ? groups : groups.filter((group) => !group.desktopOnly);
+}
+/**
+* The file-link sources installed plugins contribute, in install order.
+*
+* More than one is allowed and the first to claim a path wins, the same way a
+* runtime tool matcher does: the host has no way to choose between two
+* packages that both recognise a path, and the alternative is two tabs for one
+* file.
+*/
+function pluginFileLinks() {
+	return activeState().fileLinks;
+}
+/**
+* The renderer a plugin registered for one tool: the exact name claim first,
+* then the first runtime matcher that accepts it, in install order (the one
+* place besides `start` where that order is observable); undefined leaves
+* the host's default card.
+*/
+function pluginToolRenderer(toolName, statuses = {}, details) {
+	return activeState().toolRenderers.get(toolName) ?? activeState().toolMatchers.find((renderer) => renderer.matches?.(toolName, statuses, details));
+}
+/** A session-scoped renderer, or undefined until that session's verified composition is installed. */
+function sessionToolRenderer(sessionId, toolName) {
+	return sessionStates.get(sessionId)?.toolRenderers.get(toolName);
+}
+function sessionWebPluginsInstalled(sessionId) {
+	return sessionStates.has(sessionId);
+}
+/**
+* Routes one wire frame to the channel owning its type. Returns false when no
+* channel claims it, so the demux can fall through silently the way unknown
+* frames always have.
+*/
+function dispatchFrameToState(state, frame) {
+	if (typeof frame.type !== "string" || typeof frame.sessionId !== "string") return false;
+	const channel = state.channels.get(frame.type);
+	if (channel === void 0) return false;
+	const payload = channel.parse(frame.payload);
+	if (payload !== null) channel.apply(frame.sessionId, payload);
+	return true;
+}
+function dispatchChannelFrame(frame) {
+	if (typeof frame.type !== "string" || typeof frame.sessionId !== "string") return false;
+	const state = sessionStates.get(frame.sessionId);
+	if (state !== void 0) {
+		if (dispatchFrameToState(state, frame)) return true;
+	} else if (activeSessionId === null) return dispatchFrameToState(defaultState, frame);
+	if (!Object.hasOwn(frame, "payload")) return false;
+	const pending = pendingSessionFrames.get(frame.sessionId) ?? /* @__PURE__ */ new Map();
+	if (!pending.has(frame.type) && pending.size >= MAX_PENDING_CHANNEL_TYPES) {
+		const oldest = pending.keys().next().value;
+		if (oldest !== void 0) pending.delete(oldest);
+	}
+	pending.set(frame.type, frame);
+	pendingSessionFrames.set(frame.sessionId, pending);
+	return false;
+}
+/** Session teardown: every channel forgets the session's data. */
+function dropPluginSessionData(sessionId) {
+	pendingSessionFrames.delete(sessionId);
+	const state = sessionStates.get(sessionId) ?? (activeSessionId === null ? defaultState : void 0);
+	for (const channel of state?.channels.values() ?? []) channel.drop(sessionId);
+}
+/** Starts every plugin runtime in install order; the disposer runs in reverse. */
+function startPluginDefinitions(plugins, runtime) {
+	const disposers = [];
+	const disposeStarted = () => {
+		for (const dispose of disposers.reverse()) dispose();
+	};
+	try {
+		for (const plugin of plugins) {
+			const dispose = plugin.start?.(runtime);
+			if (dispose) disposers.push(dispose);
+		}
+	} catch (error) {
+		disposeStarted();
+		throw error;
+	}
+	return disposeStarted;
+}
+function startWebPlugins(runtime) {
+	return startPluginDefinitions(activeState().plugins, runtime);
+}
+//#endregion
+exports.HOST_SLOTS = HOST_SLOTS;
+exports.activateWebPluginSession = activateWebPluginSession;
+exports.activateWebPluginWorkspace = activateWebPluginWorkspace;
+exports.activityGroupSlot = activityGroupSlot;
+exports.bindSessionWebWorkspace = bindSessionWebWorkspace;
+exports.dispatchChannelFrame = dispatchChannelFrame;
+exports.dropPluginSessionData = dropPluginSessionData;
+exports.installGlobalWebPlugins = installGlobalWebPlugins;
+exports.installSessionWebPlugins = installSessionWebPlugins;
+exports.installWebPlugins = installWebPlugins;
+exports.installWorkspaceWebPlugins = installWorkspaceWebPlugins;
+exports.installedWebPlugins = installedWebPlugins;
+exports.isDesktopClient = isDesktopClient;
+exports.nativeTemplateCatalog = nativeTemplateCatalog;
+exports.paletteCommands = paletteCommands;
+exports.pluginActivityGroups = pluginActivityGroups;
+exports.pluginContextActions = pluginContextActions;
+exports.pluginDockFaces = pluginDockFaces;
+exports.pluginFileLinks = pluginFileLinks;
+exports.pluginLeaderBindings = pluginLeaderBindings;
+exports.pluginMinorModes = pluginMinorModes;
+exports.pluginRepositorySettingsPanels = pluginRepositorySettingsPanels;
+exports.pluginSelectionAxes = pluginSelectionAxes;
+exports.pluginSettingsPanels = pluginSettingsPanels;
+exports.pluginSettingsSections = pluginSettingsSections;
+exports.pluginToolRenderer = pluginToolRenderer;
+exports.pluginUserMessageActions = pluginUserMessageActions;
+exports.removeSessionWebPlugins = removeSessionWebPlugins;
+exports.removeWorkspaceWebPlugins = removeWorkspaceWebPlugins;
+exports.resetWebPlugins = resetWebPlugins;
+exports.sessionToolRenderer = sessionToolRenderer;
+exports.sessionWebPluginsInstalled = sessionWebPluginsInstalled;
+exports.setWebPluginLoadDiagnostics = setWebPluginLoadDiagnostics;
+exports.slotFills = slotFills;
+exports.startPluginDefinitions = startPluginDefinitions;
+exports.startWebPlugins = startWebPlugins;
+exports.subscribeWebPluginRegistry = subscribeWebPluginRegistry;
+exports.webPluginDiagnostics = webPluginDiagnostics;
+exports.webPluginRegistryRevision = webPluginRegistryRevision;
+exports.webPluginsInstalled = webPluginsInstalled;
+exports.webTabs = webTabs;
+exports.webTemplateCatalog = webTemplateCatalog;
+exports.workspaceSlotFills = workspaceSlotFills;
+
+//# sourceMappingURL=pluginRegistry.cjs.map