modern-cmdk 1.4.0 → 1.6.0

package/dist/core/index.mjs

@@ -16,27 +16,68 @@ function ensureWellFormed(str) {
 	return str.replace(LONE_SURROGATE_RE, REPLACEMENT_CHAR);
 }
 // src/core/frecency/idb-storage.ts
-/** Serialize a FrecencyRecord to a JSON-safe format */
-function serializeRecord(record) {
-	return {
-		frequency: record.frequency,
-		lastUsedMs: record.lastUsed
-	};
-}
-/** Deserialize a FrecencyRecord from its JSON-safe form */
-function deserializeRecord(serialized) {
-	return {
-		frequency: serialized.frequency,
-		lastUsed: serialized.lastUsedMs
-	};
-}
-/** Serialize FrecencyData for IndexedDB storage — uses Iterator Helpers */
+Symbol.dispose ??= Symbol.for("Symbol.dispose");
+Symbol.asyncDispose ??= Symbol.for("Symbol.asyncDispose");
+/** Serialize FrecencyData as v1 for IndexedDB storage — uses Iterator Helpers */
 function serializeData(data) {
-	return { records: data.records.entries().map(([id, record]) => [id, serializeRecord(record)]).toArray() };
+	return { records: data.records.entries().map(([id, { frequency, lastUsed }]) => [id, {
+		frequency,
+		lastUsedMs: lastUsed
+	}]).toArray() };
+}
+const isNonNegative = (n) => Number.isFinite(n) && n >= 0;
+/**
+* Validate a persisted payload (untrusted: it may be corrupt, foreign or from a
+* newer schema). Keeps the rows that are `[string, { frequency, lastUsedMs }]`
+* with finite numbers >= 0 and counts the rest in a single warning; a repeated id
+* counts toward that number and the last row with it wins. A payload
+* that is not a v1 or v2 record map counts as one dropped row and yields empty
+* data; `undefined` (nothing stored) is not a warning.
+*/
+function deserializeData(raw) {
+	const payload = raw;
+	const rows = raw === void 0 ? [] : Array.isArray(payload?.records) && [
+		void 0,
+		1,
+		2
+	].includes(payload.version) ? payload.records : [null];
+	const records = new Map(rows.values().filter((row) => Array.isArray(row) && typeof row[0] === "string" && isNonNegative(row[1]?.frequency) && isNonNegative(row[1].lastUsedMs)).map(([id, { frequency, lastUsedMs }]) => [id, {
+		frequency,
+		lastUsed: lastUsedMs
+	}]));
+	if (records.size < rows.length) console.warn("[modern-cmdk] dropped invalid frecency rows:", rows.length - records.size);
+	return { records };
 }
-/** 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)])) };
+/**
+* Open `storeName` in `dbName` per operation, creating the store when missing.
+* idb-keyval 6.3.0's createStore does `request.onupgradeneeded = () =>
+* request.result.createObjectStore(storeName)`, which runs only when the database
+* is new, so a second storeName in an existing database fails with NotFoundError
+* (SEC-35). Here a database without the store is reopened at `version + 1`, whose
+* upgrade creates it. The connection closes right after the transaction starts (the
+* transaction still finishes), so it delays another instance's upgrade only until that
+* transaction is done. An upgrade blocked by a connection that is never closed (for example an
+* idb-keyval createStore connection held by app code, which has no versionchange handler)
+* waits for it, so that load or save does not settle until the connection closes.
+*/
+function openStore(dbName, storeName) {
+	const open = async (version) => {
+		const request = indexedDB.open(dbName, version);
+		request.onupgradeneeded = () => request.result.createObjectStore(storeName);
+		const db = await new Promise((resolve, reject) => {
+			request.onsuccess = () => resolve(request.result);
+			request.onerror = () => reject(request.error);
+		});
+		if (db.objectStoreNames.contains(storeName)) return db;
+		db.close();
+		return open(db.version + 1);
+	};
+	return async (mode, callback) => {
+		const db = await open();
+		const transaction = db.transaction(storeName, mode);
+		db.close();
+		return callback(transaction.objectStore(storeName));
+	};
 }
 /** Build the namespaced IDB key — ensures valid Unicode in key */
 function storageKey(namespace) {
@@ -44,7 +85,7 @@ function storageKey(namespace) {
 }
 let idbModule;
 /**
-* IndexedDB-backed frecency storage using idb-keyval.
+* IndexedDB-backed frecency storage using idb-keyval's get, set and del.
 *
 * Persists frecency data across browser sessions. Implements both
 * `Disposable` and `AsyncDisposable` for use with `using` and `await using`.
@@ -78,35 +119,30 @@ var IdbFrecencyStorage = class {
 		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);
-		}
+	/** Lazy-create the store opener on first access */
+	#getStore() {
+		this.#store ??= openStore(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);
+		const store = this.#getStore();
+		return deserializeData(await get(storageKey(namespace), store));
 	}
 	/** 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();
+		const store = 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();
+		const store = this.#getStore();
 		await del(storageKey(namespace), store);
 	}
 	/** Synchronous dispose — marks as disposed (best-effort cleanup) */
@@ -119,6 +155,12 @@ var IdbFrecencyStorage = class {
 	}
 };
 // src/core/types.ts
+/**
+* The `groupedIds` key of items that have no group. The value is an observable key of
+* `CommandState.groupedIds` and stays `'__ungrouped'`. A group registered under this id shares the
+* bucket: its items are listed with the ungrouped ones and the bucket takes its priority.
+*/
+const UNGROUPED_GROUP_ID = "__ungrouped";
 /** Create a branded {@link ItemId} from a plain string. Ensures well-formed Unicode. */
 function itemId(id) {
 	return ensureWellFormed(id);
@@ -135,7 +177,10 @@ const DEFAULT_FRECENCY_DECAY = {
 	monthWeight: 1,
 	olderWeight: .5
 };
-/** Default machine options */
+/**
+* Default machine options. The machine reads `loop` and `open` from here when its options leave them out
+* (the other options are opt-ins whose absence is their default); `virtualizeThreshold` is not read yet.
+*/
 const DEFAULT_MACHINE_OPTIONS = {
 	loop: true,
 	virtualizeThreshold: 100,
@@ -152,7 +197,7 @@ function createInitialState(options) {
 		loading: false,
 		page: "root",
 		pageStack: [],
-		open: options?.open ?? false,
+		open: options?.open ?? DEFAULT_MACHINE_OPTIONS.open ?? false,
 		lastUpdated: Date.now()
 	};
 }
@@ -181,13 +226,6 @@ var MemoryFrecencyStorage = class {
 // src/core/frecency/index.ts
 /** Shared empty bonus map — avoids allocation when no frecency records exist */
 const EMPTY_BONUS_MAP = /* @__PURE__ */ new Map();
-/** Bucket boundaries as hour constants — no per-call unit conversion */
-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 hour/day/week/month bucket boundaries with
@@ -196,32 +234,74 @@ const BUCKET_HOURS = {
 function computeFrecencyBonus(history, now = Date.now(), config = DEFAULT_FRECENCY_DECAY) {
 	const hours = (now - history.lastUsed) / 36e5;
 	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;
+	const recencyWeight = hours < 1 ? hourWeight : hours < 24 ? dayWeight : hours < 168 ? weekWeight : hours < 720 ? monthWeight : olderWeight;
 	return history.frequency * recencyWeight;
 }
+/** Trailing debounce in milliseconds between the last `recordSelection` and the save it schedules */
+const FLUSH_DELAY_MS = 1e3;
 /**
 * 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 Date.now() for timestamps.
+* ranking boosts for search results. Supports pluggable storage backends.
+* Dirty data is saved 1000 ms after the last `recordSelection`, when the page
+* becomes hidden or is hidden for good (`visibilitychange`, `pagehide`), on
+* `flush()` and on dispose; a save waits for a `load()` in flight, so it writes the merged
+* history. Dispose disposes the storage only when the engine created it (no `storage`
+* option): a storage the caller passes is the caller's to dispose. Uses Date.now() for
+* timestamps.
 */
 var FrecencyEngine = class {
 	#storage;
+	/** True when the engine created its storage, so dispose disposes it; a caller's storage is left alone */
+	#ownsStorage;
 	#namespace;
 	#data;
 	#config;
 	#dirty = false;
+	#timer;
+	/** The last started save, never rejecting: saves queue behind it and flush awaits it */
+	#pending = Promise.resolve();
+	/** The last started load, never rejecting: a save starts only after it settles */
+	#loading = Promise.resolve();
+	/** Set by a rejected load: the engine writes nothing afterwards */
+	#loadFailed = false;
+	#abort = new AbortController();
 	constructor(options) {
+		this.#ownsStorage = options.storage === void 0;
 		this.#storage = options.storage ?? new MemoryFrecencyStorage();
 		this.#namespace = options.namespace ?? "default";
 		this.#config = options.decayConfig ?? DEFAULT_FRECENCY_DECAY;
 		this.#data = { records: /* @__PURE__ */ new Map() };
+		const { signal } = this.#abort;
+		globalThis.addEventListener?.("pagehide", this.#save, { signal });
+		globalThis.document?.addEventListener("visibilitychange", () => document.hidden && this.#save(), { signal });
 	}
-	/** Load frecency data from storage */
-	async load() {
-		const data = await this.#storage.load(this.#namespace);
-		this.#data = data;
+	/**
+	* Merge the data in storage into the engine: frequencies add, `lastUsed` takes the later
+	* time, and selections recorded before the load resolves are kept. Call it once per
+	* engine; a second load would add the persisted frequencies again. A save started while
+	* the load is in flight waits for it, so the history it writes is the merged one, and a load
+	* that never settles holds every save, and `await using`, forever. A failed load rejects here
+	* and turns persistence off for this engine: saving would replace a history it could not read.
+	*/
+	load() {
+		const merged = this.#merge();
+		this.#loading = merged.catch(() => {
+			this.#loadFailed = true;
+		});
+		return merged;
+	}
+	async #merge() {
+		const { records } = await this.#storage.load(this.#namespace);
+		const mine = this.#data.records;
+		for (const [id, loaded] of records) {
+			const m = mine.get(id);
+			mine.set(id, m ? {
+				frequency: m.frequency + loaded.frequency,
+				lastUsed: Math.max(m.lastUsed, loaded.lastUsed)
+			} : loaded);
+		}
 	}
-	/** Record a selection event for an item */
+	/** Record a selection event for an item and schedule a save 1000 ms after the last one */
 	recordSelection(itemId) {
 		const now = Date.now();
 		const updated = {
@@ -230,6 +310,8 @@ var FrecencyEngine = class {
 		};
 		this.#data.records.set(itemId, updated);
 		this.#dirty = true;
+		clearTimeout(this.#timer);
+		if (!this.#abort.signal.aborted) this.#timer = setTimeout(this.#save, FLUSH_DELAY_MS);
 	}
 	/** Get frecency bonus for an item */
 	getBonus(itemId, now) {
@@ -255,30 +337,49 @@ var FrecencyEngine = class {
 			...config
 		};
 	}
-	/** Flush dirty data to storage */
+	/**
+	* Flush dirty data to storage and wait for every save in flight; saves run one after
+	* another, each after the load in flight (one that never settles holds them all), none after a
+	* rejected load, and a rejected save leaves the data dirty and rethrows to the flush that started it
+	*/
 	async flush() {
-		if (!this.#dirty) return;
-		await this.#storage.save(this.#namespace, this.#data);
+		clearTimeout(this.#timer);
+		const dirty = this.#dirty;
 		this.#dirty = false;
+		const save = Promise.all([this.#pending, this.#loading]).then(() => dirty && !this.#loadFailed && this.#storage.save(this.#namespace, this.#data));
+		this.#pending = save.catch(() => {});
+		try {
+			await save;
+		} catch (error) {
+			this.#dirty = true;
+			throw error;
+		}
 	}
+	/** Flush for the timer and the page listeners: a failure is reported, never thrown */
+	#save = () => this.flush().catch(this.#warn);
+	#warn = (error) => {
+		console.warn("[modern-cmdk] save failed:", error);
+	};
 	/** 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]();
+	/**
+	* Async dispose — flushes dirty data, then disposes the storage the engine created, even
+	* when the save rejects (the rejection propagates). Use with `await using`.
+	*/
+	[Symbol.asyncDispose]() {
+		this.#abort.abort();
+		return this.flush().finally(this.#disposeStorage);
 	}
+	/** Sync dispose — starts the flush without awaiting it and disposes the storage the engine created once it settles */
 	[Symbol.dispose]() {
-		if (this.#dirty) Promise.resolve().then(() => this.#storage.save(this.#namespace, this.#data)).catch((err) => {
-			console.warn("[modern-cmdk] FrecencyEngine dispose flush failed:", err);
-		});
-		this.#storage[Symbol.dispose]();
+		this.#abort.abort();
+		this.#save().finally(this.#disposeStorage).catch(this.#warn);
 	}
+	#disposeStorage = () => {
+		if (this.#ownsStorage) this.#storage[Symbol.dispose]();
+	};
 };
 // src/core/utils/group-by.ts
 /**
@@ -397,10 +498,13 @@ function formatShortcut(parsed) {
 /**
 * Manages keyboard shortcut bindings with global keydown listening.
 * Supports `using` for automatic cleanup of both individual bindings and the
-* global document listener. Detects conflicts with the local mapGroupBy helper (core/utils/group-by.ts).
+* global document listener. Every normalized shortcut keeps a stack of bindings, one per item: the later
+* binding wins the keydown, disposing it restores the earlier one, and `getConflicts()` reports the keys with
+* two or more bindings (through `detectConflicts`, which groups with the local mapGroupBy helper).
 */
 var KeyboardShortcutRegistry = class {
 	#bindings = /* @__PURE__ */ new Map();
+	#keysByItem = /* @__PURE__ */ new Map();
 	#globalListener = null;
 	#enabled = true;
 	constructor(options) {
@@ -410,45 +514,72 @@ var KeyboardShortcutRegistry = class {
 	/** Register a shortcut binding — returns Disposable for `using` auto-deregister */
 	register(shortcutStr, itemId, handler) {
 		const shortcut = parseShortcut(shortcutStr);
-		this.#bindings.set(shortcut.normalized, {
+		const binding = {
 			shortcut,
 			itemId,
 			handler
-		});
-		return { [Symbol.dispose]: () => {
-			this.#bindings.delete(shortcut.normalized);
-		} };
+		};
+		const stack = this.#bindings.get(shortcut.normalized) ?? [];
+		const own = stack.findIndex((b) => b.itemId === itemId);
+		if (own < 0) stack.push(binding);
+		else stack[own] = binding;
+		this.#bindings.set(shortcut.normalized, stack);
+		const keys = this.#keysByItem.get(itemId) ?? /* @__PURE__ */ new Set();
+		this.#keysByItem.set(itemId, keys.add(shortcut.normalized));
+		return { [Symbol.dispose]: () => this.#remove(shortcut.normalized, (b) => b === binding) };
+	}
+	/** Drops the bindings of one key that the predicate selects; an emptied key goes away */
+	#remove(key, drop) {
+		const stack = this.#bindings.get(key);
+		if (!stack) return;
+		const rest = stack.filter((b) => !drop(b));
+		if (rest.length) this.#bindings.set(key, rest);
+		else this.#bindings.delete(key);
+		for (const { itemId } of stack) {
+			if (rest.some((b) => b.itemId === itemId)) continue;
+			const keys = this.#keysByItem.get(itemId);
+			keys?.delete(key);
+			if (!keys?.size) this.#keysByItem.delete(itemId);
+		}
 	}
-	/** Unregister a shortcut by its string representation */
+	/** Unregister a shortcut by its string representation — every binding of that key */
 	unregister(shortcutStr) {
-		const shortcut = parseShortcut(shortcutStr);
-		this.#bindings.delete(shortcut.normalized);
+		this.#remove(parseShortcut(shortcutStr).normalized, () => true);
 	}
-	/** 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);
+	/**
+	* Unregister all shortcuts for a given item — only the stacks of the keys it is bound under are touched.
+	* `keep` names one shortcut whose binding stays (a re-bind then replaces it in place, see register).
+	*/
+	unregisterByItem(itemId, keep) {
+		const keys = this.#keysByItem.get(itemId);
+		if (!keys) return;
+		const kept = keep === void 0 ? void 0 : parseShortcut(keep).normalized;
+		for (const key of [...keys]) if (key !== kept) this.#remove(key, (b) => b.itemId === itemId);
 	}
-	/** Check for conflicting shortcuts */
+	/** Keys bound by two or more items (normalized shortcut -> the parsed shortcuts, earliest first) */
 	getConflicts() {
-		return detectConflicts(this.#bindings.values().map((b) => b.shortcut).toArray());
+		return detectConflicts(this.#bindings.values().flatMap((stack) => stack.map((b) => b.shortcut)).toArray());
 	}
 	/** Enable or disable global shortcut listening */
 	setEnabled(enabled) {
 		this.#enabled = enabled;
 	}
-	/** Get all registered bindings */
+	/** The winning binding of every key (a snapshot: the later of the bindings that share a key) */
 	getBindings() {
-		return this.#bindings;
+		return new Map(this.#bindings.entries().map(([key, stack]) => [key, stack.at(-1)]));
 	}
 	#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;
+			for (const stack of this.#bindings.values()) {
+				const binding = stack.at(-1);
+				if (matchesShortcut(event, binding.shortcut)) {
+					event.preventDefault();
+					event.stopPropagation();
+					binding.handler();
+					return;
+				}
 			}
 		};
 		document.addEventListener("keydown", this.#globalListener);
@@ -462,6 +593,7 @@ var KeyboardShortcutRegistry = class {
 	[Symbol.dispose]() {
 		this.#detachGlobalListener();
 		this.#bindings.clear();
+		this.#keysByItem.clear();
 	}
 };
 // src/core/utils/set-ops.ts
@@ -516,7 +648,6 @@ function setSymmetricDifference(a, b) {
 var CommandRegistry = class {
 	#items = /* @__PURE__ */ new Map();
 	#groups = /* @__PURE__ */ new Map();
-	#itemOrder = [];
 	#itemOrderSet = /* @__PURE__ */ new Set();
 	#cachedItems = null;
 	#cachedGroups = null;
@@ -528,45 +659,32 @@ var CommandRegistry = class {
 	}
 	/** 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);
-		} };
+		return this.registerItems([item]);
 	}
 	/** Register multiple items at once — single Disposable for batch cleanup. for...of for hot path. */
 	registerItems(items) {
-		for (const item of items) {
+		const owned = [...items];
+		for (const item of owned) {
 			this.#items.set(item.id, item);
-			if (!this.#itemOrderSet.has(item.id)) {
-				this.#itemOrder.push(item.id);
-				this.#itemOrderSet.add(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);
+			for (const item of owned) if (this.#items.get(item.id) === item) this.unregisterItem(item.id);
 		} };
 	}
-	/** Unregister a single item — O(1) Map/Set delete, indexOf+toSpliced for order */
+	/** Unregister a single item — O(1) Map/Set delete */
 	unregisterItem(id) {
-		if (!this.#items.has(id)) return;
-		this.#items.delete(id);
+		if (!this.#items.delete(id)) return;
 		this.#itemOrderSet.delete(id);
-		const idx = this.#itemOrder.indexOf(id);
-		if (idx !== -1) this.#itemOrder = this.#itemOrder.toSpliced(idx, 1);
 		this.#invalidateCache();
 	}
 	/** Bulk unregister — for...of for hot path */
 	unregisterItems(ids) {
-		for (const id of ids) this.#items.delete(id);
-		this.#itemOrderSet = setDifference(this.#itemOrderSet, ids);
-		this.#itemOrder = this.#itemOrder.filter((id) => !ids.has(id));
+		for (const id of ids) {
+			this.#items.delete(id);
+			this.#itemOrderSet.delete(id);
+		}
 		this.#invalidateCache();
 	}
 	/** Register a group */
@@ -574,8 +692,7 @@ var CommandRegistry = class {
 		this.#groups.set(group.id, group);
 		this.#invalidateGroupCache();
 		return { [Symbol.dispose]: () => {
-			this.#groups.delete(group.id);
-			this.#invalidateGroupCache();
+			if (this.#groups.get(group.id) === group) this.unregisterGroup(group.id);
 		} };
 	}
 	/** Unregister a group */
@@ -594,7 +711,7 @@ var CommandRegistry = class {
 	/** 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();
+		this.#cachedItems = this.#items.values().toArray();
 		return this.#cachedItems;
 	}
 	/** Get all registered groups sorted by priority — cached between group mutations */
@@ -611,8 +728,8 @@ var CommandRegistry = class {
 			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);
+		const ungrouped = grouped.get(UNGROUPED_GROUP_ID);
+		if (ungrouped) result.set(UNGROUPED_GROUP_ID, ungrouped);
 		return result;
 	}
 	/** Get item IDs as a Set — returns internal set (O(1), no allocation) */
@@ -659,7 +776,6 @@ var CommandRegistry = class {
 	clear() {
 		this.#items.clear();
 		this.#groups.clear();
-		this.#itemOrder = [];
 		this.#itemOrderSet.clear();
 		this.#invalidateCache();
 		this.#invalidateGroupCache();
@@ -693,6 +809,11 @@ function isWordSeparator(code) {
 * 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.
+*
+* `matches` are half-open ranges into `item.value` itself (UTF-16 indices of the original
+* string, even where lowercasing changes its length, as 'İ' → 'i̇' does). A keyword has no
+* position in the label: when a keyword outscores the value, `matches` keeps the value's own
+* ranges if the value matched and is `[]` otherwise.
 */
 function scoreItem(query, item) {
 	if (query === "") return {
@@ -700,45 +821,21 @@ function scoreItem(query, item) {
 		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;
+	return scoreItemPreLowered(query.toLowerCase(), item.id, item.value, item.value.toLowerCase(), item.keywords?.map((keyword) => keyword.toLowerCase()));
 }
 /**
 * Internal fast path: called by search engine with pre-lowered query and targets.
-* Eliminates all toLowerCase() calls on the hot path.
+* Eliminates the toLowerCase() calls on the hot path, except per character in toOriginalRanges
+* when lowering changes the length of the value. `value` is the original text, which the
+* ranges index (see {@link scoreItem}).
 */
-function scoreItemPreLowered(lowerQuery, id, lowerValue, lowerKeywords) {
+function scoreItemPreLowered(lowerQuery, id, value, lowerValue, lowerKeywords) {
 	let bestScore = 0;
 	let bestMatches = null;
 	const valueResult = scoreTarget(lowerQuery, lowerValue);
 	if (valueResult !== null) {
 		bestScore = valueResult.score;
-		bestMatches = valueResult.matches;
+		bestMatches = toOriginalRanges(value, lowerValue, valueResult.matches);
 		if (bestScore >= 1) return {
 			id,
 			score: 1,
@@ -749,7 +846,7 @@ function scoreItemPreLowered(lowerQuery, id, lowerValue, lowerKeywords) {
 		const result = scoreTarget(lowerQuery, lowerKeywords[i]);
 		if (result !== null && result.score > bestScore) {
 			bestScore = result.score;
-			bestMatches = result.matches;
+			bestMatches ??= [];
 			if (bestScore >= 1) break;
 		}
 	}
@@ -759,6 +856,28 @@ function scoreItemPreLowered(lowerQuery, id, lowerValue, lowerKeywords) {
 		matches: bestMatches
 	} : null;
 }
+/**
+* Maps ranges found in `lowerValue` back onto `value`. Under toLowerCase() only U+0130
+* ('İ' → 'i' + U+0307) changes the UTF-16 length of any code point, which shifts every later
+* index, so when the lengths differ each lowered unit is traced to the character it came from:
+* a range starts at the start of the character holding its first unit and ends at the end of
+* the character holding its last.
+* Equal lengths (the common case; the final sigma lowers to 'ς' or 'σ', both one unit) need no map.
+*/
+function toOriginalRanges(value, lowerValue, ranges) {
+	if (value.length === lowerValue.length) return ranges;
+	const locate = (unit, after) => {
+		let from = 0;
+		let lowered = 0;
+		for (const char of value) {
+			lowered += char.toLowerCase().length;
+			if (lowered > unit) return from + after * char.length;
+			from += char.length;
+		}
+		return from;
+	};
+	return ranges.map(([start, end]) => [locate(start, 0), locate(end - 1, 1)]);
+}
 function scoreTarget(query, lowerTarget) {
 	const tLen = lowerTarget.length;
 	if (tLen === 0) return null;
@@ -790,28 +909,41 @@ function scoreTarget(query, lowerTarget) {
 	return scoreFuzzy(query, qLen, lowerTarget, tLen);
 }
 function scoreWordBoundary(query, qLen, lowerTarget, tLen) {
-	let queryIdx = 0;
+	if (qLen > 512) return null;
 	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;
+	failedFrom = void 0;
+	squares = 0;
+	if (!coverQuery(query, 0, lowerTarget, 0, matches)) return null;
 	return {
-		score: .3 + .4 * (totalWeightedLen / maxPossible),
+		score: .65 + .03 * (squares / (qLen * qLen)) + .02 * (qLen / tLen),
 		matches
 	};
 }
+let failedFrom;
+let squares = 0;
+/**
+* Covers query[queryIdx..] with segments that each start at a word start at or after `from`,
+* stay inside one word and match contiguously. Each word start tries its longest run first, then
+* shorter ones, so the first cover found is the one a greedy scan finds whenever that succeeds.
+* Prepends the segments of the cover to `matches`, in order; charCode scan, no regex, no split.
+*/
+function coverQuery(query, queryIdx, lowerTarget, from, matches) {
+	const end = failedFrom?.[queryIdx] ?? lowerTarget.length;
+	for (let i = from; i < end; i++) if ((i === 0 || isWordSeparator(lowerTarget.charCodeAt(i - 1))) && lowerTarget.charCodeAt(i) === query.charCodeAt(queryIdx)) {
+		let run = 0;
+		while (!isWordSeparator(lowerTarget.charCodeAt(i + run)) && lowerTarget.charCodeAt(i + run) === query.charCodeAt(queryIdx + run)) run++;
+		for (; run > 0; run--) if (queryIdx + run === query.length || coverQuery(query, queryIdx + run, lowerTarget, i + run, matches)) {
+			matches.unshift([i, i + run]);
+			squares += run * run;
+			return true;
+		}
+	}
+	if (queryIdx > 0 && from < end) {
+		failedFrom ??= [];
+		failedFrom[queryIdx] = from;
+	}
+	return false;
+}
 function scoreFuzzy(query, qLen, lowerTarget, tLen) {
 	let queryIdx = 0;
 	let targetIdx = 0;
@@ -852,9 +984,10 @@ if (isDev && typeof window !== "undefined") leakRegistry = new FinalizationRegis
 	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.
+* Creates a search engine with pluggable scorer.
+* With the default scorer, a query that extends the previous one (compared lowercased) re-scores
+* only the prior matches; a custom scorer is called for every item on every non-empty query.
+* Pre-caches lowercase at index time; indexed items are not re-lowered during search.
 * Uses Iterator Helpers (ES2025) for result pipelines.
 */
 function createSearchEngine(options) {
@@ -886,11 +1019,11 @@ function createSearchEngine(options) {
 				}));
 			}
 			const lowerQuery = query.toLowerCase();
-			const candidateItems = query.startsWith(previousQuery) && previousQuery.length > 0 ? items.values().filter((item) => previousResults.has(item.id)) : items;
+			const candidateItems = useDefaultScorer && previousQuery.length > 0 && lowerQuery.startsWith(previousQuery) ? 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()));
+				const result = entry ? scoreItemPreLowered(lowerQuery, item.id, item.value, entry.lowerValue, entry.lowerKeywords) : scoreItemPreLowered(lowerQuery, item.id, item.value, item.value.toLowerCase(), item.keywords?.map((k) => k.toLowerCase()));
 				if (result !== null) results.push(result);
 			}
 			else for (const item of candidateItems) {
@@ -898,13 +1031,15 @@ function createSearchEngine(options) {
 				if (result != null) results.push(result);
 			}
 			results.sort((a, b) => b.score - a.score);
-			previousQuery = query;
+			previousQuery = lowerQuery;
 			previousResults = new Set(results.values().map((r) => r.id));
 			return results.values();
 		},
 		remove(ids) {
-			for (const id of ids) indexedEntries.delete(id);
-			previousResults = setDifference(previousResults, ids);
+			for (const id of ids) {
+				indexedEntries.delete(id);
+				previousResults.delete(id);
+			}
 		},
 		clear() {
 			indexedEntries.clear();
@@ -921,6 +1056,7 @@ function createSearchEngine(options) {
 // src/core/utils/event-emitter.ts
 /**
 * Type-safe event emitter with strong references and Disposable subscriptions.
+* `T` maps event names to payload types; an interface or a type alias both work (`object`, not an index signature, which an interface lacks).
 * Returns Disposable from `on()` for automatic unsubscription via `using`.
 */
 var TypedEmitter = class {
@@ -938,11 +1074,20 @@ var TypedEmitter = class {
 			set.delete(fn);
 		} };
 	}
-	/** Emit an event to all listeners. Snapshots the set to prevent live-iteration issues. */
+	/**
+	* Emit an event to all listeners. Snapshots the set to prevent live-iteration issues.
+	* A throwing listener does not stop the later ones: its error is rethrown from a microtask, as the scheduler does.
+	*/
 	emit(event, data) {
 		const set = this.#listeners.get(event);
 		if (!set || set.size === 0) return;
-		for (const fn of [...set]) fn(data);
+		for (const fn of [...set]) try {
+			fn(data);
+		} catch (error) {
+			queueMicrotask(() => {
+				throw error;
+			});
+		}
 	}
 	/** Check if any listeners exist for an event */
 	has(event) {
@@ -964,13 +1109,9 @@ var TypedEmitter = class {
 // 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, read through globalThis: typeof guards only a bare
-* identifier, so `typeof navigator?.scheduling` would throw where navigator is undeclared (runtimes without one). */
-const canYield = typeof globalThis.scheduler?.yield === "function";
-const hasInputPending = typeof globalThis.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).
+* execution pass using rAF (browser) or queueMicrotask (where rAF is absent: Node.js, SSR).
 */
 function createScheduler() {
 	let pending = [];
@@ -981,12 +1122,6 @@ function createScheduler() {
 		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) {
@@ -1026,52 +1161,82 @@ function createScheduler() {
 // src/core/machine.ts
 /**
 * Creates a headless command palette state machine with search, frecency,
-* and keyboard shortcut support. Implements Disposable for `using` cleanup.
+* and keyboard shortcut support. Implements Disposable and AsyncDisposable for
+* `using` and `await using` cleanup (the latter awaits the pending frecency save).
 *
 * @example
 * ```ts
-* using machine = createCommandMachine({ items, loop: true });
-* machine.subscribe(() => console.log(machine.getState()));
+* const machine = createCommandMachine({ items, loop: true });
+* const unsubscribe = machine.subscribe(() => console.log(machine.getState()));
+* machine.send({ type: 'SEARCH_CHANGE', query: 'app' }); // handled in the next frame
+*
+* // on teardown
+* unsubscribe();
+* machine[Symbol.dispose]();
 * ```
 */
 function createCommandMachine(options = {}) {
 	let state = createInitialState(options);
 	let filteredIdSet = /* @__PURE__ */ new Set();
 	let filteredIdIndex = /* @__PURE__ */ new Map();
+	let navIds = [];
 	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 {
+		return score && score > 0 ? {
 			id: item.id,
 			score,
 			matches: []
-		};
+		} : null;
 	} } : void 0);
 	const scheduler = createScheduler();
 	const emitter = new TypedEmitter();
 	const keyboardRegistry = new KeyboardShortcutRegistry();
+	const pendingSources = /* @__PURE__ */ new Set();
 	let frecencyEngine = null;
 	if (options.frecency?.enabled) {
 		frecencyEngine = new FrecencyEngine(options.frecency);
-		frecencyEngine.load();
+		frecencyEngine.load().then(() => {
+			if (disposed || state.search === "" || options.filter === false) return;
+			dirty = true;
+			if (queued === 0) commit();
+		}, (error) => {
+			console.warn("[modern-cmdk] frecency load failed:", error);
+		});
 	}
+	let queued = 0;
+	let nextQueued = 0;
+	let inHandler = false;
+	let dirty = false;
+	let changed = false;
+	let disposed = false;
 	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);
+		for (const item of options.items) bind(item);
 	}
 	if (options.groups) for (const group of options.groups) registry.registerGroup(group);
 	refilter("");
-	function setState(newState) {
-		state = newState;
-		emitter.emit("stateChange", state);
+	changed = false;
+	function setState(patch) {
+		state = {
+			...state,
+			...patch,
+			lastUpdated: Date.now()
+		};
+		changed = true;
+	}
+	function setOpen(open) {
+		setState({ open });
+		emitter.emit("openChange", open);
+		options.onOpenChange?.(open);
 	}
 	function refilter(query) {
+		dirty = false;
 		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();
+		if (disableFilter || query === "") filteredIds = items.map((i) => i.id);
 		else {
 			let results = searchEngine.search(query, items).toArray();
 			if (frecencyEngine) {
@@ -1084,68 +1249,76 @@ function createCommandMachine(options = {}) {
 			}
 			filteredIds = results.map((r) => r.id);
 		}
+		if (options.disabledItems === "hide") filteredIds = filteredIds.filter(isEnabled);
 		filteredIdSet = new Set(filteredIds);
 		filteredIdIndex = new Map(filteredIds.entries().map(([i, id]) => [id, i]));
-		const groupedIds = mapGroupBy(filteredIds, (id) => {
-			return registry.getItem(id)?.groupId ?? "__ungrouped";
-		});
-		const activeId = state.activeId && filteredIdSet.has(state.activeId) ? state.activeId : filteredIds[0] ?? null;
+		const priority = (g) => registry.getGroup(g)?.priority ?? 0;
+		const groupedIds = new Map([...mapGroupBy(filteredIds, (id) => registry.getItem(id)?.groupId ?? "__ungrouped")].sort((x, y) => priority(x[0]) - priority(y[0])));
+		navIds = filteredIds.filter(isEnabled);
+		const activeId = state.activeId && filteredIdSet.has(state.activeId) && isEnabled(state.activeId) ? state.activeId : navIds[0] ?? null;
 		setState({
-			...state,
 			search: query,
 			filteredIds,
 			groupedIds,
 			filteredCount: filteredIds.length,
-			activeId,
-			lastUpdated: Date.now()
+			activeId
 		});
 	}
+	function isEnabled(id) {
+		return !registry.getItem(id)?.disabled;
+	}
+	/**
+	* (Re)binds an item's keyboard shortcut — the one place that does it, for initial items, ITEMS_LOADED,
+	* REGISTER_ITEM and UPDATE_ITEM. The item's bindings on other keys go first; one on the same key is replaced in place, so
+	* it keeps its place in that key's stack (CE-108). A disabled item is not bound at all (its key
+	* stays free for the page and for other items on it); UPDATE_ITEM re-binds, so enabling an item binds it. Under
+	* 'select' the binding dispatches ITEM_SELECT, whose guard checks the item; under 'direct' it only binds an item
+	* with an onSelect and checks the registry entry again before calling it.
+	*/
+	function bind({ id, shortcut, disabled, onSelect }) {
+		const select = options.shortcutAction === "select";
+		const bound = shortcut && !disabled && (select || onSelect) ? shortcut : void 0;
+		keyboardRegistry.unregisterByItem(id, bound);
+		if (!bound) return;
+		const handler = () => {
+			if (select) machine.send({
+				type: "ITEM_SELECT",
+				id
+			});
+			else if (isEnabled(id)) onSelect?.();
+		};
+		keyboardRegistry.register(bound, id, handler);
+	}
 	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: Date.now()
-				});
-				options.onActiveChange?.(newActiveId);
-			}
-			return;
-		}
-		if (direction === "last") {
-			const newActiveId = filteredIds[filteredIds.length - 1] ?? null;
-			if (newActiveId !== activeId) {
-				setState({
-					...state,
-					activeId: newActiveId,
-					lastUpdated: Date.now()
-				});
-				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;
+		const { activeId } = state;
+		const last = navIds.length - 1;
+		if (last < 0) return;
+		const loop = options.loop ?? DEFAULT_MACHINE_OPTIONS.loop;
+		const current = activeId ? navIds.indexOf(activeId) : -1;
+		let index;
+		if (direction === "first") index = 0;
+		else if (direction === "last") index = last;
+		else if (direction === "next") index = current < 0 || current >= last ? loop ? 0 : last : current + 1;
+		else index = current <= 0 ? loop ? last : 0 : current - 1;
+		const newActiveId = navIds[index] ?? null;
 		if (newActiveId !== activeId) {
-			setState({
-				...state,
-				activeId: newActiveId,
-				lastUpdated: Date.now()
-			});
+			setState({ activeId: newActiveId });
 			options.onActiveChange?.(newActiveId);
 		}
 	}
+	/** Ends a batch: one refilter if a registry event ran, then one stateChange even if the refilter throws. */
+	function commit() {
+		try {
+			if (dirty) refilter(state.search);
+		} finally {
+			if (changed) {
+				changed = false;
+				emitter.emit("stateChange", state);
+			}
+		}
+	}
 	function handleEvent(event) {
+		if (dirty && (event.type === "NAVIGATE" || event.type === "ITEM_ACTIVATE")) refilter(state.search);
 		switch (event.type) {
 			case "SEARCH_CHANGE":
 				refilter(event.query);
@@ -1162,12 +1335,8 @@ function createCommandMachine(options = {}) {
 				break;
 			}
 			case "ITEM_ACTIVATE":
-				if (filteredIdSet.has(event.id)) {
-					setState({
-						...state,
-						activeId: event.id,
-						lastUpdated: Date.now()
-					});
+				if (filteredIdSet.has(event.id) && isEnabled(event.id)) {
+					setState({ activeId: event.id });
 					options.onActiveChange?.(event.id);
 				}
 				break;
@@ -1176,87 +1345,81 @@ function createCommandMachine(options = {}) {
 				break;
 			case "PAGE_PUSH":
 				setState({
-					...state,
 					page: event.page,
-					pageStack: [...state.pageStack, state.page],
-					lastUpdated: Date.now()
+					pageStack: [...state.pageStack, state.page]
 				});
 				break;
 			case "PAGE_POP": {
 				const prevPage = state.pageStack.at(-1);
 				if (prevPage != null) setState({
-					...state,
 					page: prevPage,
-					pageStack: state.pageStack.toSpliced(-1, 1),
-					lastUpdated: Date.now()
+					pageStack: state.pageStack.toSpliced(-1, 1)
 				});
 				break;
 			}
 			case "OPEN":
-				setState({
-					...state,
-					open: true,
-					lastUpdated: Date.now()
-				});
-				emitter.emit("openChange", true);
-				options.onOpenChange?.(true);
+				setOpen(true);
 				break;
 			case "CLOSE":
-				setState({
-					...state,
-					open: false,
-					lastUpdated: Date.now()
-				});
-				emitter.emit("openChange", false);
-				options.onOpenChange?.(false);
+				setOpen(false);
 				break;
-			case "TOGGLE": {
-				const newOpen = !state.open;
-				setState({
-					...state,
-					open: newOpen,
-					lastUpdated: Date.now()
-				});
-				emitter.emit("openChange", newOpen);
-				options.onOpenChange?.(newOpen);
+			case "TOGGLE":
+				setOpen(!state.open);
 				break;
-			}
 			case "ITEMS_LOADED":
 				registry.registerItems(event.items);
 				searchEngine.index(event.items);
-				state = {
-					...state,
-					loading: false
-				};
-				refilter(state.search);
+				for (const item of event.items) bind(item);
+				dirty = true;
+				break;
+			case "LOADING": {
+				if (event.pending) pendingSources.add(event.source);
+				else pendingSources.delete(event.source);
+				const loading = pendingSources.size > 0;
+				if (loading !== state.loading) setState({ loading });
 				break;
+			}
 			case "REGISTER_ITEM":
+			case "UPDATE_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);
+				bind(event.item);
+				dirty = true;
 				break;
 			case "UNREGISTER_ITEM":
 				registry.unregisterItem(event.id);
 				searchEngine.remove(/* @__PURE__ */ new Set([event.id]));
 				keyboardRegistry.unregisterByItem(event.id);
-				refilter(state.search);
+				dirty = true;
 				break;
 			case "REGISTER_GROUP":
 				registry.registerGroup(event.group);
-				refilter(state.search);
+				dirty = true;
 				break;
 			case "UNREGISTER_GROUP":
 				registry.unregisterGroup(event.id);
-				refilter(state.search);
+				dirty = true;
 		}
 	}
-	return {
+	const machine = {
 		getState() {
 			return state;
 		},
 		send(event) {
-			scheduler.schedule(() => handleEvent(event));
+			queued++;
+			if (inHandler) nextQueued++;
+			scheduler.schedule(() => {
+				inHandler = true;
+				try {
+					handleEvent(event);
+				} finally {
+					inHandler = false;
+					if (--queued === nextQueued) {
+						nextQueued = 0;
+						commit();
+					}
+				}
+			});
 		},
 		/** useSyncExternalStore-compatible subscribe — returns cleanup function */
 		subscribe(listener) {
@@ -1280,14 +1443,25 @@ function createCommandMachine(options = {}) {
 			return filteredIdIndex;
 		},
 		[Symbol.dispose]() {
+			disposed = true;
+			queued = nextQueued = 0;
 			scheduler[Symbol.dispose]();
 			registry[Symbol.dispose]();
 			searchEngine[Symbol.dispose]();
 			emitter[Symbol.dispose]();
 			keyboardRegistry[Symbol.dispose]();
 			frecencyEngine?.[Symbol.dispose]();
+		},
+		/** Awaits the pending frecency save, then disposes like [Symbol.dispose] — for `await using` */
+		async [Symbol.asyncDispose]() {
+			try {
+				await frecencyEngine?.flush();
+			} finally {
+				machine[Symbol.dispose]();
+			}
 		}
 	};
+	return machine;
 }
 // src/core/search/fuzzy-scorer.ts
 /**
@@ -1346,4 +1520,4 @@ function createTelemetryMiddleware(hooks) {
 		}
 	};
 }
-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 };
+export { CommandRegistry, DEFAULT_FRECENCY_DECAY, DEFAULT_MACHINE_OPTIONS, FrecencyEngine, IdbFrecencyStorage, KeyboardShortcutRegistry, MemoryFrecencyStorage, TypedEmitter, UNGROUPED_GROUP_ID, batchScoreItems, computeFrecencyBonus, createCommandMachine, createInitialState, createScheduler, createSearchEngine, createTelemetryMiddleware, detectConflicts, findMatchingShortcut, formatShortcut, groupId, itemId, matchesShortcut, parseShortcut, scoreItem, scoreItemAsync };