modern-cmdk 1.3.0 → 1.5.0

package/dist/react/index.mjs

@@ -1,8 +1,9 @@
 'use client';
+import { a as CommandGroupContext, c as CommandStateContext, i as useCommand, l as useStableContext, n as useCommandSetup, o as CommandListStatusContext, r as createKeydownHandler, s as CommandStableContext, t as CommandDialog, u as useStateContext } from "./chunk-dialog.mjs";
 import * as React from "react";
-import { Component, Suspense, createContext, use, useCallback, useEffect, useId, useLayoutEffect, useMemo, useOptimistic, useRef, useState, useSyncExternalStore, useTransition } from "react";
+import { Component, Suspense, use, useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { Dialog } from "radix-ui";
+import { createCommandMachine, formatShortcut, groupId, itemId, parseShortcut } from "modern-cmdk";
 import { createPortal } from "react-dom";
 // src/react/activity.tsx
 const ActivityComponent = "Activity" in React ? React.Activity : null;
@@ -19,28 +20,6 @@ function CommandActivity({ mode, children }) {
 	if (mode === "hidden") return null;
 	return /* @__PURE__ */ jsx(Fragment, { children });
 }
-// src/react/context.ts
-const CommandStableContext = createContext(null);
-CommandStableContext.displayName = "CommandStableContext";
-const CommandStateContext = createContext(null);
-CommandStateContext.displayName = "CommandStateContext";
-/** Consume stable context with a descriptive error — replaces 3-line boilerplate in every component */
-function useStableContext(component) {
-	const ctx = use(CommandStableContext);
-	if (!ctx) throw new Error(`${component} must be used within a <Command> component`);
-	return ctx;
-}
-/** Consume state context with a descriptive error — replaces 3-line boilerplate in every component */
-function useStateContext(component) {
-	const ctx = use(CommandStateContext);
-	if (!ctx) throw new Error(`${component} must be used within a <Command> component`);
-	return ctx;
-}
-const CommandGroupContext = createContext(null);
-CommandGroupContext.displayName = "CommandGroupContext";
-/** Context for the status container rendered outside the listbox — used by Command.Empty */
-const CommandListStatusContext = createContext(null);
-CommandListStatusContext.displayName = "CommandListStatusContext";
 // src/react/async-items.tsx
 /** Inner component that suspends via use() until items resolve */
 function AsyncItemsInner({ items: itemsPromise, children }) {
@@ -54,14 +33,42 @@ function AsyncItemsInner({ items: itemsPromise, children }) {
 	}, [stable.machine, items]);
 	return /* @__PURE__ */ jsx(Fragment, { children: children(items) });
 }
-/** Suspense-based async item loader that resolves a promise of items using React 19 `use()`. */
+/**
+* Rendered next to the Suspense fallback: while it is mounted its source counts as pending,
+* so `state.loading` (Command.Loading, the list's aria-busy) follows the suspended promise.
+* The fallback unmounts when the items resolve, reject into an error boundary, or this
+* AsyncItems unmounts, and the cleanup then clears the source.
+*/
+function PendingSignal() {
+	const stable = useStableContext("Command.AsyncItems");
+	const source = useId();
+	useLayoutEffect(() => {
+		stable.machine.send({
+			type: "LOADING",
+			source,
+			pending: true
+		});
+		return () => {
+			stable.machine.send({
+				type: "LOADING",
+				source,
+				pending: false
+			});
+		};
+	}, [stable.machine, source]);
+	return null;
+}
+/**
+* Suspense-based async item loader that resolves a promise of items using React 19 `use()`.
+*
+* The `items` promise must be kept stable across renders (held in state, a ref, or `useMemo`):
+* a new promise on every render, such as `items={fetchItems()}`, suspends again on every render.
+*/
 function CommandAsyncItems({ items, fallback, children }) {
-	const stableRef = useRef(items);
-	if (stableRef.current !== items) stableRef.current = items;
 	return /* @__PURE__ */ jsx(Suspense, {
-		fallback,
+		fallback: /* @__PURE__ */ jsxs(Fragment, { children: [fallback, /* @__PURE__ */ jsx(PendingSignal, {})] }),
 		children: /* @__PURE__ */ jsx(AsyncItemsInner, {
-			items: stableRef.current,
+			items,
 			children
 		})
 	});
@@ -76,1353 +83,6 @@ function CommandBadge({ ref, children, ...props }) {
 		children
 	});
 }
-// src/core/utils/string-wellformed.ts
-/**
-* Regex matching lone surrogates (unpaired high or low surrogates).
-* A lone high surrogate (U+D800–U+DBFF) not followed by a low surrogate,
-* or a lone low surrogate (U+DC00–U+DFFF) not preceded by a high surrogate.
-*/
-const LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
-/** Unicode replacement character used to replace lone surrogates. */
-const REPLACEMENT_CHAR = "�";
-/**
-* Ensures a string is well-formed Unicode by replacing lone surrogates
-* with the Unicode replacement character (U+FFFD).
-* Cross-browser replacement for `str.isWellFormed() ? str : str.toWellFormed()`.
-*/
-function ensureWellFormed(str) {
-	return str.replace(LONE_SURROGATE_RE, REPLACEMENT_CHAR);
-}
-// src/core/types.ts
-/** Create a branded {@link ItemId} from a plain string. Ensures well-formed Unicode. */
-function itemId(id) {
-	return ensureWellFormed(id);
-}
-/** Create a branded {@link GroupId} from a plain string. Ensures well-formed Unicode. */
-function groupId(id) {
-	return ensureWellFormed(id);
-}
-/** Default frecency decay configuration */
-const DEFAULT_FRECENCY_DECAY = {
-	hourWeight: 4,
-	dayWeight: 2,
-	weekWeight: 1.5,
-	monthWeight: 1,
-	olderWeight: .5
-};
-/** 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: Date.now()
-	};
-}
-// 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 (ES2025) */
-	toJSON() {
-		return Object.fromEntries(this.#store.entries().map(([namespace, data]) => [namespace, { records: data.records.entries().toArray() }]));
-	}
-	[Symbol.dispose]() {
-		this.#store.clear();
-	}
-};
-// 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
-* configurable step weights per recency bucket (hour/day/week/month/older).
-*/
-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;
-	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 Date.now() 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() {
-		const data = await this.#storage.load(this.#namespace);
-		this.#data = data;
-	}
-	/** Record a selection event for an item */
-	recordSelection(itemId) {
-		const now = Date.now();
-		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 = Date.now()) {
-		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.resolve().then(() => this.#storage.save(this.#namespace, this.#data)).catch((err) => {
-			console.warn("[modern-cmdk] FrecencyEngine dispose flush failed:", err);
-		});
-		this.#storage[Symbol.dispose]();
-	}
-};
-// src/core/utils/group-by.ts
-/**
-* Groups items from an iterable into a Map keyed by the result of `keyFn`.
-* Cross-browser replacement for `Map.groupBy()`.
-*/
-function mapGroupBy(items, keyFn) {
-	const map = /* @__PURE__ */ new Map();
-	for (const item of items) {
-		const key = keyFn(item);
-		const group = map.get(key);
-		if (group) group.push(item);
-		else map.set(key, [item]);
-	}
-	return map;
-}
-// 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;
-}
-/**
-* Detects conflicting shortcut bindings by grouping on their normalized form
-* via mapGroupBy helper. Returns only groups with two or more colliding shortcuts.
-* mapGroupBy returns a Map directly — no Object.entries conversion needed.
-*/
-function detectConflicts(shortcuts) {
-	const grouped = mapGroupBy(shortcuts, (s) => s.normalized);
-	return new Map(grouped.entries().filter(([, group]) => group.length > 1));
-}
-// 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.
-* Ensures valid Unicode input via ensureWellFormed helper.
-*/
-function parseShortcut(shortcut) {
-	const safeShortcut = ensureWellFormed(shortcut);
-	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;
-		}
-		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("+");
-}
-// 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 with the local mapGroupBy helper (core/utils/group-by.ts).
-*/
-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();
-	}
-};
-// src/core/utils/set-ops.ts
-/** Returns a new Set containing elements present in both `a` and `b`. */
-function setIntersection(a, b) {
-	const result = /* @__PURE__ */ new Set();
-	const [smaller, larger] = a.size <= b.size ? [a, b] : [b, a];
-	for (const item of smaller) if (larger.has(item)) result.add(item);
-	return result;
-}
-/** Returns a new Set containing elements in `a` but not in `b`. */
-function setDifference(a, b) {
-	const result = /* @__PURE__ */ new Set();
-	for (const item of a) if (!b.has(item)) result.add(item);
-	return result;
-}
-/** Returns a new Set containing all elements from both `a` and `b`. */
-function setUnion(a, b) {
-	const result = new Set(a);
-	for (const item of b) result.add(item);
-	return result;
-}
-/** Returns `true` if every element in `a` is also in `b`. */
-function setIsSubsetOf(a, b) {
-	if (a.size > b.size) return false;
-	for (const item of a) if (!b.has(item)) return false;
-	return true;
-}
-/** Returns `true` if every element in `b` is also in `a`. */
-function setIsSupersetOf(a, b) {
-	return setIsSubsetOf(b, a);
-}
-/** Returns `true` if `a` and `b` share no elements. */
-function setIsDisjointFrom(a, b) {
-	const [smaller, larger] = a.size <= b.size ? [a, b] : [b, a];
-	for (const item of smaller) if (larger.has(item)) return false;
-	return true;
-}
-/** Returns a new Set containing elements in either `a` or `b` but not both. */
-function setSymmetricDifference(a, b) {
-	const result = new Set(a);
-	for (const item of b) if (result.has(item)) result.delete(item);
-	else result.add(item);
-	return result;
-}
-// src/core/registry.ts
-/**
-* Manages registration and lookup of command items and groups.
-* Uses set operation helpers (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 — 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));
-		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 — direct Map, no Object.entries conversion */
-	getGroupedItems() {
-		const grouped = mapGroupBy(this.getItems(), (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 */
-	intersectWith(candidateIds) {
-		return setIntersection(this.#itemOrderSet, candidateIds);
-	}
-	/** Find items registered but not in a given set */
-	differenceFrom(otherIds) {
-		return setDifference(this.#itemOrderSet, otherIds);
-	}
-	/** Union of registered IDs with another set */
-	unionWith(otherIds) {
-		return setUnion(this.#itemOrderSet, otherIds);
-	}
-	/** Check if registered items are a subset of the given set */
-	isSubsetOf(otherIds) {
-		return setIsSubsetOf(this.#itemOrderSet, otherIds);
-	}
-	/** Check if registered items are a superset of the given set */
-	isSupersetOf(otherIds) {
-		return setIsSupersetOf(this.#itemOrderSet, otherIds);
-	}
-	/** Check if registered items share no IDs with the given set */
-	isDisjointFrom(otherIds) {
-		return setIsDisjointFrom(this.#itemOrderSet, otherIds);
-	}
-	/** Symmetric difference between registered IDs and another set */
-	symmetricDifferenceWith(otherIds) {
-		return setSymmetricDifference(this.#itemOrderSet, 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();
-	}
-};
-// src/core/utils/env.ts
-/**
-* `true` unless `process.env.NODE_ENV` is `'production'`.
-*
-* Consumer bundlers (Vite, webpack, Next, esbuild) replace `process.env.NODE_ENV` statically,
-* so the dev-only branches guarded by this flag fold away in production builds. A browser
-* running the unbundled module throws a ReferenceError on the bare `process` reference;
-* the catch turns that into the production value (`false`), so dev-only code stays off.
-*/
-const isDev = (() => {
-	try {
-		return process.env.NODE_ENV !== "production";
-	} catch {
-		return false;
-	}
-})();
-// src/core/search/default-scorer.ts
-function isWordSeparator(code) {
-	return code === 32 || code === 9 || code === 45 || code === 95 || code === 46 || code === 47 || code === 92;
-}
-/**
-* 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
-	};
-}
-// src/core/search/index.ts
-let leakRegistry;
-if (isDev && typeof window !== "undefined") 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 (ES2025) for result pipelines.
-*/
-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 (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 = setDifference(previousResults, ids);
-		},
-		clear() {
-			indexedEntries.clear();
-			previousQuery = "";
-			previousResults.clear();
-		},
-		[Symbol.dispose]() {
-			indexedEntries.clear();
-			previousResults.clear();
-			if (leakRegistry) leakRegistry.unregister(sentinel);
-		}
-	};
-}
-// 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();
-	}
-};
-// 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).
-*/
-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 = [];
-		}
-	};
-}
-// 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 = mapGroupBy(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: Date.now()
-		});
-	}
-	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;
-		if (newActiveId !== activeId) {
-			setState({
-				...state,
-				activeId: newActiveId,
-				lastUpdated: Date.now()
-			});
-			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: Date.now()
-					});
-					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: Date.now()
-				});
-				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()
-				});
-				break;
-			}
-			case "OPEN":
-				setState({
-					...state,
-					open: true,
-					lastUpdated: Date.now()
-				});
-				emitter.emit("openChange", true);
-				options.onOpenChange?.(true);
-				break;
-			case "CLOSE":
-				setState({
-					...state,
-					open: false,
-					lastUpdated: Date.now()
-				});
-				emitter.emit("openChange", false);
-				options.onOpenChange?.(false);
-				break;
-			case "TOGGLE": {
-				const newOpen = !state.open;
-				setState({
-					...state,
-					open: newOpen,
-					lastUpdated: Date.now()
-				});
-				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(/* @__PURE__ */ 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);
-		}
-	}
-	return {
-		getState() {
-			return state;
-		},
-		send(event) {
-			scheduler.schedule(() => handleEvent(event));
-		},
-		/** useSyncExternalStore-compatible subscribe — returns cleanup function */
-		subscribe(listener) {
-			const disposable = emitter.on("stateChange", listener);
-			return () => disposable[Symbol.dispose]();
-		},
-		/** Full state subscribe — returns Disposable for `using` pattern */
-		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]();
-		}
-	};
-}
-// src/react/hooks/use-command.ts
-/** Core hook that binds a CommandMachine to React via useSyncExternalStore, useOptimistic, and a transition for optimistic active-item updates. */
-function useCommand(machine) {
-	const id = useId();
-	const [isPending, startTransition] = useTransition();
-	const state = useSyncExternalStore(machine.subscribe, machine.getState, machine.getState);
-	const filteredIdSet = useMemo(() => machine.getFilteredIdSet(), [state.filteredIds, machine]);
-	const [optimisticActiveId, rawSetOptimisticActiveId] = useOptimistic(state.activeId);
-	const setOptimisticActiveId = useCallback((id) => {
-		startTransition(() => {
-			rawSetOptimisticActiveId(id);
-		});
-	}, [rawSetOptimisticActiveId]);
-	const updateSearch = useCallback((query) => {
-		machine.send({
-			type: "SEARCH_CHANGE",
-			query
-		});
-	}, [machine]);
-	return {
-		state: optimisticActiveId !== state.activeId ? {
-			...state,
-			activeId: optimisticActiveId
-		} : state,
-		isPending,
-		updateSearch,
-		setOptimisticActiveId,
-		filteredIdSet,
-		id
-	};
-}
-// src/react/hooks/use-keyboard.ts
-/** Navigation key to machine direction mapping */
-const NAVIGATION_KEYS = {
-	ArrowDown: "next",
-	ArrowUp: "prev",
-	Home: "first",
-	End: "last"
-};
-/** Create a keydown handler for command palette keyboard navigation */
-function createKeydownHandler(machine, getState) {
-	return (event) => {
-		const { key } = event;
-		const state = getState();
-		const direction = NAVIGATION_KEYS[key];
-		if (direction) {
-			event.preventDefault();
-			machine.send({
-				type: "NAVIGATE",
-				direction
-			});
-			return;
-		}
-		switch (key) {
-			case "Enter": {
-				event.preventDefault();
-				const { activeId } = state;
-				if (activeId) machine.send({
-					type: "ITEM_SELECT",
-					id: activeId
-				});
-				break;
-			}
-			case "Backspace":
-				if (state.search === "" && state.pageStack.length > 0) {
-					event.preventDefault();
-					machine.send({ type: "PAGE_POP" });
-				}
-				break;
-			case "Escape":
-				event.preventDefault();
-				machine.send({ type: "CLOSE" });
-		}
-	};
-}
-// src/react/hooks/use-command-setup.ts
-/**
-* Shared setup for Command and Command.Dialog — creates machine once,
-* subscribes via useSyncExternalStore, memoizes context values, and
-* registers disposal on unmount.
-*
-* @param machineFactory - Called exactly once (first render) to create the machine.
-*   Subsequent renders skip it via ref guard.
-* @param label - Accessible label for the command palette (included in stable context).
-*/
-function useCommandSetup(machineFactory, label) {
-	const machineRef = useRef(null);
-	if (machineRef.current === null) machineRef.current = machineFactory();
-	const machine = machineRef.current;
-	const { state, isPending, updateSearch, setOptimisticActiveId, filteredIdSet, id } = useCommand(machine);
-	const listId = `${id}-list`;
-	const inputId = `${id}-input`;
-	useEffect(() => {
-		return () => {
-			machineRef.current?.[Symbol.dispose]();
-			machineRef.current = null;
-		};
-	}, []);
-	return {
-		machine,
-		state,
-		isPending,
-		listId,
-		inputId,
-		handleKeyDown: useMemo(() => createKeydownHandler(machine, () => machine.getState()), [machine]),
-		stableContextValue: useMemo(() => ({
-			machine,
-			rootId: id,
-			listId,
-			inputId,
-			label,
-			updateSearch,
-			setOptimisticActiveId
-		}), [
-			machine,
-			id,
-			listId,
-			inputId,
-			label,
-			updateSearch,
-			setOptimisticActiveId
-		]),
-		stateContextValue: useMemo(() => ({
-			state,
-			isPending,
-			filteredIdSet,
-			visibleIdSet: null,
-			virtualPositionMap: null
-		}), [
-			state,
-			isPending,
-			filteredIdSet
-		])
-	};
-}
-// src/react/dialog.tsx
-/** Dialog variant that wraps the command palette in a Radix UI Dialog with focus trap and overlay. */
-function CommandDialog({ children, className, overlayClassName, contentClassName, label = "Command palette", description = "Type a command or search...", open: controlledOpen, onOpenChange, container, ...machineOptions }) {
-	const onOpenChangeRef = useRef(onOpenChange);
-	onOpenChangeRef.current = onOpenChange;
-	const { machine, state, handleKeyDown, stableContextValue, stateContextValue, inputId } = useCommandSetup(() => createCommandMachine({
-		...machineOptions,
-		open: controlledOpen ?? false,
-		onOpenChange: (open) => {
-			onOpenChangeRef.current?.(open);
-		}
-	}), label);
-	useEffect(() => {
-		if (!state.open) return;
-		document.addEventListener("keydown", handleKeyDown);
-		return () => {
-			document.removeEventListener("keydown", handleKeyDown);
-		};
-	}, [handleKeyDown, state.open]);
-	useEffect(() => {
-		if (controlledOpen !== void 0) machine.send({ type: controlledOpen ? "OPEN" : "CLOSE" });
-	}, [controlledOpen, machine]);
-	const handleOpenAutoFocus = useCallback((e) => {
-		e.preventDefault();
-		document.getElementById(inputId)?.focus();
-	}, [inputId]);
-	const handleRadixOpenChange = useCallback((open) => {
-		machine.send({ type: open ? "OPEN" : "CLOSE" });
-	}, [machine]);
-	return /* @__PURE__ */ jsx(Dialog.Root, {
-		open: state.open,
-		onOpenChange: handleRadixOpenChange,
-		children: /* @__PURE__ */ jsxs(Dialog.Portal, {
-			container,
-			children: [/* @__PURE__ */ jsx(Dialog.Overlay, {
-				"data-command-overlay": "",
-				"data-state": state.open ? "open" : "closed",
-				className: overlayClassName
-			}), /* @__PURE__ */ jsxs(Dialog.Content, {
-				"data-command-dialog": "",
-				"data-state": state.open ? "open" : "closed",
-				className,
-				"aria-label": label,
-				onOpenAutoFocus: handleOpenAutoFocus,
-				children: [
-					/* @__PURE__ */ jsx(Dialog.Title, {
-						className: "sr-only",
-						children: label
-					}),
-					/* @__PURE__ */ jsx(Dialog.Description, {
-						className: "sr-only",
-						children: description
-					}),
-					/* @__PURE__ */ jsx(CommandStableContext, {
-						value: stableContextValue,
-						children: /* @__PURE__ */ jsx(CommandStateContext, {
-							value: stateContextValue,
-							children: /* @__PURE__ */ jsx("div", {
-								"data-command-dialog-content": "",
-								className: contentClassName,
-								children: /* @__PURE__ */ jsx("div", {
-									"data-command-root": "",
-									role: "search",
-									"aria-label": label,
-									children
-								})
-							})
-						})
-					})
-				]
-			})]
-		})
-	});
-}
 // src/react/empty.tsx
 /** Rendered when no items match the current search query. */
 function CommandEmpty({ ref, children, ...props }) {
@@ -2046,10 +706,20 @@ var CommandErrorBoundary = class extends Component {
 	componentDidCatch(error, errorInfo) {
 		this.props.onError?.(error, errorInfo);
 	}
+	componentDidUpdate(prevProps, prevState) {
+		if (this.state.error === null || prevState.error === null) return;
+		const prev = prevProps.resetKeys;
+		const next = this.props.resetKeys;
+		if (prev !== next && (prev?.length !== next?.length || next?.some((key, index) => !Object.is(key, prev?.[index])))) this.reset();
+	}
+	/** Clears the captured error so the children render again. */
+	reset = () => {
+		this.setState(INITIAL_STATE);
+	};
 	render() {
 		if (this.state.error) {
 			const { fallback } = this.props;
-			if (typeof fallback === "function") return fallback(this.state.error);
+			if (typeof fallback === "function") return fallback(this.state.error, this.reset);
 			if (fallback) return fallback;
 			return null;
 		}
@@ -2065,6 +735,13 @@ function useCommandState(selector) {
 	return useSyncExternalStore(stable.machine.subscribe, getSnapshot, getSnapshot);
 }
 // src/react/hooks/use-devtools.ts
+const isDev = (() => {
+	try {
+		return process.env.NODE_ENV !== "production";
+	} catch {
+		return false;
+	}
+})();
 /** Branded key for the global devtools instance map */
 const DEVTOOLS_KEY = "__CRIMSON_COMMAND_DEVTOOLS__";
 /**