modern-cmdk 1.0.1 → 1.1.0

package/dist/core-DZT7Vwmo.mjs

@@ -1,1219 +0,0 @@
-import { createStore, del, get, set } from "idb-keyval";
-//#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 — uses Iterator Helpers */
-function deserializeData(serialized) {
-	const entries = serialized.records.values().map(([id, record]) => [id, deserializeRecord(record)]).toArray();
-	return { records: new Map(entries) };
-}
-/** Build the namespaced IDB key — String.toWellFormed() (ES2026) ensures valid Unicode in key */
-function storageKey(namespace) {
-	return `frecency:${namespace.isWellFormed() ? namespace : namespace.toWellFormed()}`;
-}
-/**
-* 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`.
-*
-* @example
-* ```ts
-* await using storage = new IdbFrecencyStorage();
-* const data = await storage.load('my-app');
-* ```
-*/
-var IdbFrecencyStorage = class {
-	#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.#store = createStore(dbName, storeName);
-	}
-	/** Load frecency data from IndexedDB for the given namespace */
-	async load(namespace) {
-		if (this.#disposed) return { records: /* @__PURE__ */ new Map() };
-		const serialized = await get(storageKey(namespace), this.#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;
-		await set(storageKey(namespace), serializeData(data), this.#store);
-	}
-	/** Delete frecency data for a namespace from IndexedDB */
-	async delete(namespace) {
-		if (this.#disposed) return;
-		await del(storageKey(namespace), this.#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 — satisfies on value, not interface */
-const DEFAULT_FRECENCY_DECAY = {
-	hourWeight: 4,
-	dayWeight: 2,
-	weekWeight: 1.5,
-	monthWeight: 1,
-	olderWeight: .5
-};
-/** Default machine options — satisfies on value */
-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
-/** 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
-		};
-		const newRecords = new Map(this.#data.records);
-		newRecords.set(itemId, updated);
-		this.#data = { records: newRecords };
-		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()) {
-		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;
-	}
-	[Symbol.dispose]() {
-		if (this.#dirty) {
-			const result = this.#storage.save(this.#namespace, this.#data);
-			if (result instanceof Promise) result.catch(() => {});
-		}
-		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((entry) => entry[1].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 RegExp.escape (ES2026) for safe pattern construction from user-provided strings.
-* 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 — for...of with deferred delete (avoids mutation during iteration) */
-	unregisterByItem(itemId) {
-		const keysToDelete = [];
-		for (const [key, binding] of this.#bindings) if (binding.itemId === itemId) keysToDelete.push(key);
-		for (const key of keysToDelete) 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;
-	#invalidateCache() {
-		this.#cachedItems = 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]: () => {
-			for (const id of ids) this.unregisterItem(id);
-		} };
-	}
-	/** Unregister a single item — O(1) Map delete + Set delete, O(n) order rebuild */
-	unregisterItem(id) {
-		if (!this.#items.has(id)) return;
-		this.#items.delete(id);
-		this.#itemOrderSet.delete(id);
-		this.#itemOrder = this.#itemOrder.filter((orderId) => orderId !== id);
-		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);
-		return { [Symbol.dispose]: () => {
-			this.#groups.delete(group.id);
-		} };
-	}
-	/** Unregister a group */
-	unregisterGroup(id) {
-		this.#groups.delete(id);
-	}
-	/** 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 */
-	getGroups() {
-		return this.#groups.values().toArray().sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
-	}
-	/** 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();
-	}
-	[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 scoreFuzzy(query, qLen, lowerTarget, tLen);
-	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) => {});
-/**
-* 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())
-			});
-		},
-		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.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) {
-		const set = this.#listeners.get(event) ?? /* @__PURE__ */ new Set();
-		const fn = listener;
-		set.add(fn);
-		this.#listeners.set(event, set);
-		return { [Symbol.dispose]: () => {
-			set.delete(fn);
-		} };
-	}
-	/** Emit an event to all listeners. Hot path — for...of, zero allocation. */
-	emit(event, data) {
-		const set = this.#listeners.get(event);
-		if (!set) 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() {
-		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);
-	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 = [];
-			for (const i of items) if (!i.disabled) filteredIds.push(i.id);
-		} else {
-			const results = searchEngine.search(query, items).toArray();
-			if (frecencyEngine) {
-				const bonuses = frecencyEngine.getAllBonuses();
-				results.sort((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.map((id, i) => [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.slice(0, -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;
-		},
-		[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.
-*/
-async function scoreItemAsync(query, item) {
-	return Promise.try(() => scoreItem(query, item));
-}
-/**
-* Async generator that yields score results for each item.
-* Enables streaming consumption and lazy evaluation of scoring operations.
-*/
-async function* scoreItemsGenerator(query, items) {
-	for (const item of items) yield Promise.try(() => scoreItem(query, item)).catch(() => null);
-}
-/**
-* Batch score items using Array.fromAsync (ES2026) with an async generator pipeline.
-* Uses Promise.try for safe execution of each scoring operation and Array.fromAsync
-* for materializing the async iterable into a concrete array.
-*/
-async function batchScoreItems(query, items) {
-	return (await Array.fromAsync(scoreItemsGenerator(query, items))).filter((r) => r != null).sort((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 { itemId as C, groupId as S, computeFrecencyBonus as _, createScheduler as a, DEFAULT_MACHINE_OPTIONS as b, scoreItem as c, formatShortcut as d, parseShortcut as f, FrecencyEngine as g, matchesShortcut as h, createCommandMachine as i, CommandRegistry as l, findMatchingShortcut as m, batchScoreItems as n, TypedEmitter as o, detectConflicts as p, scoreItemAsync as r, createSearchEngine as s, createTelemetryMiddleware as t, KeyboardShortcutRegistry as u, MemoryFrecencyStorage as v, IdbFrecencyStorage as w, createInitialState as x, DEFAULT_FRECENCY_DECAY as y };
-
-//# sourceMappingURL=core-DZT7Vwmo.mjs.map