@embedpdf/plugin-commands 3.0.0-next.13 → 3.0.0-next.15

package/dist/index.js

@@ -1,29 +1,213 @@
-import { n as resolvedCommandsEqual, t as CommandsToken } from "./contract-UFgXphIQ.js";
-import { definePlugin } from "@embedpdf/core";
+import { a as unregisteredCommand, i as unknownCommandWarning, n as boundCommandOf, o as CommandsToken, r as resolvedCommandsEqual, t as COMMANDS_DEFAULTS } from "./contract-Cj5BTtO7.js";
+import { CommandsToken as CommandsToken$1 } from "./contract/host.js";
+import { DocumentsToken, PluginError, definePlugin, isPluginError, memo, memoByKey, toPluginError, toPluginErrorInfo } from "@embedpdf/core";
 import { I18nToken } from "@embedpdf/plugin-i18n/contract";
 import { ShellToken } from "@embedpdf/plugin-shell/contract";
 import { matchShortcut, parseShortcut } from "@embedpdf/core-ui";
-//#region src/capability.ts
-function registerCommand(registry, def) {
-	if (registry.has(def.id)) throw new Error(`[commands] duplicate command: ${def.id}`);
-	const shortcuts = def.shortcut === void 0 ? [] : [].concat(def.shortcut);
-	registry.set(def.id, {
-		def,
+//#region src/registry.ts
+/** A command definition with its shortcuts parsed once, and how the registry tells a family apart. */
+const registeredCommand = (definition) => {
+	const shortcuts = definition.shortcut === void 0 ? [] : [].concat(definition.shortcut);
+	return {
+		definition,
 		shortcuts,
 		parsed: shortcuts.map(parseShortcut)
+	};
+};
+const isCommandFamily = (item) => "prefix" in item;
+function configuredCommands(items) {
+	const commands = /* @__PURE__ */ new Map();
+	const families = [];
+	for (const item of items) if (isCommandFamily(item)) families.push(item);
+	else commands.set(item.id, registeredCommand(item));
+	return {
+		commands,
+		families
+	};
+}
+//#endregion
+//#region src/services/availability.ts
+/**
+* Whether a category is off: it, or a category it's under, is in the list. Parts are whole
+* dotted segments, so `annotations` covers `annotations.highlight` and not `annotationsExtra`.
+*/
+const isCategoryOff = (category, disabled) => disabled.some((off) => category === off || category.startsWith(`${off}.`));
+/**
+* The label: a language's string under the command's id, else under its `labelKey` (the current
+* language, then the fallback one), else `label`, else the id. So a string for
+* `'document:download'` relabels that one command, whichever key its label is under.
+*/
+const labelOf = (definition, context) => {
+	const i18n = context.tryGet(I18nToken);
+	if (!i18n) return definition.label ?? definition.labelKey ?? definition.id;
+	const fallbackKey = definition.labelKey ? { fallbackKey: definition.labelKey } : {};
+	return definition.label === void 0 && definition.labelKey ? i18n.t(definition.id, fallbackKey) : i18n.t(definition.id, {
+		...fallbackKey,
+		fallback: definition.label ?? definition.id
+	});
+};
+/**
+* Whether a document's session holds a permission: what `ctx.allows` answers for a
+* document-scoped plugin, asked here of the command's document, since the commands are one
+* set for the whole workspace.
+*/
+const sessionHolds = (security, permission) => permission === "annotations:create" ? security.allowsAnnotation("create") : security.allows(permission);
+/** Where a language keeps the sentence for a permission: `commands.notAllowed.doc-text-copy`. */
+const permissionKeyOf = (permission) => `commands.notAllowed.${permission.replace(/[.:]/g, "-")}`;
+/** The general sentence's key: `{label} isn't allowed`. */
+const DEFAULT_NOT_ALLOWED_KEY = "commands.notAllowed.default";
+/** The sentence for a command the session may not run, under `key`, else the general one. */
+const notAllowedMessage = (key, label, context) => {
+	const fallback = `${label} isn't allowed`;
+	const i18n = context.tryGet(I18nToken);
+	if (!i18n) return fallback;
+	const params = { label };
+	return i18n.t(key, {
+		params,
+		fallback: i18n.t(DEFAULT_NOT_ALLOWED_KEY, {
+			params,
+			fallback
+		})
 	});
+};
+/** The sentence for a command that's turned off. */
+const turnedOffMessage = (label, context) => {
+	const i18n = context.tryGet(I18nToken);
+	return i18n ? i18n.t("commands.turnedOff", {
+		params: { label },
+		fallback: "{label} isn't available"
+	}) : `${label} isn't available`;
+};
+function createAvailability(ctx, settings) {
+	/** Whether a command is turned off: by its id, or through one of its categories. */
+	const isTurnedOff = (definition) => {
+		const { disabledCategories, disabledCommands } = settings.get();
+		return disabledCommands.includes(definition.id) || (definition.categories ?? []).some((category) => isCategoryOff(category, disabledCategories));
+	};
+	/** Whether a command's `allowed` check says yes; one that throws allows it. */
+	const passesCheck = (definition, context) => {
+		if (!definition.allowed) return true;
+		try {
+			return definition.allowed(context);
+		} catch {
+			return true;
+		}
+	};
+	/**
+	* Why its document's session may not run a command, as the key of the sentence that says
+	* so, or `null` when it may: the first permission `requires` names that the session doesn't
+	* hold (`commands.notAllowed.doc-print`), else its `allowed` check saying no (its
+	* `notAllowedKey`). With no document open there is no session to ask, and nothing is refused.
+	*/
+	const notAllowedKeyOf = (definition, context) => {
+		if (!definition.requires?.length && !definition.allowed) return null;
+		const handle = context.documentId === null ? null : ctx.documentHandle(context.documentId);
+		if (!handle) return null;
+		const missing = definition.requires?.find((permission) => !sessionHolds(handle.security, permission));
+		if (missing !== void 0) return permissionKeyOf(missing);
+		return passesCheck(definition, context) ? null : definition.notAllowedKey ?? DEFAULT_NOT_ALLOWED_KEY;
+	};
+	/** Why a command won't run whatever the moment, or `null` when it may run. */
+	const refusalOf = (definition, context) => {
+		if (isTurnedOff(definition)) return {
+			reason: "turned-off",
+			message: turnedOffMessage(labelOf(definition, context), context)
+		};
+		const notAllowed = notAllowedKeyOf(definition, context);
+		return notAllowed === null ? null : {
+			reason: "not-allowed",
+			message: notAllowedMessage(notAllowed, labelOf(definition, context), context)
+		};
+	};
+	return {
+		isTurnedOff,
+		notAllowedKeyOf,
+		refusalOf
+	};
+}
+//#endregion
+//#region src/write/turning-off.ts
+function createTurningOff(settings, definitionOf, isTurnedOff) {
+	const listOf = (list) => settings.get()[list];
+	const replace = (list, names) => settings.api.updateSettings(list === "disabledCategories" ? { disabledCategories: [...names] } : { disabledCommands: [...names] });
+	const add = (list, name) => {
+		const current = listOf(list);
+		if (!current.includes(name)) replace(list, [...current, name]);
+	};
+	const remove = (list, name) => {
+		const current = listOf(list);
+		if (current.includes(name)) replace(list, current.filter((other) => other !== name));
+	};
+	return {
+		getDisabledCategories: () => listOf("disabledCategories"),
+		isCategoryDisabled: (category) => isCategoryOff(category, listOf("disabledCategories")),
+		disableCategory: (category) => add("disabledCategories", category),
+		enableCategory: (category) => remove("disabledCategories", category),
+		setDisabledCategories: (categories) => replace("disabledCategories", categories),
+		getDisabledCommands: () => listOf("disabledCommands"),
+		isCommandDisabled: (id) => {
+			const definition = definitionOf(id);
+			return definition ? isTurnedOff(definition) : listOf("disabledCommands").includes(id);
+		},
+		disableCommand: (id) => add("disabledCommands", id),
+		enableCommand: (id) => remove("disabledCommands", id),
+		setDisabledCommands: (ids) => replace("disabledCommands", ids)
+	};
 }
-const panelTarget = (def) => def.panel === void 0 ? null : typeof def.panel === "string" ? { id: def.panel } : def.panel;
-function createCommandsCapability(ctx, registry) {
-	/** Bind capability resolution to the command's target document. The kernel
-	*  resolves workspace tokens regardless of the document argument, so one
-	*  code path serves both scopes. */
-	const commandCtx = (documentId) => {
-		const target = documentId ?? ctx.core().activeId;
+//#endregion
+//#region src/controller.ts
+/**
+* The commands controller: the commands (from the settings, added while the
+* app runs, and from families), resolution for a document (derivations over
+* live state, safe to throw), the one way to run a command, turning commands
+* off (by category and one by one), what the session may run (the scope's
+* `requires`, the plugins' checks in `allowed`), and the host-only keystroke
+* matcher.
+*
+* Definitions hold functions, so the commands added while the app runs are a
+* map outside state; every change to it calls `ctx.notify()` so readers read
+* again.
+*/
+const panelTarget = (definition) => definition.panel === void 0 ? null : typeof definition.panel === "string" ? { id: definition.panel } : definition.panel;
+const NOT_REGISTERED = [
+	null,
+	"",
+	void 0,
+	void 0,
+	false,
+	false,
+	false,
+	void 0
+];
+const NO_NAMES = [];
+const accentOf = (primary, secondary) => primary === void 0 && secondary === void 0 ? void 0 : {
+	...primary !== void 0 ? { primary } : {},
+	...secondary !== void 0 ? { secondary } : {}
+};
+/** The memo key of a resolution: the command id and the document named, if any. */
+const resolutionKey = (id, documentId) => JSON.stringify([id, documentId ?? null]);
+function createCommandsController(ctx) {
+	const settings = ctx.settings();
+	/** Commands added while the app runs, in the order they were added. */
+	const registered = /* @__PURE__ */ new Map();
+	/** Bumped on every change to `registered`: the input of the reads built from it. */
+	let registeredVersion = 0;
+	const registeredChanged = () => {
+		registeredVersion += 1;
+		ctx.notify();
+	};
+	/** The commands the settings define, rebuilt when the setting changes. */
+	const configured = memo(() => [settings.get().commands], (items) => configuredCommands(items));
+	const executed = ctx.events.source();
+	const executionFailed = ctx.events.source();
+	/** Capabilities for the command's document: the one named, else the active one. */
+	const commandContext = (documentId, call = {}) => {
+		const target = documentId ?? ctx.get(DocumentsToken).getActiveId();
 		const get = (token) => target ? ctx.forDocument(token, target) : ctx.get(token);
 		return {
 			documentId: target,
-			core: ctx.core,
+			...call.args === void 0 ? {} : { args: call.args },
+			...call.signal ? { signal: call.signal } : {},
 			get,
 			tryGet: (token) => {
 				try {
@@ -34,149 +218,296 @@ function createCommandsCapability(ctx, registry) {
 			}
 		};
 	};
-	/** Derivations run against live state; a derivation that throws (e.g. it
-	*  needs a document and none is open) falls back to the safe default —
-	*  the button renders, disabled, exactly like v2's empty state. */
-	const derive = (fn, c, fallback) => {
-		if (!fn) return fallback;
+	/** A family's command for one name, made once so it keeps its identity. */
+	const familyCommands = /* @__PURE__ */ new WeakMap();
+	const familyCommand = (family, name) => {
+		let byName = familyCommands.get(family);
+		if (!byName) {
+			byName = /* @__PURE__ */ new Map();
+			familyCommands.set(family, byName);
+		}
+		let entry = byName.get(name);
+		if (!entry) {
+			entry = registeredCommand({
+				...family.command(name),
+				id: `${family.prefix}${name}`
+			});
+			byName.set(name, entry);
+		}
+		return entry;
+	};
+	/** The command with this id: one added while the app runs, else the settings', else a family's. */
+	const entryOf = (id) => {
+		const { commands, families } = configured();
+		const entry = registered.get(id) ?? commands.get(id);
+		if (entry) return entry;
+		const family = families.find((candidate) => id.startsWith(candidate.prefix) && id.length > candidate.prefix.length);
+		return family ? familyCommand(family, id.slice(family.prefix.length)) : null;
+	};
+	/** Every command with its own definition (not a family's), each id once. */
+	const definedCommands = memo(() => [registeredVersion, configured()], (_version, { commands }) => {
+		const entries = new Map(commands);
+		for (const [id, entry] of registered) entries.set(id, entry);
+		return [...entries.values()];
+	});
+	const derive = (derivation, context, fallback) => {
+		if (!derivation) return fallback;
 		try {
-			return fn(c);
+			return derivation(context);
 		} catch {
 			return fallback;
 		}
 	};
-	/** Same guard as `derive`, for the icon-accent derivation: a throw (no
-	*  document, provider missing) means "no accent" — the icon renders plain. */
-	const deriveAccent = (fn, c) => {
-		if (!fn) return void 0;
+	const deriveAccent = (derivation, context) => {
+		if (!derivation) return void 0;
 		try {
-			return fn(c) ?? void 0;
+			return derivation(context) ?? void 0;
 		} catch {
 			return;
 		}
 	};
-	const resolve = (id, documentId) => {
-		const entry = registry.get(id);
-		if (!entry) return null;
-		const { def } = entry;
-		const c = commandCtx(documentId);
-		const disabled = ctx.getState().disabledCategories;
-		const categoryHidden = (def.categories ?? []).some((cat) => disabled.includes(cat));
-		const i18n = c.tryGet(I18nToken);
-		const label = i18n ? i18n.t(def.labelKey) : def.labelKey;
+	const namesOf = (family, context) => {
+		try {
+			return family.names(context);
+		} catch {
+			return NO_NAMES;
+		}
+	};
+	const { isTurnedOff, notAllowedKeyOf, refusalOf } = createAvailability(ctx, settings);
+	const derivationsOf = (entry, documentId) => {
+		const { definition } = entry;
+		const context = commandContext(documentId);
+		const label = labelOf(definition, context);
+		const turnedOff = isTurnedOff(definition);
+		const notAllowed = turnedOff ? null : notAllowedKeyOf(definition, context);
+		const shownWhenNotAllowed = settings.get().notAllowed === "disable";
+		const ruledOut = turnedOff || notAllowed !== null;
 		let active;
-		if (def.active) active = derive(def.active, c, false);
+		if (definition.active) active = derive(definition.active, context, false);
 		else {
-			const shell = c.tryGet(ShellToken);
-			const panel = panelTarget(def);
-			active = shell ? def.menu ? shell.isMenuOpen(def.menu) : panel ? shell.isOpen(panel.id) : def.modal ? shell.isOpen(def.modal) : false : false;
+			const shell = context.tryGet(ShellToken);
+			const panel = panelTarget(definition);
+			active = shell ? definition.menu ? shell.isMenuOpen(definition.menu) : panel ? shell.isOpen(panel.id) : definition.modal ? shell.isOpen(definition.modal) : false : false;
 		}
-		return {
-			id: def.id,
+		const accent = deriveAccent(definition.iconAccent, context);
+		return [
+			entry,
 			label,
-			icon: def.icon,
-			iconAccent: deriveAccent(def.iconAccent, c),
-			shortcuts: entry.shortcuts,
-			menu: def.menu,
-			enabled: derive(def.enabled, c, true) && !categoryHidden,
+			accent?.primary,
+			accent?.secondary,
+			!ruledOut && derive(definition.enabled, context, true),
 			active,
-			visible: derive(def.visible, c, true) && !categoryHidden,
-			categories: def.categories ?? []
-		};
+			!turnedOff && (notAllowed === null || shownWhenNotAllowed) && derive(definition.visible, context, true),
+			notAllowed !== null && shownWhenNotAllowed ? notAllowedMessage(notAllowed, label, context) : void 0
+		];
 	};
-	const execute = (id, documentId) => {
-		const entry = registry.get(id);
-		if (!entry) return;
-		const resolved = resolve(id, documentId);
-		if (!resolved || !resolved.enabled || !resolved.visible) return;
-		const c = commandCtx(documentId);
-		if (entry.def.run) {
-			entry.def.run(c);
+	/** A resolved command, the same object until one of its derivations or its entry changes. */
+	const resolvedByKey = memoByKey((key) => {
+		const [id, documentId] = JSON.parse(key);
+		const entry = entryOf(id);
+		return entry ? derivationsOf(entry, documentId ?? void 0) : NOT_REGISTERED;
+	}, (_key, entry, label, accentPrimary, accentSecondary, enabled, active, visible, disabledReason) => entry && {
+		id: entry.definition.id,
+		label,
+		icon: entry.definition.icon,
+		iconAccent: accentOf(accentPrimary, accentSecondary),
+		shortcuts: entry.shortcuts,
+		menu: entry.definition.menu,
+		enabled,
+		active,
+		visible,
+		categories: entry.definition.categories ?? [],
+		...disabledReason === void 0 ? {} : { disabledReason }
+	});
+	const resolveCommand = (id, documentId) => entryOf(id) ? resolvedByKey(resolutionKey(id, documentId)) : null;
+	/**
+	* Every command's id for a document (`''` is the active one): the defined ones in the order
+	* they were added, then each family's names that no defined command took.
+	*/
+	const idsByDocument = memoByKey((documentKey) => {
+		const config = configured();
+		const context = commandContext(documentKey || void 0);
+		return [
+			definedCommands(),
+			config,
+			...config.families.map((family) => namesOf(family, context))
+		];
+	}, (_documentKey, ...inputs) => {
+		const [defined, { families }, ...names] = inputs;
+		const ids = defined.map((entry) => entry.definition.id);
+		const taken = new Set(ids);
+		families.forEach((family, index) => {
+			for (const name of names[index] ?? NO_NAMES) {
+				const id = `${family.prefix}${name}`;
+				if (taken.has(id)) continue;
+				taken.add(id);
+				ids.push(id);
+			}
+		});
+		return ids;
+	});
+	const commandsByDocument = memoByKey((documentKey) => idsByDocument(documentKey).map((id) => resolveCommand(id, documentKey || void 0)), (_documentKey, ...resolved) => resolved.filter((command) => command !== null));
+	const listCommands = (documentId) => commandsByDocument(documentId ?? "");
+	const listShortcuts = memo(() => [definedCommands()], (entries) => entries.flatMap((entry) => entry.shortcuts.map((shortcut) => ({
+		commandId: entry.definition.id,
+		shortcut
+	}))));
+	/** What running a command does: its `run`, or opening what it opens. */
+	const runCommand = async (definition, context) => {
+		if (definition.run) {
+			await definition.run(context);
 			return;
 		}
-		const shell = c.tryGet(ShellToken);
+		const shell = context.tryGet(ShellToken);
+		const panel = panelTarget(definition);
 		if (!shell) return;
-		const panel = panelTarget(entry.def);
-		if (entry.def.menu) shell.toggleMenu(entry.def.menu);
-		else if (panel) shell.toggle(panel.id, { exclusive: panel.exclusive });
-		else if (entry.def.modal) shell.toggle(entry.def.modal, { exclusive: "modal" });
+		if (definition.menu) shell.toggleMenu(definition.menu);
+		else if (panel) shell.toggle(panel.id, {
+			exclusive: panel.exclusive,
+			focus: panel.focus
+		});
+		else if (definition.modal) shell.toggle(definition.modal, { exclusive: "modal" });
 	};
-	return {
-		register: (def) => registerCommand(registry, def),
-		unregister: (id) => void registry.delete(id),
-		has: (id) => registry.has(id),
-		ids: () => [...registry.keys()],
-		resolve,
-		search: (query, documentId) => {
-			const q = query.trim().toLowerCase();
-			const hits = [];
-			for (const id of registry.keys()) {
-				const r = resolve(id, documentId);
-				if (!r || !r.visible) continue;
-				if (q === "" || r.label.toLowerCase().includes(q) || r.id.includes(q)) hits.push(r);
-			}
-			return hits;
+	const execute = async (id, options = {}) => {
+		const { signal, documentId, args } = options;
+		if (signal?.aborted) throw new PluginError("operation-cancelled", "commands", "operation cancelled");
+		const entry = entryOf(id);
+		if (!entry) return {
+			status: "rejected",
+			reason: "not-found"
+		};
+		const resolved = resolveCommand(id, documentId);
+		if (!resolved?.visible) return {
+			status: "rejected",
+			reason: "hidden"
+		};
+		if (!resolved.enabled) return {
+			status: "rejected",
+			reason: "disabled"
+		};
+		const context = commandContext(documentId, {
+			args,
+			signal
+		});
+		try {
+			await ctx.cancellable(signal, runCommand(entry.definition, context));
+		} catch (error) {
+			if (signal?.aborted && isPluginError(error, "operation-cancelled")) throw error;
+			const failure = toPluginError("commands", error);
+			executionFailed.emit({
+				commandId: id,
+				documentId: context.documentId,
+				error: toPluginErrorInfo(failure)
+			});
+			throw failure;
+		}
+		executed.emit({
+			commandId: id,
+			documentId: context.documentId,
+			args
+		});
+		return { status: "executed" };
+	};
+	const registerOne = (definition, options) => {
+		if ((registered.has(definition.id) || configured().commands.has(definition.id)) && !options?.replace) throw new PluginError("conflict", "commands", `duplicate command '${definition.id}'`);
+		const entry = registeredCommand(definition);
+		registered.set(definition.id, entry);
+		registeredChanged();
+		return () => {
+			if (registered.get(definition.id) !== entry) return;
+			registered.delete(definition.id);
+			registeredChanged();
+		};
+	};
+	const turningOff = createTurningOff(settings, (id) => entryOf(id)?.definition ?? null, isTurnedOff);
+	return { api: {
+		...settings.api,
+		registerCommand: registerOne,
+		registerCommands: (definitions, options) => {
+			const removers = definitions.map((definition) => registerOne(definition, options));
+			return () => removers.forEach((remove) => remove());
 		},
-		menuTarget: (id) => {
-			const entry = registry.get(id);
-			return entry ? { menu: entry.def.menu } : null;
+		hasCommand: (id) => entryOf(id) !== null,
+		getCommand: (id) => entryOf(id)?.definition ?? null,
+		listCommandIds: () => idsByDocument(""),
+		resolveCommand,
+		listCommands,
+		searchCommands: (query, documentId) => {
+			const needle = query.trim().toLowerCase();
+			return listCommands(documentId).filter((command) => command.visible && (needle === "" || command.label.toLowerCase().includes(needle) || command.id.includes(needle)));
 		},
+		listShortcuts,
 		execute,
-		matchStroke: (stroke, opts) => {
-			for (const [id, entry] of registry) if (entry.parsed.some((p) => matchShortcut(p, stroke, opts))) return id;
-			return null;
+		canExecute: (id, documentId) => {
+			const resolved = resolveCommand(id, documentId);
+			return !!resolved && resolved.enabled && resolved.visible;
 		},
-		disabledCategories: () => ctx.getState().disabledCategories,
-		isCategoryDisabled: (category) => ctx.getState().disabledCategories.includes(category),
-		disableCategory: (category) => ctx.dispatch({
-			type: "COMMANDS/DISABLE_CATEGORY",
-			category
-		}),
-		enableCategory: (category) => ctx.dispatch({
-			type: "COMMANDS/ENABLE_CATEGORY",
-			category
-		}),
-		setDisabledCategories: (categories) => ctx.dispatch({
-			type: "COMMANDS/SET_DISABLED_CATEGORIES",
-			categories
-		})
-	};
-}
-//#endregion
-//#region src/reducer.ts
-const initialCommandsState = { disabledCategories: [] };
-function commandsReducer(state, action) {
-	switch (action.type) {
-		case "COMMANDS/DISABLE_CATEGORY": return state.disabledCategories.includes(action.category) ? state : { disabledCategories: [...state.disabledCategories, action.category] };
-		case "COMMANDS/ENABLE_CATEGORY": return state.disabledCategories.includes(action.category) ? { disabledCategories: state.disabledCategories.filter((c) => c !== action.category) } : state;
-		case "COMMANDS/SET_DISABLED_CATEGORIES": return { disabledCategories: [...action.categories] };
-		default: return state;
-	}
+		getRefusal: (id, documentId) => {
+			const entry = entryOf(id);
+			return entry ? refusalOf(entry.definition, commandContext(documentId)) : null;
+		},
+		...turningOff,
+		onExecuted: executed.on,
+		onExecutionFailed: executionFailed.on,
+		matchStroke: (stroke, options) => {
+			let refused = null;
+			for (const entry of definedCommands()) {
+				if (options.inTextField && !entry.definition.shortcutInTextFields) continue;
+				if (!entry.parsed.some((shortcut) => matchShortcut(shortcut, stroke, options))) continue;
+				const context = commandContext();
+				const refusal = refusalOf(entry.definition, context);
+				if (!refusal) return {
+					commandId: entry.definition.id,
+					refusal: null
+				};
+				if (!derive(entry.definition.visible, context, true)) continue;
+				refused ?? (refused = {
+					commandId: entry.definition.id,
+					refusal
+				});
+			}
+			return refused;
+		},
+		getMenuTarget: (id) => {
+			const entry = entryOf(id);
+			return entry ? { menu: entry.definition.menu } : null;
+		}
+	} };
 }
 //#endregion
 //#region src/commands.plugin.ts
 /**
-* The commands plugin: workspace-scoped (one vocabulary for the whole
-* workspace; resolution/execution bind to a target document per call).
-* Definitions live in this closure — never in the store (they hold
-* functions); the store slice holds only `disabledCategories`.
+* The commands: one set for the whole workspace, each resolved and run for a
+* document (the one named, else the document in scope, else the active one).
+* Definitions are settings and app content, never state, since they hold
+* functions. `config` is the settings the app registers, over
+* {@link COMMANDS_DEFAULTS}.
 */
-const commandsPlugin = (config) => {
-	const registry = /* @__PURE__ */ new Map();
-	for (const def of config?.commands ?? []) registerCommand(registry, def);
-	return definePlugin({
-		id: "commands",
-		scope: "workspace",
-		token: CommandsToken,
-		initialState: {
-			...initialCommandsState,
-			disabledCategories: [...config?.disabledCategories ?? []]
-		},
-		reduce: commandsReducer,
-		capability: (ctx) => createCommandsCapability(ctx, registry)
-	});
-};
+const commandsPlugin = (config) => definePlugin({
+	id: "commands",
+	scope: "workspace",
+	token: CommandsToken$1,
+	optional: [I18nToken, ShellToken],
+	resolvesAnyCapability: true,
+	settings: {
+		defaults: COMMANDS_DEFAULTS,
+		registered: config
+	},
+	create: createCommandsController,
+	inScope: (commands, documentId) => ({
+		...commands,
+		resolveCommand: (id, target = documentId) => commands.resolveCommand(id, target),
+		listCommands: (target = documentId) => commands.listCommands(target),
+		searchCommands: (query, target = documentId) => commands.searchCommands(query, target),
+		execute: (id, options) => commands.execute(id, {
+			...options,
+			documentId: options?.documentId ?? documentId
+		}),
+		canExecute: (id, target = documentId) => commands.canExecute(id, target),
+		getRefusal: (id, target = documentId) => commands.getRefusal(id, target)
+	})
+});
 //#endregion
-export { CommandsToken, commandsPlugin, commandsReducer, initialCommandsState, resolvedCommandsEqual };
+export { COMMANDS_DEFAULTS, CommandsToken, boundCommandOf, commandsPlugin, resolvedCommandsEqual, unknownCommandWarning, unregisteredCommand };
 
 //# sourceMappingURL=index.js.map