modern-cmdk 1.0.2 → 1.1.0

package/dist/core/index.mjs

@@ -1,2 +1,1269 @@
-import { C as itemId, S as groupId, _ as computeFrecencyBonus, a as createScheduler, b as DEFAULT_MACHINE_OPTIONS, c as scoreItem, d as formatShortcut, f as parseShortcut, g as FrecencyEngine, h as matchesShortcut, i as createCommandMachine, l as CommandRegistry, m as findMatchingShortcut, n as batchScoreItems, o as TypedEmitter, p as detectConflicts, r as scoreItemAsync, s as createSearchEngine, t as createTelemetryMiddleware, u as KeyboardShortcutRegistry, v as MemoryFrecencyStorage, w as IdbFrecencyStorage, x as createInitialState, y as DEFAULT_FRECENCY_DECAY } from "../core-CgQYpHK3.mjs";
+//#region src/core/frecency/idb-storage.ts
+/** Serialize a FrecencyRecord to a JSON-safe format */
+function serializeRecord(record) {
+	return {
+		frequency: record.frequency,
+		lastUsedNs: record.lastUsed.epochNanoseconds.toString()
+	};
+}
+/** Deserialize a FrecencyRecord from its JSON-safe form */
+function deserializeRecord(serialized) {
+	return {
+		frequency: serialized.frequency,
+		lastUsed: Temporal.Instant.fromEpochNanoseconds(BigInt(serialized.lastUsedNs))
+	};
+}
+/** Serialize FrecencyData for IndexedDB storage — uses Iterator Helpers */
+function serializeData(data) {
+	return { records: data.records.entries().map(([id, record]) => [id, serializeRecord(record)]).toArray() };
+}
+/** Deserialize FrecencyData from IndexedDB storage — Iterator passed directly to Map (no .toArray()) */
+function deserializeData(serialized) {
+	return { records: new Map(serialized.records.values().map(([id, record]) => [id, deserializeRecord(record)])) };
+}
+/** Build the namespaced IDB key — String.toWellFormed() (ES2026) ensures valid Unicode in key */
+function storageKey(namespace) {
+	return `frecency:${namespace.isWellFormed() ? namespace : namespace.toWellFormed()}`;
+}
+let idbModule;
+/**
+* IndexedDB-backed frecency storage using idb-keyval 6.2.2.
+*
+* Persists frecency data across browser sessions. Implements both
+* `Disposable` and `AsyncDisposable` for use with `using` and `await using`.
+*
+* idb-keyval is lazy-loaded on first method call — consumers who import
+* the core module without using IDB frecency pay zero cost.
+*
+* @example
+* ```ts
+* await using storage = new IdbFrecencyStorage();
+* const data = await storage.load('my-app');
+* ```
+*/
+var IdbFrecencyStorage = class {
+	#dbName;
+	#storeName;
+	#store;
+	#disposed = false;
+	/**
+	* Create an IDB-backed frecency storage.
+	*
+	* @param dbName — IndexedDB database name (default: 'modern-cmdk')
+	* @param storeName — IndexedDB object store name (default: 'frecency')
+	*/
+	constructor(dbName = "modern-cmdk", storeName = "frecency") {
+		this.#dbName = dbName;
+		this.#storeName = storeName;
+	}
+	/** Lazy-load idb-keyval module — cached across all instances */
+	async #idb() {
+		idbModule ??= import("idb-keyval");
+		return idbModule;
+	}
+	/** Lazy-create the IDB store on first access */
+	async #getStore() {
+		if (!this.#store) {
+			const { createStore } = await this.#idb();
+			this.#store = createStore(this.#dbName, this.#storeName);
+		}
+		return this.#store;
+	}
+	/** Load frecency data from IndexedDB for the given namespace */
+	async load(namespace) {
+		if (this.#disposed) return { records: /* @__PURE__ */ new Map() };
+		const { get } = await this.#idb();
+		const store = await this.#getStore();
+		const serialized = await get(storageKey(namespace), store);
+		if (!serialized) return { records: /* @__PURE__ */ new Map() };
+		return deserializeData(serialized);
+	}
+	/** Save frecency data to IndexedDB for the given namespace */
+	async save(namespace, data) {
+		if (this.#disposed) return;
+		const { set } = await this.#idb();
+		const store = await this.#getStore();
+		await set(storageKey(namespace), serializeData(data), store);
+	}
+	/** Delete frecency data for a namespace from IndexedDB */
+	async delete(namespace) {
+		if (this.#disposed) return;
+		const { del } = await this.#idb();
+		const store = await this.#getStore();
+		await del(storageKey(namespace), store);
+	}
+	/** Synchronous dispose — marks as disposed (best-effort cleanup) */
+	[Symbol.dispose]() {
+		this.#disposed = true;
+	}
+	/** Async dispose — marks as disposed, suitable for `await using` */
+	async [Symbol.asyncDispose]() {
+		this.#disposed = true;
+	}
+};
+//#endregion
+//#region src/core/types.ts
+/** Create a branded {@link ItemId} from a plain string. Ensures well-formed Unicode (ES2026). */
+function itemId(id) {
+	return id.isWellFormed() ? id : id.toWellFormed();
+}
+/** Create a branded {@link GroupId} from a plain string. Ensures well-formed Unicode (ES2026). */
+function groupId(id) {
+	return id.isWellFormed() ? id : id.toWellFormed();
+}
+/** Default frecency decay configuration */
+const DEFAULT_FRECENCY_DECAY = {
+	hourWeight: 4,
+	dayWeight: 2,
+	weekWeight: 1.5,
+	monthWeight: 1,
+	olderWeight: .5
+};
+/** Default machine options */
+const DEFAULT_MACHINE_OPTIONS = {
+	loop: true,
+	virtualizeThreshold: 100,
+	open: false
+};
+/** Initial state factory */
+function createInitialState(options) {
+	return {
+		search: "",
+		activeId: null,
+		filteredIds: [],
+		groupedIds: /* @__PURE__ */ new Map(),
+		filteredCount: 0,
+		loading: false,
+		page: "root",
+		pageStack: [],
+		open: options?.open ?? false,
+		lastUpdated: Temporal.Now.instant()
+	};
+}
+//#endregion
+//#region src/core/frecency/memory-storage.ts
+/**
+* In-memory implementation of FrecencyStorage using a Map.
+* Data does not persist across page reloads. Suitable for ephemeral
+* sessions or as the default when no persistent storage is configured.
+*/
+var MemoryFrecencyStorage = class {
+	#store = /* @__PURE__ */ new Map();
+	load(namespace) {
+		return this.#store.get(namespace) ?? { records: /* @__PURE__ */ new Map() };
+	}
+	save(namespace, data) {
+		this.#store.set(namespace, data);
+	}
+	/** Serialize all stored data — Iterator Helpers pipeline (ES2026) */
+	toJSON() {
+		return Object.fromEntries(this.#store.entries().map(([namespace, data]) => [namespace, { records: data.records.entries().toArray() }]));
+	}
+	[Symbol.dispose]() {
+		this.#store.clear();
+	}
+};
+//#endregion
+//#region src/core/frecency/index.ts
+/** Shared empty bonus map — avoids allocation when no frecency records exist */
+const EMPTY_BONUS_MAP = /* @__PURE__ */ new Map();
+/** Pre-computed bucket boundaries in hours — avoids Duration.total() per call */
+const BUCKET_HOURS = {
+	hour: 1,
+	day: 24,
+	week: 168,
+	month: 720
+};
+/**
+* Computes a frecency bonus for an item based on usage frequency and recency.
+* Uses Temporal.Duration bucket boundaries (hour/day/week/month) with
+* configurable exponential decay weights per time bucket.
+*/
+function computeFrecencyBonus(history, now = Temporal.Now.instant(), config = DEFAULT_FRECENCY_DECAY) {
+	const hours = now.since(history.lastUsed).total("hours");
+	const { hourWeight = 4, dayWeight = 2, weekWeight = 1.5, monthWeight = 1, olderWeight = .5 } = config;
+	const recencyWeight = hours < BUCKET_HOURS.hour ? hourWeight : hours < BUCKET_HOURS.day ? dayWeight : hours < BUCKET_HOURS.week ? weekWeight : hours < BUCKET_HOURS.month ? monthWeight : olderWeight;
+	return history.frequency * recencyWeight;
+}
+/**
+* Stateful frecency engine that tracks item selection history and provides
+* ranking boosts for search results. Supports pluggable storage backends
+* and automatic flush on dispose. Uses Temporal.Now.instant() for timestamps.
+*/
+var FrecencyEngine = class {
+	#storage;
+	#namespace;
+	#data;
+	#config;
+	#dirty = false;
+	constructor(options) {
+		this.#storage = options.storage ?? new MemoryFrecencyStorage();
+		this.#namespace = options.namespace ?? "default";
+		this.#config = options.decayConfig ?? DEFAULT_FRECENCY_DECAY;
+		this.#data = { records: /* @__PURE__ */ new Map() };
+	}
+	/** Load frecency data from storage */
+	async load() {
+		this.#data = await this.#storage.load(this.#namespace);
+	}
+	/** Record a selection event for an item */
+	recordSelection(itemId) {
+		const now = Temporal.Now.instant();
+		const updated = {
+			frequency: (this.#data.records.get(itemId)?.frequency ?? 0) + 1,
+			lastUsed: now
+		};
+		this.#data.records.set(itemId, updated);
+		this.#dirty = true;
+	}
+	/** Get frecency bonus for an item */
+	getBonus(itemId, now) {
+		const record = this.#data.records.get(itemId);
+		if (!record) return 0;
+		return computeFrecencyBonus(record, now, this.#config);
+	}
+	/** Get all frecency bonuses as a map — for...of for hot ranking path (no closure overhead) */
+	getAllBonuses(now = Temporal.Now.instant()) {
+		if (this.#data.records.size === 0) return EMPTY_BONUS_MAP;
+		const bonuses = /* @__PURE__ */ new Map();
+		for (const [id, record] of this.#data.records) bonuses.set(id, computeFrecencyBonus(record, now, this.#config));
+		return bonuses;
+	}
+	/** Get the decay configuration */
+	getConfig() {
+		return this.#config;
+	}
+	/** Update decay configuration at runtime */
+	setConfig(config) {
+		this.#config = {
+			...this.#config,
+			...config
+		};
+	}
+	/** Flush dirty data to storage */
+	async flush() {
+		if (!this.#dirty) return;
+		await this.#storage.save(this.#namespace, this.#data);
+		this.#dirty = false;
+	}
+	/** Get the raw frecency data */
+	getData() {
+		return this.#data;
+	}
+	/** Async dispose — flushes dirty data before cleanup. Use with `await using`. */
+	async [Symbol.asyncDispose]() {
+		if (this.#dirty) {
+			await this.#storage.save(this.#namespace, this.#data);
+			this.#dirty = false;
+		}
+		this.#storage[Symbol.dispose]();
+	}
+	[Symbol.dispose]() {
+		if (this.#dirty) Promise.try(() => this.#storage.save(this.#namespace, this.#data)).catch((err) => {
+			console.warn("[modern-cmdk] FrecencyEngine dispose flush failed:", err);
+		});
+		this.#storage[Symbol.dispose]();
+	}
+};
+//#endregion
+//#region src/core/keyboard/matcher.ts
+/**
+* Tests whether a KeyboardEvent exactly matches a ParsedShortcut,
+* comparing all four modifier keys (meta, ctrl, shift, alt) and the primary key.
+*/
+function matchesShortcut(event, shortcut) {
+	if (shortcut.meta !== event.metaKey) return false;
+	if (shortcut.ctrl !== event.ctrlKey) return false;
+	if (shortcut.shift !== event.shiftKey) return false;
+	if (shortcut.alt !== event.altKey) return false;
+	return event.key.toLowerCase() === shortcut.key;
+}
+/** Match a KeyboardEvent against a list of shortcuts — Iterator Helpers .find() */
+function findMatchingShortcut(event, shortcuts) {
+	return shortcuts.values().find((shortcut) => matchesShortcut(event, shortcut)) ?? null;
+}
+/**
+* Detects conflicting shortcut bindings by grouping on their normalized form
+* via Map.groupBy (ES2026). Returns only groups with two or more colliding shortcuts.
+* Map.groupBy returns a Map directly — no Object.entries conversion needed.
+*/
+function detectConflicts(shortcuts) {
+	const grouped = Map.groupBy(shortcuts, (s) => s.normalized);
+	return new Map(grouped.entries().filter(([, group]) => group.length > 1));
+}
+//#endregion
+//#region src/core/keyboard/parser.ts
+const isMac = typeof navigator !== "undefined" && (navigator.userAgentData?.platform === "macOS" || /Mac|iPod|iPhone|iPad/.test(navigator.platform));
+/** Modifier aliases — cross-platform Mod resolution */
+const MODIFIER_MAP = {
+	mod: isMac ? "meta" : "ctrl",
+	meta: "meta",
+	cmd: "meta",
+	command: "meta",
+	ctrl: "ctrl",
+	control: "ctrl",
+	shift: "shift",
+	alt: "alt",
+	option: "alt",
+	opt: "alt"
+};
+/**
+* Parse a shortcut string like "Mod+Shift+K" into a structured ParsedShortcut.
+* Uses String.isWellFormed() (ES2026) to ensure valid Unicode input.
+*/
+function parseShortcut(shortcut) {
+	const safeShortcut = shortcut.isWellFormed() ? shortcut : shortcut.toWellFormed();
+	const parts = safeShortcut.split("+").map((p) => p.trim().toLowerCase());
+	let meta = false;
+	let ctrl = false;
+	let shift = false;
+	let alt = false;
+	let key = "";
+	for (const part of parts) {
+		const modifier = MODIFIER_MAP[part];
+		if (modifier) switch (modifier) {
+			case "meta":
+				meta = true;
+				break;
+			case "ctrl":
+				ctrl = true;
+				break;
+			case "shift":
+				shift = true;
+				break;
+			case "alt":
+				alt = true;
+				break;
+		}
+		else key = part;
+	}
+	const modifiers = [];
+	if (meta) modifiers.push("meta");
+	if (ctrl) modifiers.push("ctrl");
+	if (shift) modifiers.push("shift");
+	if (alt) modifiers.push("alt");
+	modifiers.push(key);
+	return {
+		key,
+		meta,
+		ctrl,
+		shift,
+		alt,
+		raw: safeShortcut,
+		normalized: modifiers.join("+")
+	};
+}
+/**
+* Formats a ParsedShortcut for display using platform-appropriate symbols.
+* On macOS: renders glyphs (⌘, ⇧, ⌥, ⌃). On other platforms: text labels joined by "+".
+*/
+function formatShortcut(parsed) {
+	const parts = [];
+	if (parsed.meta) parts.push(isMac ? "⌘" : "Ctrl");
+	if (parsed.ctrl && !(!isMac && parsed.meta)) parts.push(isMac ? "⌃" : "Ctrl");
+	if (parsed.shift) parts.push(isMac ? "⇧" : "Shift");
+	if (parsed.alt) parts.push(isMac ? "⌥" : "Alt");
+	const displayKey = parsed.key.length === 1 ? parsed.key.toUpperCase() : parsed.key.charAt(0).toUpperCase() + parsed.key.slice(1);
+	parts.push(displayKey);
+	return isMac ? parts.join("") : parts.join("+");
+}
+//#endregion
+//#region src/core/keyboard/index.ts
+/**
+* Manages keyboard shortcut bindings with global keydown listening.
+* Supports `using` for automatic cleanup of both individual bindings and the
+* global document listener. Detects conflicts via Map.groupBy (ES2026).
+*/
+var KeyboardShortcutRegistry = class {
+	#bindings = /* @__PURE__ */ new Map();
+	#globalListener = null;
+	#enabled = true;
+	constructor(options) {
+		this.#enabled = options?.enabled ?? true;
+		this.#attachGlobalListener();
+	}
+	/** Register a shortcut binding — returns Disposable for `using` auto-deregister */
+	register(shortcutStr, itemId, handler) {
+		const shortcut = parseShortcut(shortcutStr);
+		this.#bindings.set(shortcut.normalized, {
+			shortcut,
+			itemId,
+			handler
+		});
+		return { [Symbol.dispose]: () => {
+			this.#bindings.delete(shortcut.normalized);
+		} };
+	}
+	/** Unregister a shortcut by its string representation */
+	unregister(shortcutStr) {
+		const shortcut = parseShortcut(shortcutStr);
+		this.#bindings.delete(shortcut.normalized);
+	}
+	/** Unregister all shortcuts for a given item — Map spec allows deletion during iteration */
+	unregisterByItem(itemId) {
+		for (const [key, binding] of this.#bindings) if (binding.itemId === itemId) this.#bindings.delete(key);
+	}
+	/** Check for conflicting shortcuts */
+	getConflicts() {
+		return detectConflicts(this.#bindings.values().map((b) => b.shortcut).toArray());
+	}
+	/** Enable or disable global shortcut listening */
+	setEnabled(enabled) {
+		this.#enabled = enabled;
+	}
+	/** Get all registered bindings */
+	getBindings() {
+		return this.#bindings;
+	}
+	#attachGlobalListener() {
+		if (typeof document === "undefined") return;
+		this.#globalListener = (event) => {
+			if (!this.#enabled) return;
+			for (const binding of this.#bindings.values()) if (matchesShortcut(event, binding.shortcut)) {
+				event.preventDefault();
+				event.stopPropagation();
+				binding.handler();
+				return;
+			}
+		};
+		document.addEventListener("keydown", this.#globalListener);
+	}
+	#detachGlobalListener() {
+		if (this.#globalListener && typeof document !== "undefined") {
+			document.removeEventListener("keydown", this.#globalListener);
+			this.#globalListener = null;
+		}
+	}
+	[Symbol.dispose]() {
+		this.#detachGlobalListener();
+		this.#bindings.clear();
+	}
+};
+//#endregion
+//#region src/core/registry.ts
+/**
+* Manages registration and lookup of command items and groups.
+* Uses ES2026 Set methods (union/intersection/difference) for efficient ID operations.
+* All registration methods return Disposable for automatic cleanup via `using`.
+*/
+var CommandRegistry = class {
+	#items = /* @__PURE__ */ new Map();
+	#groups = /* @__PURE__ */ new Map();
+	#itemOrder = [];
+	#itemOrderSet = /* @__PURE__ */ new Set();
+	#cachedItems = null;
+	#cachedGroups = null;
+	#invalidateCache() {
+		this.#cachedItems = null;
+	}
+	#invalidateGroupCache() {
+		this.#cachedGroups = null;
+	}
+	/** Register an item — returns Disposable for `using` auto-deregister */
+	registerItem(item) {
+		this.#items.set(item.id, item);
+		if (!this.#itemOrderSet.has(item.id)) {
+			this.#itemOrder.push(item.id);
+			this.#itemOrderSet.add(item.id);
+		}
+		this.#invalidateCache();
+		return { [Symbol.dispose]: () => {
+			this.unregisterItem(item.id);
+		} };
+	}
+	/** Register multiple items at once — single Disposable for batch cleanup. for...of for hot path. */
+	registerItems(items) {
+		for (const item of items) {
+			this.#items.set(item.id, item);
+			if (!this.#itemOrderSet.has(item.id)) {
+				this.#itemOrder.push(item.id);
+				this.#itemOrderSet.add(item.id);
+			}
+		}
+		this.#invalidateCache();
+		const ids = new Set(items.values().map((i) => i.id));
+		return { [Symbol.dispose]: () => {
+			this.unregisterItems(ids);
+		} };
+	}
+	/** Unregister a single item — O(1) Map/Set delete, indexOf+toSpliced for order */
+	unregisterItem(id) {
+		if (!this.#items.has(id)) return;
+		this.#items.delete(id);
+		this.#itemOrderSet.delete(id);
+		const idx = this.#itemOrder.indexOf(id);
+		if (idx !== -1) this.#itemOrder = this.#itemOrder.toSpliced(idx, 1);
+		this.#invalidateCache();
+	}
+	/** Bulk unregister using Set.difference (ES2026) — for...of for hot path */
+	unregisterItems(ids) {
+		for (const id of ids) this.#items.delete(id);
+		this.#itemOrderSet = this.#itemOrderSet.difference(ids);
+		this.#itemOrder = this.#itemOrder.filter((id) => !ids.has(id));
+		this.#invalidateCache();
+	}
+	/** Register a group */
+	registerGroup(group) {
+		this.#groups.set(group.id, group);
+		this.#invalidateGroupCache();
+		return { [Symbol.dispose]: () => {
+			this.#groups.delete(group.id);
+			this.#invalidateGroupCache();
+		} };
+	}
+	/** Unregister a group */
+	unregisterGroup(id) {
+		this.#groups.delete(id);
+		this.#invalidateGroupCache();
+	}
+	/** Get an item by ID — O(1) */
+	getItem(id) {
+		return this.#items.get(id);
+	}
+	/** Get a group by ID — O(1) */
+	getGroup(id) {
+		return this.#groups.get(id);
+	}
+	/** Get all registered items in insertion order — cached between mutations */
+	getItems() {
+		if (this.#cachedItems !== null) return this.#cachedItems;
+		this.#cachedItems = this.#itemOrder.values().map((id) => this.#items.get(id)).filter((item) => item != null).toArray();
+		return this.#cachedItems;
+	}
+	/** Get all registered groups sorted by priority — cached between group mutations */
+	getGroups() {
+		if (this.#cachedGroups !== null) return this.#cachedGroups;
+		this.#cachedGroups = this.#groups.values().toArray().toSorted((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+		return this.#cachedGroups;
+	}
+	/** Get items grouped by groupId using Map.groupBy (ES2026) — direct Map, no Object.entries conversion */
+	getGroupedItems() {
+		const items = this.getItems();
+		const grouped = Map.groupBy(items, (item) => item.groupId ?? "__ungrouped");
+		const result = /* @__PURE__ */ new Map();
+		for (const group of this.getGroups()) {
+			const groupItems = grouped.get(group.id);
+			if (groupItems != null) result.set(group.id, groupItems);
+		}
+		const ungrouped = grouped.get("__ungrouped");
+		if (ungrouped) result.set("__ungrouped", ungrouped);
+		return result;
+	}
+	/** Get item IDs as a Set — returns internal set (O(1), no allocation) */
+	getItemIds() {
+		return this.#itemOrderSet;
+	}
+	/** Find intersection of registered items with a candidate set (ES2026 Set.intersection) */
+	intersectWith(candidateIds) {
+		return this.#itemOrderSet.intersection(candidateIds);
+	}
+	/** Find items registered but not in a given set (ES2026 Set.difference) */
+	differenceFrom(otherIds) {
+		return this.#itemOrderSet.difference(otherIds);
+	}
+	/** Union of registered IDs with another set (ES2026 Set.union) */
+	unionWith(otherIds) {
+		return this.#itemOrderSet.union(otherIds);
+	}
+	/** Check if registered items are a subset of the given set (ES2026 Set.isSubsetOf) */
+	isSubsetOf(otherIds) {
+		return this.#itemOrderSet.isSubsetOf(otherIds);
+	}
+	/** Check if registered items are a superset of the given set (ES2026 Set.isSupersetOf) */
+	isSupersetOf(otherIds) {
+		return this.#itemOrderSet.isSupersetOf(otherIds);
+	}
+	/** Check if registered items share no IDs with the given set (ES2026 Set.isDisjointFrom) */
+	isDisjointFrom(otherIds) {
+		return this.#itemOrderSet.isDisjointFrom(otherIds);
+	}
+	/** Symmetric difference between registered IDs and another set (ES2026 Set.symmetricDifference) */
+	symmetricDifferenceWith(otherIds) {
+		return this.#itemOrderSet.symmetricDifference(otherIds);
+	}
+	/** Total number of registered items */
+	get size() {
+		return this.#items.size;
+	}
+	/** Total number of registered groups */
+	get groupCount() {
+		return this.#groups.size;
+	}
+	/** Clear all items and groups */
+	clear() {
+		this.#items.clear();
+		this.#groups.clear();
+		this.#itemOrder = [];
+		this.#itemOrderSet.clear();
+		this.#invalidateCache();
+		this.#invalidateGroupCache();
+	}
+	[Symbol.dispose]() {
+		this.clear();
+	}
+};
+//#endregion
+//#region src/core/search/default-scorer.ts
+function isWordSeparator(code) {
+	return code === 32 || code === 9 || code === 45 || code === 95 || code === 46 || code === 47 || code === 92;
+}
+/**
+* Public API: scores a command item against a search query.
+* Multi-strategy: exact → prefix → substring → word-boundary → fuzzy.
+* Returns null if no match. For batch use, prefer the search engine
+* which pre-caches lowercase and normalizes query once.
+*/
+function scoreItem(query, item) {
+	if (query === "") return {
+		id: item.id,
+		score: 1,
+		matches: []
+	};
+	const lowerQuery = query.toLowerCase();
+	let bestScore = 0;
+	let bestMatches = null;
+	const valueResult = scoreTarget(lowerQuery, item.value.toLowerCase());
+	if (valueResult !== null) {
+		bestScore = valueResult.score;
+		bestMatches = valueResult.matches;
+		if (bestScore >= 1) return {
+			id: item.id,
+			score: 1,
+			matches: bestMatches
+		};
+	}
+	const kw = item.keywords;
+	if (kw !== void 0) for (let i = 0; i < kw.length; i++) {
+		const result = scoreTarget(lowerQuery, kw[i].toLowerCase());
+		if (result !== null && result.score > bestScore) {
+			bestScore = result.score;
+			bestMatches = result.matches;
+			if (bestScore >= 1) break;
+		}
+	}
+	return bestMatches !== null ? {
+		id: item.id,
+		score: bestScore,
+		matches: bestMatches
+	} : null;
+}
+/**
+* Internal fast path: called by search engine with pre-lowered query and targets.
+* Eliminates all toLowerCase() calls on the hot path.
+*/
+function scoreItemPreLowered(lowerQuery, id, lowerValue, lowerKeywords) {
+	let bestScore = 0;
+	let bestMatches = null;
+	const valueResult = scoreTarget(lowerQuery, lowerValue);
+	if (valueResult !== null) {
+		bestScore = valueResult.score;
+		bestMatches = valueResult.matches;
+		if (bestScore >= 1) return {
+			id,
+			score: 1,
+			matches: bestMatches
+		};
+	}
+	if (lowerKeywords !== void 0) for (let i = 0; i < lowerKeywords.length; i++) {
+		const result = scoreTarget(lowerQuery, lowerKeywords[i]);
+		if (result !== null && result.score > bestScore) {
+			bestScore = result.score;
+			bestMatches = result.matches;
+			if (bestScore >= 1) break;
+		}
+	}
+	return bestMatches !== null ? {
+		id,
+		score: bestScore,
+		matches: bestMatches
+	} : null;
+}
+function scoreTarget(query, lowerTarget) {
+	const tLen = lowerTarget.length;
+	if (tLen === 0) return null;
+	const qLen = query.length;
+	if (qLen === 0) return {
+		score: 1,
+		matches: []
+	};
+	if (qLen > tLen) return null;
+	if (lowerTarget === query) return {
+		score: 1,
+		matches: [[0, qLen]]
+	};
+	if (lowerTarget.startsWith(query)) return {
+		score: .9 + .1 * (qLen / tLen),
+		matches: [[0, qLen]]
+	};
+	const substringIdx = lowerTarget.indexOf(query);
+	if (substringIdx !== -1) {
+		const positionBonus = 1 - substringIdx / tLen;
+		const lengthRatio = qLen / tLen;
+		return {
+			score: .5 + .3 * positionBonus + .2 * lengthRatio,
+			matches: [[substringIdx, substringIdx + qLen]]
+		};
+	}
+	const wordBoundaryResult = scoreWordBoundary(query, qLen, lowerTarget, tLen);
+	if (wordBoundaryResult) return wordBoundaryResult;
+	return scoreFuzzy(query, qLen, lowerTarget, tLen);
+}
+function scoreWordBoundary(query, qLen, lowerTarget, tLen) {
+	let queryIdx = 0;
+	const matches = [];
+	let totalWeightedLen = 0;
+	let i = 0;
+	while (i < tLen && queryIdx < qLen) if ((i === 0 || isWordSeparator(lowerTarget.charCodeAt(i - 1))) && lowerTarget.charCodeAt(i) === query.charCodeAt(queryIdx)) {
+		const matchStart = i;
+		let matchLen = 0;
+		while (queryIdx < qLen && i < tLen && !isWordSeparator(lowerTarget.charCodeAt(i)) && lowerTarget.charCodeAt(i) === query.charCodeAt(queryIdx)) {
+			queryIdx++;
+			i++;
+			matchLen++;
+		}
+		matches.push([matchStart, matchStart + matchLen]);
+		totalWeightedLen += matchLen * 2;
+	} else i++;
+	if (queryIdx !== qLen) return null;
+	const maxPossible = qLen * 2;
+	return {
+		score: .3 + .4 * (totalWeightedLen / maxPossible),
+		matches
+	};
+}
+function scoreFuzzy(query, qLen, lowerTarget, tLen) {
+	let queryIdx = 0;
+	let targetIdx = 0;
+	const matches = [];
+	let currentMatchStart = -1;
+	let contiguityScore = 0;
+	while (queryIdx < qLen && targetIdx < tLen) if (query.charCodeAt(queryIdx) === lowerTarget.charCodeAt(targetIdx)) {
+		if (currentMatchStart === -1) currentMatchStart = targetIdx;
+		queryIdx++;
+		targetIdx++;
+	} else {
+		if (currentMatchStart !== -1) {
+			const segmentLen = targetIdx - currentMatchStart;
+			matches.push([currentMatchStart, targetIdx]);
+			contiguityScore += segmentLen * segmentLen;
+			currentMatchStart = -1;
+		}
+		targetIdx++;
+	}
+	if (currentMatchStart !== -1) {
+		const segmentLen = targetIdx - currentMatchStart;
+		matches.push([currentMatchStart, targetIdx]);
+		contiguityScore += segmentLen * segmentLen;
+	}
+	if (queryIdx !== qLen) return null;
+	const maxContiguity = qLen * qLen;
+	const contiguityRatio = contiguityScore / maxContiguity;
+	const positionBonus = 1 - (matches[0]?.[0] ?? 0) / tLen;
+	const lengthRatio = qLen / tLen;
+	return {
+		score: .1 + .3 * contiguityRatio + .15 * positionBonus + .1 * lengthRatio,
+		matches
+	};
+}
+//#endregion
+//#region src/core/search/index.ts
+const __DEV__ = globalThis.process ? globalThis.process.env.NODE_ENV !== "production" : false;
+let leakRegistry;
+if (__DEV__) leakRegistry = new FinalizationRegistry((label) => {
+	console.warn(`[modern-cmdk] ${label} was garbage collected without being disposed. Use \`using\` or call [Symbol.dispose]() to prevent leaks.`);
+});
+/**
+* Creates a search engine with pluggable scorer and incremental filtering.
+* When the query extends the previous one, only prior matches are re-scored.
+* Pre-caches lowercase at index time — zero toLowerCase() calls during search.
+* Uses Iterator Helpers (ES2026) for result pipelines and Set.difference for pruning.
+*/
+function createSearchEngine(options) {
+	const customScorer = options?.scorer;
+	const useDefaultScorer = customScorer === void 0;
+	const indexedEntries = /* @__PURE__ */ new Map();
+	let previousQuery = "";
+	let previousResults = /* @__PURE__ */ new Set();
+	const sentinel = {};
+	if (__DEV__ && leakRegistry) leakRegistry.register(sentinel, "SearchEngine", sentinel);
+	return {
+		index(items) {
+			for (const item of items) indexedEntries.set(item.id, {
+				item,
+				lowerValue: item.value.toLowerCase(),
+				lowerKeywords: item.keywords?.map((k) => k.toLowerCase())
+			});
+			previousQuery = "";
+			previousResults = /* @__PURE__ */ new Set();
+		},
+		search(query, items) {
+			if (query === "") {
+				previousQuery = "";
+				previousResults = new Set(items.values().map((i) => i.id));
+				return items.values().map((item) => ({
+					id: item.id,
+					score: 1,
+					matches: []
+				}));
+			}
+			const lowerQuery = query.toLowerCase();
+			const candidateItems = query.startsWith(previousQuery) && previousQuery.length > 0 ? items.values().filter((item) => previousResults.has(item.id)) : items;
+			const results = [];
+			if (useDefaultScorer) for (const item of candidateItems) {
+				const entry = indexedEntries.get(item.id);
+				const result = entry ? scoreItemPreLowered(lowerQuery, item.id, entry.lowerValue, entry.lowerKeywords) : scoreItemPreLowered(lowerQuery, item.id, item.value.toLowerCase(), item.keywords?.map((k) => k.toLowerCase()));
+				if (result !== null) results.push(result);
+			}
+			else for (const item of candidateItems) {
+				const result = customScorer(query, item);
+				if (result != null) results.push(result);
+			}
+			results.sort((a, b) => b.score - a.score);
+			previousQuery = query;
+			previousResults = new Set(results.values().map((r) => r.id));
+			return results.values();
+		},
+		remove(ids) {
+			for (const id of ids) indexedEntries.delete(id);
+			previousResults = previousResults.difference(ids);
+		},
+		clear() {
+			indexedEntries.clear();
+			previousQuery = "";
+			previousResults.clear();
+		},
+		[Symbol.dispose]() {
+			indexedEntries.clear();
+			previousResults.clear();
+			if (__DEV__ && leakRegistry) leakRegistry.unregister(sentinel);
+		}
+	};
+}
+//#endregion
+//#region src/core/utils/event-emitter.ts
+/**
+* Type-safe event emitter with strong references and Disposable subscriptions.
+* Returns Disposable from `on()` for automatic unsubscription via `using`.
+*/
+var TypedEmitter = class {
+	#listeners = /* @__PURE__ */ new Map();
+	/** Subscribe to an event. Returns a Disposable that removes the listener when disposed. */
+	on(event, listener) {
+		let set = this.#listeners.get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.#listeners.set(event, set);
+		}
+		const fn = listener;
+		set.add(fn);
+		return { [Symbol.dispose]: () => {
+			set.delete(fn);
+		} };
+	}
+	/** Emit an event to all listeners. Snapshots the set to prevent live-iteration issues. */
+	emit(event, data) {
+		const set = this.#listeners.get(event);
+		if (!set || set.size === 0) return;
+		for (const fn of [...set]) fn(data);
+	}
+	/** Check if any listeners exist for an event */
+	has(event) {
+		const set = this.#listeners.get(event);
+		return set !== void 0 && set.size > 0;
+	}
+	/** Get count of listeners for an event */
+	listenerCount(event) {
+		return this.#listeners.get(event)?.size ?? 0;
+	}
+	/** Remove all listeners */
+	removeAll() {
+		this.#listeners.clear();
+	}
+	[Symbol.dispose]() {
+		this.#listeners.clear();
+	}
+};
+//#endregion
+//#region src/core/utils/scheduler.ts
+/** Whether we're in a browser environment with rAF available */
+const hasRAF = typeof requestAnimationFrame === "function";
+/** Feature detection for cutting-edge scheduling APIs */
+const canYield = typeof globalThis.scheduler?.yield === "function";
+const hasInputPending = typeof navigator?.scheduling?.isInputPending === "function";
+/**
+* Creates a batched update scheduler. Coalesces rapid state updates into a single
+* execution pass using rAF (browser) or queueMicrotask (Node.js).
+*/
+function createScheduler() {
+	let pending = [];
+	let rafId = null;
+	let microtaskScheduled = false;
+	function executeBatch() {
+		const batch = pending;
+		pending = [];
+		rafId = null;
+		microtaskScheduled = false;
+		if (batch.length > 10 && hasInputPending && navigator.scheduling?.isInputPending?.()) {
+			pending = [...batch, ...pending];
+			if (canYield) globalThis.scheduler?.yield?.().then(() => void executeBatch());
+			else rafId ??= requestAnimationFrame(() => void executeBatch());
+			return;
+		}
+		for (const update of batch) try {
+			update();
+		} catch (error) {
+			queueMicrotask(() => {
+				throw error;
+			});
+		}
+	}
+	function flush() {
+		if (rafId !== null) {
+			cancelAnimationFrame(rafId);
+			rafId = null;
+		}
+		microtaskScheduled = false;
+		executeBatch();
+	}
+	return {
+		schedule(update) {
+			pending.push(update);
+			if (hasRAF) rafId ??= requestAnimationFrame(() => void executeBatch());
+			else if (!microtaskScheduled) {
+				microtaskScheduled = true;
+				queueMicrotask(executeBatch);
+			}
+		},
+		flush,
+		[Symbol.dispose]() {
+			if (rafId !== null) {
+				cancelAnimationFrame(rafId);
+				rafId = null;
+			}
+			microtaskScheduled = false;
+			pending = [];
+		}
+	};
+}
+//#endregion
+//#region src/core/machine.ts
+/**
+* Creates a headless command palette state machine with search, frecency,
+* and keyboard shortcut support. Implements Disposable for `using` cleanup.
+*
+* @example
+* ```ts
+* using machine = createCommandMachine({ items, loop: true });
+* machine.subscribe(() => console.log(machine.getState()));
+* ```
+*/
+function createCommandMachine(options = {}) {
+	let state = createInitialState(options);
+	let filteredIdSet = /* @__PURE__ */ new Set();
+	let filteredIdIndex = /* @__PURE__ */ new Map();
+	const registry = new CommandRegistry();
+	const searchEngine = options.search ?? createSearchEngine(typeof options.filter === "function" ? { scorer: (query, item) => {
+		const score = options.filter(item, query);
+		if (score === false) return null;
+		return {
+			id: item.id,
+			score,
+			matches: []
+		};
+	} } : void 0);
+	const scheduler = createScheduler();
+	const emitter = new TypedEmitter();
+	const keyboardRegistry = new KeyboardShortcutRegistry();
+	let frecencyEngine = null;
+	if (options.frecency?.enabled) {
+		frecencyEngine = new FrecencyEngine(options.frecency);
+		frecencyEngine.load();
+	}
+	if (options.items) {
+		registry.registerItems(options.items);
+		searchEngine.index(options.items);
+		for (const item of options.items) if (item.shortcut != null && item.onSelect != null) keyboardRegistry.register(item.shortcut, item.id, item.onSelect);
+	}
+	if (options.groups) for (const group of options.groups) registry.registerGroup(group);
+	refilter("");
+	function setState(newState) {
+		state = newState;
+		emitter.emit("stateChange", state);
+	}
+	function refilter(query) {
+		const items = registry.getItems();
+		const disableFilter = options.filter === false;
+		let filteredIds;
+		if (disableFilter || query === "") filteredIds = items.values().filter((i) => !i.disabled).map((i) => i.id).toArray();
+		else {
+			let results = searchEngine.search(query, items).toArray();
+			if (frecencyEngine) {
+				const bonuses = frecencyEngine.getAllBonuses();
+				results = results.toSorted((a, b) => {
+					const aBonus = bonuses.get(a.id) ?? 0;
+					const bBonus = bonuses.get(b.id) ?? 0;
+					return b.score + bBonus - (a.score + aBonus);
+				});
+			}
+			filteredIds = results.map((r) => r.id);
+		}
+		filteredIdSet = new Set(filteredIds);
+		filteredIdIndex = new Map(filteredIds.entries().map(([i, id]) => [id, i]));
+		const groupedIds = Map.groupBy(filteredIds, (id) => {
+			return registry.getItem(id)?.groupId ?? "__ungrouped";
+		});
+		const activeId = state.activeId && filteredIdSet.has(state.activeId) ? state.activeId : filteredIds[0] ?? null;
+		setState({
+			...state,
+			search: query,
+			filteredIds,
+			groupedIds,
+			filteredCount: filteredIds.length,
+			activeId,
+			lastUpdated: Temporal.Now.instant()
+		});
+	}
+	function navigate(direction) {
+		const { filteredIds, activeId } = state;
+		if (filteredIds.length === 0) return;
+		if (direction === "first") {
+			const newActiveId = filteredIds[0] ?? null;
+			if (newActiveId !== activeId) {
+				setState({
+					...state,
+					activeId: newActiveId,
+					lastUpdated: Temporal.Now.instant()
+				});
+				options.onActiveChange?.(newActiveId);
+			}
+			return;
+		}
+		if (direction === "last") {
+			const newActiveId = filteredIds[filteredIds.length - 1] ?? null;
+			if (newActiveId !== activeId) {
+				setState({
+					...state,
+					activeId: newActiveId,
+					lastUpdated: Temporal.Now.instant()
+				});
+				options.onActiveChange?.(newActiveId);
+			}
+			return;
+		}
+		const loop = options.loop ?? true;
+		const currentIdx = activeId ? filteredIdIndex.get(activeId) ?? -1 : -1;
+		let newIdx;
+		if (direction === "next") if (currentIdx === -1 || currentIdx >= filteredIds.length - 1) newIdx = loop ? 0 : filteredIds.length - 1;
+		else newIdx = currentIdx + 1;
+		else if (currentIdx <= 0) newIdx = loop ? filteredIds.length - 1 : 0;
+		else newIdx = currentIdx - 1;
+		const newActiveId = filteredIds[newIdx] ?? null;
+		if (newActiveId !== activeId) {
+			setState({
+				...state,
+				activeId: newActiveId,
+				lastUpdated: Temporal.Now.instant()
+			});
+			options.onActiveChange?.(newActiveId);
+		}
+	}
+	function handleEvent(event) {
+		switch (event.type) {
+			case "SEARCH_CHANGE":
+				refilter(event.query);
+				options.onSearchChange?.(event.query);
+				break;
+			case "ITEM_SELECT": {
+				const item = registry.getItem(event.id);
+				if (item && !item.disabled) {
+					item.onSelect?.();
+					frecencyEngine?.recordSelection(event.id);
+					emitter.emit("select", event.id);
+					options.onSelect?.(event.id);
+				}
+				break;
+			}
+			case "ITEM_ACTIVATE":
+				if (filteredIdSet.has(event.id)) {
+					setState({
+						...state,
+						activeId: event.id,
+						lastUpdated: Temporal.Now.instant()
+					});
+					options.onActiveChange?.(event.id);
+				}
+				break;
+			case "NAVIGATE":
+				navigate(event.direction);
+				break;
+			case "PAGE_PUSH":
+				setState({
+					...state,
+					page: event.page,
+					pageStack: [...state.pageStack, state.page],
+					lastUpdated: Temporal.Now.instant()
+				});
+				break;
+			case "PAGE_POP": {
+				const prevPage = state.pageStack.at(-1);
+				if (prevPage != null) setState({
+					...state,
+					page: prevPage,
+					pageStack: state.pageStack.toSpliced(-1, 1),
+					lastUpdated: Temporal.Now.instant()
+				});
+				break;
+			}
+			case "OPEN":
+				setState({
+					...state,
+					open: true,
+					lastUpdated: Temporal.Now.instant()
+				});
+				emitter.emit("openChange", true);
+				options.onOpenChange?.(true);
+				break;
+			case "CLOSE":
+				setState({
+					...state,
+					open: false,
+					lastUpdated: Temporal.Now.instant()
+				});
+				emitter.emit("openChange", false);
+				options.onOpenChange?.(false);
+				break;
+			case "TOGGLE": {
+				const newOpen = !state.open;
+				setState({
+					...state,
+					open: newOpen,
+					lastUpdated: Temporal.Now.instant()
+				});
+				emitter.emit("openChange", newOpen);
+				options.onOpenChange?.(newOpen);
+				break;
+			}
+			case "ITEMS_LOADED":
+				registry.registerItems(event.items);
+				searchEngine.index(event.items);
+				state = {
+					...state,
+					loading: false
+				};
+				refilter(state.search);
+				break;
+			case "REGISTER_ITEM":
+				registry.registerItem(event.item);
+				searchEngine.index([event.item]);
+				if (event.item.shortcut && event.item.onSelect) keyboardRegistry.register(event.item.shortcut, event.item.id, event.item.onSelect);
+				refilter(state.search);
+				break;
+			case "UNREGISTER_ITEM":
+				registry.unregisterItem(event.id);
+				searchEngine.remove(new Set([event.id]));
+				keyboardRegistry.unregisterByItem(event.id);
+				refilter(state.search);
+				break;
+			case "REGISTER_GROUP":
+				registry.registerGroup(event.group);
+				refilter(state.search);
+				break;
+			case "UNREGISTER_GROUP":
+				registry.unregisterGroup(event.id);
+				refilter(state.search);
+				break;
+		}
+	}
+	return {
+		getState() {
+			return state;
+		},
+		send(event) {
+			scheduler.schedule(() => handleEvent(event));
+		},
+		subscribe(listener) {
+			const disposable = emitter.on("stateChange", listener);
+			return () => disposable[Symbol.dispose]();
+		},
+		subscribeState(listener) {
+			return emitter.on("stateChange", listener);
+		},
+		getRegistry() {
+			return registry;
+		},
+		getKeyboardRegistry() {
+			return keyboardRegistry;
+		},
+		getFilteredIdSet() {
+			return filteredIdSet;
+		},
+		getFilteredIdIndex() {
+			return filteredIdIndex;
+		},
+		[Symbol.dispose]() {
+			scheduler[Symbol.dispose]();
+			registry[Symbol.dispose]();
+			searchEngine[Symbol.dispose]();
+			emitter[Symbol.dispose]();
+			keyboardRegistry[Symbol.dispose]();
+			frecencyEngine?.[Symbol.dispose]();
+		}
+	};
+}
+//#endregion
+//#region src/core/search/fuzzy-scorer.ts
+/**
+* Async-safe fuzzy scorer — wraps scoring in Promise.try (ES2026) for error resilience.
+* Falls back gracefully on error via Promise.try's synchronous-throw capture.
+*/
+function scoreItemAsync(query, item) {
+	return Promise.try(() => scoreItem(query, item));
+}
+/**
+* Batch score items synchronously inside a single Promise.try (ES2026).
+* Eliminates per-item microtask overhead from async generators — runs the
+* entire scoring pipeline in one synchronous pass, wrapped for error safety.
+*/
+function batchScoreItems(query, items) {
+	return Promise.try(() => items.values().map((item) => scoreItem(query, item)).filter((r) => r != null).toArray().toSorted((a, b) => b.score - a.score));
+}
+//#endregion
+//#region src/core/telemetry.ts
+/**
+* Creates a telemetry middleware that measures command palette interactions.
+* Uses Temporal.Now.instant() (ES2026) for nanosecond-precision timestamps
+* and Temporal.Instant.since() for accurate duration computation.
+*
+* @example
+* ```ts
+* const telemetry = createTelemetryMiddleware({
+*   onPaletteOpen: () => analytics.track('palette_opened'),
+*   onItemSelected: (id, query, pos) => analytics.track('item_selected', { id, query, position: pos }),
+* });
+* ```
+*/
+function createTelemetryMiddleware(hooks) {
+	let openTimestamp = null;
+	return {
+		onOpen() {
+			openTimestamp = Temporal.Now.instant();
+			hooks.onPaletteOpen?.();
+		},
+		onClose() {
+			if (openTimestamp != null) {
+				const elapsed = Temporal.Now.instant().since(openTimestamp);
+				hooks.onPaletteClose?.(elapsed.total("milliseconds"));
+				openTimestamp = null;
+			}
+		},
+		onSearch(query, resultCount, startTime) {
+			const elapsed = Temporal.Now.instant().since(startTime);
+			hooks.onSearchComplete?.(query, resultCount, elapsed.total("milliseconds"));
+		},
+		onSelect(itemId, query, position) {
+			hooks.onItemSelected?.(itemId, query, position);
+		}
+	};
+}
+//#endregion
 export { CommandRegistry, DEFAULT_FRECENCY_DECAY, DEFAULT_MACHINE_OPTIONS, FrecencyEngine, IdbFrecencyStorage, KeyboardShortcutRegistry, MemoryFrecencyStorage, TypedEmitter, batchScoreItems, computeFrecencyBonus, createCommandMachine, createInitialState, createScheduler, createSearchEngine, createTelemetryMiddleware, detectConflicts, findMatchingShortcut, formatShortcut, groupId, itemId, matchesShortcut, parseShortcut, scoreItem, scoreItemAsync };