@vuetify/v0 0.1.12 → 0.2.0

package/dist/{useClickOutside-hbi0BOL-.mjs → createCombobox-DgFUWLKw.mjs}

@@ -1,14 +1,15 @@
-import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, r as SUPPORTS_MATCH_MEDIA, t as IN_BROWSER } from "./globals-uLTsqsl2.mjs";
+import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, r as SUPPORTS_MATCH_MEDIA, t as IN_BROWSER } from "./globals-B6VQTLVM.mjs";
 import { clamp, instanceExists, isElement, isFunction, isNull, isNullOrUndefined, isNumber, isObject, isString, isUndefined, mergeDeep, useId as useId$1 } from "./utilities/index.mjs";
 import { i as useContext, n as createContext, t as createTrinity } from "./createTrinity-C_c8eedz.mjs";
-import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-jmvgVE6N.mjs";
-import { a as createRegistry } from "./createTokens-C67MMcZJ.mjs";
-import { i as createModel, t as createSelection } from "./createSelection-Cl1nX0he.mjs";
-import { t as createSingle } from "./createSingle-BxOPkL3l.mjs";
-import { t as createGroup } from "./createGroup-CFMocwej.mjs";
+import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-B3ijAgn0.mjs";
+import { a as createRegistry } from "./createTokens-Ckczb95n.mjs";
+import { i as createModel, t as createSelection } from "./createSelection-GS1yfwki.mjs";
+import { t as createSingle } from "./createSingle-Dh2gp4kv.mjs";
+import { t as createGroup } from "./createGroup-C38Mc-se.mjs";
 import { t as toArray } from "./toArray-VdROPpy-.mjs";
-import { a as useLocale } from "./useLocale-BpjMU7hm.mjs";
-import { a as useRules, o as isStandardSchema } from "./useRules-sRYyyrvM.mjs";
+import { a as useLocale } from "./useLocale-BNecStw9.mjs";
+import { n as createFilter } from "./adapter-DXRKF27V.mjs";
+import { a as useRules, o as isStandardSchema } from "./useRules-BnQZP8n2.mjs";
 import { t as MemoryAdapter } from "./memory-XCMtkld1.mjs";
 import { computed, effectScope, isRef, nextTick, onMounted, onScopeDispose, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
 //#region src/composables/createBreadcrumbs/index.ts
@@ -692,222 +693,6 @@ function useOverflow(namespace = "v0:overflow") {
 	return useContext(namespace);
 }
 //#endregion
-//#region src/composables/useProxyModel/index.ts
-/**
-* @module useProxyModel
-*
-* @remarks
-* Proxy composable for bidirectional sync between a model context and v-model.
-*
-* Key features:
-* - Bidirectional synchronization
-* - Array and single-value modes
-* - Automatic cleanup on scope disposal
-* - Works with any ModelContext (Selection, Slider, etc.)
-*
-* Bridges the gap between model composables and Vue's v-model.
-*/
-/**
-* Syncs a ref with a model context bidirectionally.
-*
-* @param context The model context to bind to.
-* @param model The ref to sync.
-* @param options The options for the proxy model.
-* @returns A function to stop the sync.
-*
-* @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
-*
-* @example
-* ```ts
-* import { createSelection, useProxyModel } from '@vuetify/v0'
-*
-* const model = ref()
-* const registry = createSelection({ events: true })
-* registry.onboard([
-*   { id: 'item-1', value: 'Item 1' },
-*   { id: 'item-2', value: 'Item 2' },
-* ])
-*
-* const stop = useProxyModel(registry, model)
-* ```
-*/
-function useProxyModel(context, model, options) {
-	const multiple = options?.multiple ?? context.multiple ?? false;
-	const _transformIn = options?.transformIn;
-	const _transformOut = options?.transformOut;
-	function transformIn(val) {
-		const value = toValue(val);
-		return toArray(/* @__PURE__ */ isFunction(_transformIn) ? _transformIn(value) : value);
-	}
-	function transformOut(val) {
-		if (/* @__PURE__ */ isFunction(_transformOut)) return _transformOut(val);
-		return toValue(multiple) ? val : val[0];
-	}
-	const applyOptions = toValue(multiple) === toValue(context.multiple ?? false) ? void 0 : { multiple: toValue(multiple) };
-	const modelAsArray = transformIn(model);
-	const pending = new Set(modelAsArray);
-	context.apply(modelAsArray, applyOptions);
-	const selected = new Set(context.selectedValues.value);
-	for (const value of modelAsArray) if (selected.has(value)) pending.delete(value);
-	const contextWatch = watch(context.selectedValues, (val) => {
-		modelWatch.pause();
-		model.value = transformOut(Array.from(toValue(val)));
-		modelWatch.resume();
-	}, { flush: "sync" });
-	const modelWatch = watch(model, (val) => {
-		contextWatch.pause();
-		context.apply(transformIn(val), applyOptions);
-		contextWatch.resume();
-	}, {
-		flush: "sync",
-		deep: toValue(multiple)
-	});
-	function onRegister(data) {
-		const ticket = data;
-		if (!pending.has(ticket.value) || toValue(ticket.disabled)) return;
-		contextWatch.pause();
-		modelWatch.pause();
-		context.select?.(ticket.id);
-		pending.delete(ticket.value);
-		modelWatch.resume();
-		contextWatch.resume();
-	}
-	context.on?.("register:ticket", onRegister);
-	function stop() {
-		contextWatch();
-		modelWatch();
-		context.off?.("register:ticket", onRegister);
-	}
-	onScopeDispose(stop, true);
-	return stop;
-}
-//#endregion
-//#region src/composables/useTimer/index.ts
-/**
-* @module useTimer
-*
-* @remarks
-* A reactive timer composable with pause/resume support.
-*
-* Key features:
-* - Start/stop/pause/resume controls
-* - Reactive remaining time tracking
-* - One-shot (default) or repeating mode
-* - Automatic cleanup on scope disposal
-* - SSR-safe
-*/
-/**
-* Creates a reactive timer with pause/resume support.
-*
-* @param handler Callback invoked when the timer fires.
-* @param options Timer configuration.
-* @returns Timer controls and reactive state.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-timer
-*
-* @example
-* ```ts
-* const timer = useTimer(() => console.log('fired'), { duration: 5000 })
-*
-* timer.start()
-* timer.pause()
-* timer.resume()
-* timer.stop()
-* ```
-*/
-function useTimer(handler, options = {}) {
-	const { duration = 1e3, repeat = false } = options;
-	const remaining = shallowRef(duration);
-	const isActive = shallowRef(false);
-	const isPaused = shallowRef(false);
-	let timeoutId;
-	let trackingId;
-	let startedAt = 0;
-	let budget = duration;
-	function clearTimer() {
-		if (!/* @__PURE__ */ isUndefined(timeoutId)) {
-			globalThis.clearTimeout(timeoutId);
-			timeoutId = void 0;
-		}
-	}
-	function startTracking() {
-		stopTracking();
-		if (!IN_BROWSER) return;
-		trackingId = globalThis.setInterval(() => {
-			if (!isActive.value || isPaused.value) return;
-			const elapsed = Date.now() - startedAt;
-			remaining.value = Math.max(0, budget - elapsed);
-		}, 100);
-	}
-	function stopTracking() {
-		if (!/* @__PURE__ */ isUndefined(trackingId)) {
-			globalThis.clearInterval(trackingId);
-			trackingId = void 0;
-		}
-	}
-	function fire() {
-		clearTimer();
-		stopTracking();
-		handler();
-		if (repeat) begin(duration);
-		else {
-			isActive.value = false;
-			remaining.value = 0;
-		}
-	}
-	function begin(ms) {
-		clearTimer();
-		stopTracking();
-		budget = ms;
-		startedAt = Date.now();
-		remaining.value = ms;
-		isActive.value = true;
-		isPaused.value = false;
-		timeoutId = globalThis.setTimeout(fire, ms);
-		startTracking();
-	}
-	function start() {
-		if (duration < 0) return;
-		begin(duration);
-	}
-	function stop() {
-		clearTimer();
-		stopTracking();
-		isActive.value = false;
-		isPaused.value = false;
-		remaining.value = duration;
-	}
-	function pause() {
-		if (!isActive.value || isPaused.value) return;
-		const elapsed = Date.now() - startedAt;
-		budget = Math.max(0, budget - elapsed);
-		remaining.value = budget;
-		clearTimer();
-		stopTracking();
-		isPaused.value = true;
-	}
-	function resume() {
-		if (!isPaused.value) return;
-		isPaused.value = false;
-		startedAt = Date.now();
-		timeoutId = globalThis.setTimeout(fire, budget);
-		startTracking();
-	}
-	onScopeDispose(() => {
-		clearTimer();
-		stopTracking();
-	}, true);
-	return {
-		start,
-		stop,
-		pause,
-		resume,
-		remaining,
-		isActive,
-		isPaused
-	};
-}
-//#endregion
 //#region src/composables/toReactive/index.ts
 /**
 * @module toReactive
@@ -924,6 +709,115 @@ function useTimer(handler, options = {}) {
 *
 * Perfect for creating reactive versions of plain objects while automatically unwrapping refs.
 */
+function createMapProxy(refObject) {
+	let mapProxy;
+	const mapHandlers = {
+		get: (key) => unref(refObject.value.get(key)),
+		set: (key, value) => {
+			const map = refObject.value;
+			const existingValue = map.get(key);
+			if (isRef(existingValue)) existingValue.value = unref(value);
+			else map.set(key, value);
+			return mapProxy;
+		},
+		has: (key) => refObject.value.has(key),
+		delete: (key) => refObject.value.delete(key),
+		clear: () => refObject.value.clear(),
+		keys: () => refObject.value.keys(),
+		*values() {
+			for (const value of refObject.value.values()) yield unref(value);
+		},
+		*entries() {
+			for (const [key, value] of refObject.value.entries()) yield [key, unref(value)];
+		},
+		forEach: (callback, thisArg) => {
+			for (const [key, value] of refObject.value.entries()) callback.call(thisArg, unref(value), key, mapProxy);
+		}
+	};
+	mapHandlers[Symbol.iterator] = mapHandlers.entries;
+	mapProxy = new Proxy(/* @__PURE__ */ new Map(), { get(_, p) {
+		if (p === "size") return refObject.value.size;
+		if (Object.prototype.hasOwnProperty.call(mapHandlers, p)) return mapHandlers[p];
+		const map = refObject.value;
+		const value = Reflect.get(map, p);
+		return typeof value === "function" ? value.bind(map) : value;
+	} });
+	return reactive(mapProxy);
+}
+function createSetProxy(refObject) {
+	let setProxy;
+	const setHandlers = {
+		add: (value) => {
+			refObject.value.add(value);
+			return setProxy;
+		},
+		has: (value) => refObject.value.has(value),
+		delete: (value) => refObject.value.delete(value),
+		clear: () => refObject.value.clear(),
+		*keys() {
+			for (const value of refObject.value.values()) yield unref(value);
+		},
+		*values() {
+			for (const value of refObject.value.values()) yield unref(value);
+		},
+		*entries() {
+			for (const value of refObject.value.values()) {
+				const unreffedValue = unref(value);
+				yield [unreffedValue, unreffedValue];
+			}
+		},
+		forEach: (callback, thisArg) => {
+			for (const value of refObject.value) {
+				const unreffedValue = unref(value);
+				callback.call(thisArg, unreffedValue, unreffedValue, setProxy);
+			}
+		}
+	};
+	setHandlers[Symbol.iterator] = setHandlers.values;
+	setProxy = new Proxy(/* @__PURE__ */ new Set(), { get(_, p) {
+		if (p === "size") return refObject.value.size;
+		if (Object.prototype.hasOwnProperty.call(setHandlers, p)) return setHandlers[p];
+		const set = refObject.value;
+		const value = Reflect.get(set, p);
+		return typeof value === "function" ? value.bind(set) : value;
+	} });
+	return reactive(setProxy);
+}
+function createObjectProxy(refObject) {
+	return reactive(new Proxy({}, {
+		get(_, p, receiver) {
+			return unref(Reflect.get(refObject.value, p, receiver));
+		},
+		set(_, p, value) {
+			return Reflect.set(refObject.value, p, value);
+		},
+		deleteProperty(_, p) {
+			return Reflect.deleteProperty(refObject.value, p);
+		},
+		has(_, p) {
+			return Reflect.has(refObject.value, p);
+		},
+		ownKeys() {
+			return Reflect.ownKeys(refObject.value);
+		},
+		getOwnPropertyDescriptor(_, p) {
+			const desc = Reflect.getOwnPropertyDescriptor(refObject.value, p);
+			if (!desc) return;
+			const newDesc = {
+				configurable: true,
+				enumerable: desc.enumerable
+			};
+			if ("value" in desc) {
+				newDesc.value = unref(desc.value);
+				newDesc.writable = desc.writable;
+			} else {
+				newDesc.get = desc.get;
+				newDesc.set = desc.set;
+			}
+			return newDesc;
+		}
+	}));
+}
 /**
 * Converts a `MaybeRef` to a `UnwrapNestedRefs`.
 *
@@ -946,100 +840,11 @@ function useTimer(handler, options = {}) {
 */
 function toReactive(objectRef) {
 	if (!isRef(objectRef)) return reactive(objectRef);
-	const target = objectRef.value;
-	if (target instanceof Map) {
-		const mapProxy = new Proxy(/* @__PURE__ */ new Map(), { get(_, p) {
-			const map = objectRef.value;
-			if (p === "get") return (key) => unref(map.get(key));
-			if (p === "set") return (key, value) => {
-				const existingValue = map.get(key);
-				if (isRef(existingValue)) existingValue.value = unref(value);
-				else map.set(key, value);
-				return mapProxy;
-			};
-			if (p === "has") return (key) => map.has(key);
-			if (p === "delete") return (key) => map.delete(key);
-			if (p === "clear") return () => map.clear();
-			if (p === "size") return map.size;
-			if (p === "keys") return () => map.keys();
-			if (p === "values") return function* () {
-				for (const value of map.values()) yield unref(value);
-			};
-			if (p === "entries") return function* () {
-				for (const [key, value] of map.entries()) yield [key, unref(value)];
-			};
-			if (p === "forEach") return (callback, thisArg) => {
-				for (const [key, value] of map.entries()) callback.call(thisArg, unref(value), key, mapProxy);
-			};
-			if (p === Symbol.iterator) return function* () {
-				for (const [key, value] of map.entries()) yield [key, unref(value)];
-			};
-			return Reflect.get(map, p);
-		} });
-		return reactive(mapProxy);
-	}
-	if (target instanceof Set) {
-		const setProxy = new Proxy(/* @__PURE__ */ new Set(), { get(_, p) {
-			const set = objectRef.value;
-			if (p === "add") return (value) => {
-				set.add(value);
-				return setProxy;
-			};
-			if (p === "has") return (value) => set.has(value);
-			if (p === "delete") return (value) => set.delete(value);
-			if (p === "clear") return () => set.clear();
-			if (p === "size") return set.size;
-			if (p === "keys" || p === "values") return function* () {
-				for (const value of set.values()) yield unref(value);
-			};
-			if (p === "entries") return function* () {
-				for (const value of set.values()) {
-					const unreffedValue = unref(value);
-					yield [unreffedValue, unreffedValue];
-				}
-			};
-			if (p === "forEach") return (callback, thisArg) => {
-				for (const value of set) {
-					const unreffedValue = unref(value);
-					callback.call(thisArg, unreffedValue, unreffedValue, setProxy);
-				}
-			};
-			if (p === Symbol.iterator) return function* () {
-				for (const value of set.values()) yield unref(value);
-			};
-			return Reflect.get(set, p);
-		} });
-		return reactive(setProxy);
-	}
-	return reactive(new Proxy({}, {
-		get(_, p, receiver) {
-			return unref(Reflect.get(objectRef.value, p, receiver));
-		},
-		set(_, p, value) {
-			const currentTarget = objectRef.value;
-			currentTarget[p] = value;
-			return true;
-		},
-		deleteProperty(_, p) {
-			return Reflect.deleteProperty(objectRef.value, p);
-		},
-		has(_, p) {
-			return Reflect.has(objectRef.value, p);
-		},
-		ownKeys() {
-			return Object.keys(objectRef.value);
-		},
-		getOwnPropertyDescriptor(_, p) {
-			const desc = Reflect.getOwnPropertyDescriptor(objectRef.value, p);
-			if (!desc) return;
-			const newDesc = {
-				...desc,
-				configurable: true
-			};
-			if ("value" in newDesc) newDesc.value = unref(newDesc.value);
-			return newDesc;
-		}
-	}));
+	const refObject = objectRef;
+	const target = refObject.value;
+	if (target instanceof Map) return createMapProxy(refObject);
+	if (target instanceof Set) return createSetProxy(refObject);
+	return createObjectProxy(refObject);
 }
 //#endregion
 //#region src/composables/useBreakpoints/index.ts
@@ -1243,202 +1048,459 @@ const [createBreakpointsContext, createBreakpointsPlugin, useBreakpoints] = crea
 	}
 });
 //#endregion
-//#region src/composables/useDate/index.ts
+//#region src/composables/useClickOutside/index.ts
 /**
-* @module useDate
+* @module useClickOutside
 *
 * @remarks
-* Date manipulation composable with adapter pattern for date operations.
+* Detects clicks outside of specified element(s) with automatic cleanup.
 *
 * Key features:
-* - Adapter pattern for date library abstraction
-* - Locale-aware formatting via Intl.DateTimeFormat
-* - Integration with useLocale for automatic locale sync
-*
-* @example Using the built-in Temporal adapter
-* ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
-* import { createDatePlugin } from '@vuetify/v0'
-*
-* const app = createApp(App)
-* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
-*
-* // In a component:
-* const { adapter } = useDate()
-* const today = adapter.date()
-* const formatted = adapter.format(today, 'fullDate')
-* ```
-*
-* @example Custom adapter
-* ```ts
-* import type { DateAdapter } from '@vuetify/v0'
+* - Two-phase detection (pointerdown → pointerup) prevents drag-out false positives
+* - Touch scroll threshold ignores swipes/scrolls on mobile
+* - Capture phase listeners work with stopPropagation
+* - Pause/resume/stop functionality
+* - Optional iframe focus detection
+* - SSR-safe (no-op when not in browser)
 *
-* class DateFnsAdapter implements DateAdapter<Date> {
-*   // ... implementation
-* }
+* Common use cases: closing popovers, dropdowns, modals, and menus.
 *
-* app.use(createDatePlugin({ adapter: new DateFnsAdapter() }))
-* ```
-*/
-/**
-* Default short locale codes mapped to full Intl locale strings.
-* Used when useLocale provides a short code without region (e.g., 'en' instead of 'en-US').
-*/
-const defaultLocales = {
-	en: "en-US",
-	es: "es-ES",
-	fr: "fr-FR",
-	de: "de-DE",
-	it: "it-IT",
-	pt: "pt-BR",
-	ja: "ja-JP",
-	ko: "ko-KR",
-	zh: "zh-CN",
-	ru: "ru-RU",
-	ar: "ar-SA"
-};
-/**
-* Derive firstDayOfWeek from an Intl locale string.
-* Returns 0-6 (0=Sun) or 0 as fallback.
+* Accessibility: This composable handles pointer interactions only. For accessible
+* components (dialogs, popovers, menus), pair with `useHotkey` for Escape key
+* dismissal per WCAG/APG requirements.
 */
-function deriveFirstDayOfWeek(locale) {
-	try {
-		const info = new Intl.Locale(locale).getWeekInfo?.();
-		return info ? info.firstDay % 7 : 0;
-	} catch {
-		return 0;
-	}
-}
 /**
-* Creates a new date context.
+* Detects clicks outside of the specified element(s).
 *
-* @param options Adapter and locale configuration.
-* @template Z The date type used by the adapter.
-* @template E The date context type.
-* @returns A date context.
+* Uses two-phase detection (pointerdown → pointerup) to prevent false positives
+* when users drag from inside to outside an element.
 *
-* @see https://0.vuetifyjs.com/composables/plugins/use-date
+* @param target Element ref(s) to detect clicks outside of. Accepts a single ref/getter or array of refs/getters.
+* @param handler Callback invoked when a click outside is detected.
+* @param options Configuration options.
+* @returns An object with methods to control the listener.
 *
-* @example
-* ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* @see https://0.vuetifyjs.com/composables/system/use-click-outside
 *
-* const { adapter } = createDate({ adapter: new Vuetify0DateAdapter() })
-* const today = adapter.date()
+* @example Native element ref
+* ```ts
+* const menuRef = useTemplateRef<HTMLElement>('menu')
 *
-* // With locale options
-* const { adapter } = createDate({
-*   adapter: new Vuetify0DateAdapter(),
-*   locale: 'de-DE',
-* })
+* useClickOutside(menuRef, () => { isOpen.value = false })
 * ```
-*/
-function createDate(options) {
-	const { locales = defaultLocales, adapter, locale: initialLocale, firstDayOfWeek: explicitFirstDay } = options;
-	let selectedId;
-	try {
-		if (instanceExists()) selectedId = useLocale().selectedId;
-	} catch {}
-	const locale = computed(() => {
-		const selected = selectedId?.value;
-		if (!/* @__PURE__ */ isNullOrUndefined(selected)) {
-			const str = String(selected);
-			return str.includes("-") ? str : locales[str] ?? str;
-		}
-		const fallback = initialLocale ?? adapter.locale ?? "en-US";
-		return fallback.includes("-") ? fallback : locales[fallback] ?? fallback;
-	});
-	const firstDayOfWeek = computed(() => {
-		if (!/* @__PURE__ */ isUndefined(explicitFirstDay)) return explicitFirstDay;
-		const loc = locale.value;
-		return loc ? deriveFirstDayOfWeek(loc) : 0;
-	});
-	if (instanceExists()) onScopeDispose(watchEffect(() => {
-		const loc = locale.value;
-		if (loc && adapter.locale !== loc) adapter.locale = loc;
-		const fdow = firstDayOfWeek.value;
-		if (adapter.firstDayOfWeek !== fdow) adapter.firstDayOfWeek = fdow;
-	}));
-	else {
-		const loc = locale.value;
-		if (loc && adapter.locale !== loc) adapter.locale = loc;
-		const fdow = firstDayOfWeek.value;
-		if (adapter.firstDayOfWeek !== fdow) adapter.firstDayOfWeek = fdow;
-	}
-	return {
-		adapter,
-		locale,
-		firstDayOfWeek
-	};
-}
-/**
-* Creates a new date context trinity.
-*
-* @param options Adapter, locale, and namespace configuration.
-* @template Z The date type used by the adapter.
-* @template E The date context type.
-* @returns A trinity [useContext, provideContext, defaultContext].
-*
-* @see https://0.vuetifyjs.com/composables/plugins/use-date
 *
-* @example
+* @example Component ref (e.g., Atom)
 * ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* const atomRef = useTemplateRef<AtomExpose>('atom')
 *
-* const [useAppDate, provideAppDate] = createDateContext({
-*   adapter: new Vuetify0DateAdapter(),
-*   namespace: 'app:date',
-* })
+* // Pass the exposed element TemplateRef via getter
+* useClickOutside(
+*   () => atomRef.value?.element,
+*   () => { isOpen.value = false }
+* )
 * ```
-*/
-function createDateContext(options) {
-	const { namespace = "v0:date", ...dateOptions } = options;
-	const [useDateContext, _provideDateContext] = createContext(namespace);
-	const context = createDate(dateOptions);
-	function provideDateContext(_context = context, app) {
-		return _provideDateContext(_context, app);
-	}
-	return createTrinity(useDateContext, provideDateContext, context);
-}
-/**
-* Creates a new date plugin.
 *
-* @param options Adapter, locale, and namespace configuration.
-* @template Z The date type used by the adapter.
-* @template E The date context type.
-* @returns A Vue plugin.
+* @example Multiple targets
+* ```ts
+* const popoverRef = useTemplateRef<AtomExpose>('popover')
+* const anchorRef = useTemplateRef<HTMLElement>('anchor')
 *
-* @see https://0.vuetifyjs.com/composables/plugins/use-date
+* useClickOutside(
+*   [() => popoverRef.value?.element, anchorRef],
+*   () => { isOpen.value = false }
+* )
+* ```
 *
-* @example
+* @example Ignoring elements (CSS selectors or refs)
 * ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* useClickOutside(
+*  () => navRef.value?.element,
+*  () => { isOpen.value = false },
+*  { ignore: ['[data-app-bar]'] }
+* )
+* ```
 *
-* const app = createApp(App)
-* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+* @example Native dialog with bounds detection
+* ```ts
+* // For native <dialog> elements, use bounds mode to detect backdrop clicks
+* const dialogRef = useTemplateRef<HTMLDialogElement>('dialog')
 *
-* // With locale options
-* app.use(createDatePlugin({
-*   adapter: new Vuetify0DateAdapter(),
-*   locale: 'de-DE',
-* }))
+* useClickOutside(
+*   dialogRef,
+*   () => { dialogRef.value?.close() },
+*   { bounds: true }
+* )
 * ```
 */
-function createDatePlugin(options) {
-	const { namespace = "v0:date", ...dateOptions } = options;
-	const [, provideDateContext, context] = createDateContext({
-		namespace,
-		...dateOptions
-	});
-	return createPlugin({
-		namespace,
-		provide: (app) => {
-			provideDateContext(context, app);
-		}
-	});
-}
-/**
-* Returns the current date context.
+function useClickOutside(target, handler, options = {}) {
+	const { capture = true, touchScrollThreshold = 30, detectIframe = false, ignore = [], bounds = false } = options;
+	const isPaused = shallowRef(false);
+	const isActive = toRef(() => !isPaused.value);
+	let initialTarget = null;
+	let startPosition = {
+		x: 0,
+		y: 0
+	};
+	let cleanupPointerDown;
+	let cleanupPointerUp;
+	let cleanupBlur;
+	/**
+	* Resolve target(s) to an array of HTMLElements.
+	*/
+	function getTargets() {
+		return toArray(target).map((source) => toValue(source)).filter((el) => !!el && /* @__PURE__ */ isFunction(el.contains));
+	}
+	/**
+	* Resolve ignore targets to a tuple of [selectors, elements].
+	* Called once per event to avoid repeated toValue() calls in hot path.
+	*/
+	function resolveIgnoreTargets() {
+		const ignoreTargets = toValue(ignore);
+		if (ignoreTargets.length === 0) return [[], []];
+		const selectors = [];
+		const elements = [];
+		for (const ignoreTarget of ignoreTargets) if (/* @__PURE__ */ isString(ignoreTarget)) selectors.push(ignoreTarget);
+		else {
+			const ignoreEl = toValue(ignoreTarget);
+			if (ignoreEl) elements.push(ignoreEl);
+		}
+		return [selectors, elements];
+	}
+	/**
+	* Check if an element matches resolved ignore targets.
+	*/
+	function isIgnored(el, selectors, elements) {
+		if (!el) return false;
+		for (const selector of selectors) try {
+			if (el.matches(selector) || !/* @__PURE__ */ isNull(el.closest(selector))) return true;
+		} catch {}
+		for (const ignoreEl of elements) if (ignoreEl === el || ignoreEl.contains(el)) return true;
+		return false;
+	}
+	/**
+	* Check if any element in the event path should be ignored.
+	*/
+	function shouldIgnore(path) {
+		const [selectors, elements] = resolveIgnoreTargets();
+		if (selectors.length === 0 && elements.length === 0) return false;
+		return path.some((node) => node instanceof Element && isIgnored(node, selectors, elements));
+	}
+	/**
+	* Check if the event target is outside all target elements (DOM containment).
+	*/
+	function isOutside(eventTarget) {
+		/* v8 ignore start -- defensive guards */
+		if (!eventTarget) return false;
+		if (!(eventTarget instanceof Node)) return false;
+		/* v8 ignore stop */
+		const targets = getTargets();
+		if (targets.length === 0) return false;
+		return targets.every((el) => {
+			if (/* @__PURE__ */ isNullOrUndefined(el) || !/* @__PURE__ */ isFunction(el.contains)) return false;
+			return el !== eventTarget && !el.contains(eventTarget);
+		});
+	}
+	/**
+	* Check if coordinates are outside all target elements' bounding rects.
+	*/
+	function isOutsideBounds(x, y) {
+		const targets = getTargets();
+		if (targets.length === 0) return false;
+		return targets.every((el) => {
+			const { left, right, top, bottom } = el.getBoundingClientRect();
+			return x < left || x > right || y < top || y > bottom;
+		});
+	}
+	/**
+	* Validate that the target is still in the DOM.
+	*/
+	function isValidTarget(eventTarget) {
+		if (!(eventTarget instanceof Element)) return false;
+		if (!eventTarget.isConnected) return false;
+		return true;
+	}
+	/* v8 ignore start -- event handlers tested via integration, not unit */
+	/**
+	* Handle pointerdown - store initial target and position.
+	*/
+	function onPointerDown(event) {
+		if (isPaused.value) return;
+		if (event.defaultPrevented) return;
+		initialTarget = event.composedPath()[0] ?? event.target;
+		startPosition = {
+			x: event.clientX,
+			y: event.clientY
+		};
+	}
+	/**
+	* Handle pointerup - check if it's an outside click.
+	*/
+	function onPointerUp(event) {
+		if (isPaused.value) return;
+		if (event.defaultPrevented) return;
+		if (!initialTarget) return;
+		const pointerdownTarget = initialTarget;
+		initialTarget = null;
+		if (!isValidTarget(pointerdownTarget)) return;
+		const path = event.composedPath();
+		const pointerupTarget = path[0] ?? event.target;
+		if (event.pointerType === "touch") {
+			const dx = Math.abs(event.clientX - startPosition.x);
+			const dy = Math.abs(event.clientY - startPosition.y);
+			if (dx >= touchScrollThreshold || dy >= touchScrollThreshold) return;
+		}
+		if ((bounds ? isOutsideBounds(startPosition.x, startPosition.y) && isOutsideBounds(event.clientX, event.clientY) : isOutside(pointerdownTarget) && isOutside(pointerupTarget)) && !shouldIgnore(path)) handler(event);
+	}
+	/**
+	* Handle window blur - detect focus moving to iframe.
+	*/
+	function onBlur(event) {
+		if (isPaused.value) return;
+		if (event.defaultPrevented) return;
+		if (document.activeElement instanceof HTMLIFrameElement) {
+			const iframeIsOutside = getTargets().every((el) => !el.contains(document.activeElement));
+			const [selectors, elements] = resolveIgnoreTargets();
+			if (iframeIsOutside && !isIgnored(document.activeElement, selectors, elements)) handler(event);
+		}
+	}
+	/* v8 ignore stop */
+	function setup() {
+		cleanupPointerDown = useDocumentEventListener("pointerdown", onPointerDown, capture);
+		cleanupPointerUp = useDocumentEventListener("pointerup", onPointerUp, capture);
+		if (!detectIframe) return;
+		cleanupBlur = useWindowEventListener("blur", onBlur, capture);
+	}
+	function cleanup() {
+		cleanupPointerDown?.();
+		cleanupPointerUp?.();
+		cleanupBlur?.();
+		cleanupPointerDown = void 0;
+		cleanupPointerUp = void 0;
+		cleanupBlur = void 0;
+	}
+	function pause() {
+		if (isPaused.value) return;
+		isPaused.value = true;
+		initialTarget = null;
+		cleanup();
+	}
+	function resume() {
+		if (!isPaused.value) return;
+		isPaused.value = false;
+		setup();
+	}
+	function stop() {
+		isPaused.value = true;
+		initialTarget = null;
+		cleanup();
+	}
+	setup();
+	onScopeDispose(stop, true);
+	return {
+		isActive: shallowReadonly(isActive),
+		isPaused: shallowReadonly(isPaused),
+		pause,
+		resume,
+		stop
+	};
+}
+//#endregion
+//#region src/composables/useDate/index.ts
+/**
+* @module useDate
+*
+* @remarks
+* Date manipulation composable with adapter pattern for date operations.
+*
+* Key features:
+* - Adapter pattern for date library abstraction
+* - Locale-aware formatting via Intl.DateTimeFormat
+* - Integration with useLocale for automatic locale sync
+*
+* @example Using the built-in Temporal adapter
+* ```ts
+* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { createDatePlugin } from '@vuetify/v0'
+*
+* const app = createApp(App)
+* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+*
+* // In a component:
+* const { adapter } = useDate()
+* const today = adapter.date()
+* const formatted = adapter.format(today, 'fullDate')
+* ```
+*
+* @example Custom adapter
+* ```ts
+* import type { DateAdapter } from '@vuetify/v0'
+*
+* class DateFnsAdapter implements DateAdapter<Date> {
+*   // ... implementation
+* }
+*
+* app.use(createDatePlugin({ adapter: new DateFnsAdapter() }))
+* ```
+*/
+/**
+* Default short locale codes mapped to full Intl locale strings.
+* Used when useLocale provides a short code without region (e.g., 'en' instead of 'en-US').
+*/
+const defaultLocales = {
+	en: "en-US",
+	es: "es-ES",
+	fr: "fr-FR",
+	de: "de-DE",
+	it: "it-IT",
+	pt: "pt-BR",
+	ja: "ja-JP",
+	ko: "ko-KR",
+	zh: "zh-CN",
+	ru: "ru-RU",
+	ar: "ar-SA"
+};
+/**
+* Derive firstDayOfWeek from an Intl locale string.
+* Returns 0-6 (0=Sun) or 0 as fallback.
+*/
+function deriveFirstDayOfWeek(locale) {
+	try {
+		const info = new Intl.Locale(locale).getWeekInfo?.();
+		return info ? info.firstDay % 7 : 0;
+	} catch {
+		return 0;
+	}
+}
+/**
+* Creates a new date context.
+*
+* @param options Adapter and locale configuration.
+* @template Z The date type used by the adapter.
+* @template E The date context type.
+* @returns A date context.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-date
+*
+* @example
+* ```ts
+* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+*
+* const { adapter } = createDate({ adapter: new Vuetify0DateAdapter() })
+* const today = adapter.date()
+*
+* // With locale options
+* const { adapter } = createDate({
+*   adapter: new Vuetify0DateAdapter(),
+*   locale: 'de-DE',
+* })
+* ```
+*/
+function createDate(options) {
+	const { locales = defaultLocales, adapter, locale: initialLocale, firstDayOfWeek: explicitFirstDay } = options;
+	let selectedId;
+	try {
+		if (instanceExists()) selectedId = useLocale().selectedId;
+	} catch {}
+	const locale = computed(() => {
+		const selected = selectedId?.value;
+		if (!/* @__PURE__ */ isNullOrUndefined(selected)) {
+			const str = String(selected);
+			return str.includes("-") ? str : locales[str] ?? str;
+		}
+		const fallback = initialLocale ?? adapter.locale ?? "en-US";
+		return fallback.includes("-") ? fallback : locales[fallback] ?? fallback;
+	});
+	const firstDayOfWeek = computed(() => {
+		if (!/* @__PURE__ */ isUndefined(explicitFirstDay)) return explicitFirstDay;
+		const loc = locale.value;
+		return loc ? deriveFirstDayOfWeek(loc) : 0;
+	});
+	if (instanceExists()) onScopeDispose(watchEffect(() => {
+		const loc = locale.value;
+		if (loc && adapter.locale !== loc) adapter.locale = loc;
+		const fdow = firstDayOfWeek.value;
+		if (adapter.firstDayOfWeek !== fdow) adapter.firstDayOfWeek = fdow;
+	}));
+	else {
+		const loc = locale.value;
+		if (loc && adapter.locale !== loc) adapter.locale = loc;
+		const fdow = firstDayOfWeek.value;
+		if (adapter.firstDayOfWeek !== fdow) adapter.firstDayOfWeek = fdow;
+	}
+	return {
+		adapter,
+		locale,
+		firstDayOfWeek
+	};
+}
+/**
+* Creates a new date context trinity.
+*
+* @param options Adapter, locale, and namespace configuration.
+* @template Z The date type used by the adapter.
+* @template E The date context type.
+* @returns A trinity [useContext, provideContext, defaultContext].
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-date
+*
+* @example
+* ```ts
+* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+*
+* const [useAppDate, provideAppDate] = createDateContext({
+*   adapter: new Vuetify0DateAdapter(),
+*   namespace: 'app:date',
+* })
+* ```
+*/
+function createDateContext(options) {
+	const { namespace = "v0:date", ...dateOptions } = options;
+	const [useDateContext, _provideDateContext] = createContext(namespace);
+	const context = createDate(dateOptions);
+	function provideDateContext(_context = context, app) {
+		return _provideDateContext(_context, app);
+	}
+	return createTrinity(useDateContext, provideDateContext, context);
+}
+/**
+* Creates a new date plugin.
+*
+* @param options Adapter, locale, and namespace configuration.
+* @template Z The date type used by the adapter.
+* @template E The date context type.
+* @returns A Vue plugin.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-date
+*
+* @example
+* ```ts
+* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+*
+* const app = createApp(App)
+* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+*
+* // With locale options
+* app.use(createDatePlugin({
+*   adapter: new Vuetify0DateAdapter(),
+*   locale: 'de-DE',
+* }))
+* ```
+*/
+function createDatePlugin(options) {
+	const { namespace = "v0:date", ...dateOptions } = options;
+	const [, provideDateContext, context] = createDateContext({
+		namespace,
+		...dateOptions
+	});
+	return createPlugin({
+		namespace,
+		provide: (app) => {
+			provideDateContext(context, app);
+		}
+	});
+}
+/**
+* Returns the current date context.
 *
 * Requires `createDatePlugin` to be installed with an adapter.
 *
@@ -2156,6 +2218,132 @@ function useElementIntersection(target, options = {}) {
 	};
 }
 //#endregion
+//#region src/composables/useTimer/index.ts
+/**
+* @module useTimer
+*
+* @remarks
+* A reactive timer composable with pause/resume support.
+*
+* Key features:
+* - Start/stop/pause/resume controls
+* - Reactive remaining time tracking
+* - One-shot (default) or repeating mode
+* - Automatic cleanup on scope disposal
+* - SSR-safe
+*/
+/**
+* Creates a reactive timer with pause/resume support.
+*
+* @param handler Callback invoked when the timer fires.
+* @param options Timer configuration.
+* @returns Timer controls and reactive state.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-timer
+*
+* @example
+* ```ts
+* const timer = useTimer(() => console.log('fired'), { duration: 5000 })
+*
+* timer.start()
+* timer.pause()
+* timer.resume()
+* timer.stop()
+* ```
+*/
+function useTimer(handler, options = {}) {
+	const { duration = 1e3, repeat = false } = options;
+	const remaining = shallowRef(duration);
+	const isActive = shallowRef(false);
+	const isPaused = shallowRef(false);
+	let timeoutId;
+	let trackingId;
+	let startedAt = 0;
+	let budget = duration;
+	function clearTimer() {
+		if (!/* @__PURE__ */ isUndefined(timeoutId)) {
+			globalThis.clearTimeout(timeoutId);
+			timeoutId = void 0;
+		}
+	}
+	function startTracking() {
+		stopTracking();
+		if (!IN_BROWSER) return;
+		trackingId = globalThis.setInterval(() => {
+			if (!isActive.value || isPaused.value) return;
+			const elapsed = Date.now() - startedAt;
+			remaining.value = Math.max(0, budget - elapsed);
+		}, 100);
+	}
+	function stopTracking() {
+		if (!/* @__PURE__ */ isUndefined(trackingId)) {
+			globalThis.clearInterval(trackingId);
+			trackingId = void 0;
+		}
+	}
+	function fire() {
+		clearTimer();
+		stopTracking();
+		handler();
+		if (repeat) begin(duration);
+		else {
+			isActive.value = false;
+			remaining.value = 0;
+		}
+	}
+	function begin(ms) {
+		clearTimer();
+		stopTracking();
+		budget = ms;
+		startedAt = Date.now();
+		remaining.value = ms;
+		isActive.value = true;
+		isPaused.value = false;
+		timeoutId = globalThis.setTimeout(fire, ms);
+		startTracking();
+	}
+	function start() {
+		if (duration < 0) return;
+		begin(duration);
+	}
+	function stop() {
+		clearTimer();
+		stopTracking();
+		isActive.value = false;
+		isPaused.value = false;
+		remaining.value = duration;
+	}
+	function pause() {
+		if (!isActive.value || isPaused.value) return;
+		const elapsed = Date.now() - startedAt;
+		budget = Math.max(0, budget - elapsed);
+		remaining.value = budget;
+		clearTimer();
+		stopTracking();
+		isPaused.value = true;
+	}
+	function resume() {
+		if (!isPaused.value) return;
+		isPaused.value = false;
+		startedAt = Date.now();
+		timeoutId = globalThis.setTimeout(fire, budget);
+		startTracking();
+	}
+	onScopeDispose(() => {
+		clearTimer();
+		stopTracking();
+	}, true);
+	return {
+		start,
+		stop,
+		pause,
+		resume,
+		remaining,
+		isActive,
+		isPaused
+	};
+}
+//#endregion
 //#region src/composables/useLazy/index.ts
 /**
 * @module useLazy
@@ -3886,92 +4074,94 @@ const [createNotificationsContext, createNotificationsPlugin, useNotifications]
 	}
 });
 //#endregion
-//#region src/composables/usePopover/index.ts
+//#region src/composables/useProxyModel/index.ts
 /**
-* @module usePopover
+* @module useProxyModel
 *
 * @remarks
-* Composable for native popover API behavior with CSS anchor positioning.
-* Manages open/close state, anchor styles, content attributes, and
-* bidirectional sync between reactive state and native popover events.
+* Proxy composable for bidirectional sync between a model context and v-model.
 *
 * Key features:
-* - Native popover API (showPopover/hidePopover)
-* - CSS anchor positioning (position-area, position-try-fallbacks)
-* - Toggle event sync for native state changes
-* - SSR-safe (no DOM ops outside browser)
-* - Optional external isOpen ref for v-model integration
+* - Bidirectional synchronization
+* - Array and single-value modes
+* - Automatic cleanup on scope disposal
+* - Works with any ModelContext (Selection, Slider, etc.)
+*
+* Bridges the gap between model composables and Vue's v-model.
+*/
+/**
+* Syncs a ref with a model context bidirectionally.
+*
+* @param context The model context to bind to.
+* @param model The ref to sync.
+* @param options The options for the proxy model.
+* @returns A function to stop the sync.
+*
+* @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
 *
-* Perfect for building select, combobox, tooltip, and menu components
-* without wrapping the Popover compound component.
+* @example
+* ```ts
+* import { createSelection, useProxyModel } from '@vuetify/v0'
+*
+* const model = ref()
+* const registry = createSelection({ events: true })
+* registry.onboard([
+*   { id: 'item-1', value: 'Item 1' },
+*   { id: 'item-2', value: 'Item 2' },
+* ])
+*
+* const stop = useProxyModel(registry, model)
+* ```
 */
-function usePopover(options = {}) {
-	const { id: _id, positionArea = "bottom", positionTry = "most-width bottom", showDelay = 0, hideDelay = 0 } = options;
-	const id = _id ?? /* @__PURE__ */ useId$1();
-	const isOpen = options.isOpen ?? shallowRef(false);
-	const showTimer = showDelay > 0 ? useTimer(() => {
-		isOpen.value = true;
-	}, { duration: showDelay }) : void 0;
-	const hideTimer = hideDelay > 0 ? useTimer(() => {
-		isOpen.value = false;
-	}, { duration: hideDelay }) : void 0;
-	function open() {
-		hideTimer?.stop();
-		if (showTimer) showTimer.start();
-		else isOpen.value = true;
+function useProxyModel(context, model, options) {
+	const multiple = options?.multiple ?? context.multiple ?? false;
+	const _transformIn = options?.transformIn;
+	const _transformOut = options?.transformOut;
+	function transformIn(val) {
+		const value = toValue(val);
+		return toArray(/* @__PURE__ */ isFunction(_transformIn) ? _transformIn(value) : value);
 	}
-	function close() {
-		showTimer?.stop();
-		if (hideTimer) hideTimer.start();
-		else isOpen.value = false;
+	function transformOut(val) {
+		if (/* @__PURE__ */ isFunction(_transformOut)) return _transformOut(val);
+		return toValue(multiple) ? val : val[0];
 	}
-	function toggle() {
-		if (isOpen.value) close();
-		else open();
+	const applyOptions = toValue(multiple) === toValue(context.multiple ?? false) ? void 0 : { multiple: toValue(multiple) };
+	const modelAsArray = transformIn(model);
+	const pending = new Set(modelAsArray);
+	context.apply(modelAsArray, applyOptions);
+	const selected = new Set(context.selectedValues.value);
+	for (const value of modelAsArray) if (selected.has(value)) pending.delete(value);
+	const contextWatch = watch(context.selectedValues, (val) => {
+		modelWatch.pause();
+		model.value = transformOut(Array.from(toValue(val)));
+		modelWatch.resume();
+	}, { flush: "sync" });
+	const modelWatch = watch(model, (val) => {
+		contextWatch.pause();
+		context.apply(transformIn(val), applyOptions);
+		contextWatch.resume();
+	}, {
+		flush: "sync",
+		deep: toValue(multiple)
+	});
+	function onRegister(data) {
+		const ticket = data;
+		if (!pending.has(ticket.value) || toValue(ticket.disabled)) return;
+		contextWatch.pause();
+		modelWatch.pause();
+		context.select?.(ticket.id);
+		pending.delete(ticket.value);
+		modelWatch.resume();
+		contextWatch.resume();
 	}
-	const anchorStyles = toRef(() => ({ anchorName: `--${id}` }));
-	const contentAttrs = toRef(() => ({
-		id,
-		popover: ""
-	}));
-	const contentStyles = toRef(() => ({
-		"position": "fixed",
-		"margin": "unset",
-		"inset-area": positionArea,
-		"position-area": positionArea,
-		"position-anchor": `--${id}`,
-		"position-try-fallbacks": positionTry
-	}));
-	/* v8 ignore start -- browser popover API */
-	function attach(el) {
-		onMounted(() => {
-			const element = toValue(el);
-			if (isOpen.value) element?.showPopover();
-		});
-		watch(isOpen, (value) => {
-			const element = toValue(el);
-			if (!element?.isConnected) return;
-			if (value === element.matches?.(":popover-open")) return;
-			if (value) element.showPopover?.();
-			else element.hidePopover?.();
-		});
-		useEventListener(el, "toggle", (e) => {
-			if (!toValue(el)?.isConnected) return;
-			isOpen.value = e.newState === "open";
-		});
+	context.on?.("register:ticket", onRegister);
+	function stop() {
+		contextWatch();
+		modelWatch();
+		context.off?.("register:ticket", onRegister);
 	}
-	/* v8 ignore stop */
-	return {
-		isOpen,
-		id,
-		open,
-		close,
-		toggle,
-		anchorStyles,
-		contentAttrs,
-		contentStyles,
-		attach
-	};
+	onScopeDispose(stop, true);
+	return stop;
 }
 //#endregion
 //#region src/composables/useRaf/index.ts
@@ -4331,6 +4521,10 @@ const [createRtlContext, createRtlPlugin, useRtl] = createPluginContext("v0:rtl"
 	fallback: () => createRtlFallback(),
 	setup: (context, app, { adapter = new Vuetify0RtlAdapter(), target }) => {
 		adapter.setup(app, context, target);
+	},
+	persist: (ctx) => ctx.isRtl.value,
+	restore: (ctx, saved) => {
+		ctx.isRtl.value = saved;
 	}
 });
 //#endregion
@@ -5976,261 +6170,368 @@ function useDocumentEventListener(event, listener, options) {
 	return IN_BROWSER ? useEventListener(document, event, listener, options) : () => {};
 }
 //#endregion
-//#region src/composables/useClickOutside/index.ts
+//#region src/composables/usePopover/index.ts
 /**
-* @module useClickOutside
+* @module usePopover
 *
 * @remarks
-* Detects clicks outside of specified element(s) with automatic cleanup.
+* Composable for native popover API behavior with CSS anchor positioning.
+* Manages open/close state, anchor styles, content attributes, and
+* bidirectional sync between reactive state and native popover events.
 *
 * Key features:
-* - Two-phase detection (pointerdown → pointerup) prevents drag-out false positives
-* - Touch scroll threshold ignores swipes/scrolls on mobile
-* - Capture phase listeners work with stopPropagation
-* - Pause/resume/stop functionality
-* - Optional iframe focus detection
-* - SSR-safe (no-op when not in browser)
-*
-* Common use cases: closing popovers, dropdowns, modals, and menus.
+* - Native popover API (showPopover/hidePopover)
+* - CSS anchor positioning (position-area, position-try-fallbacks)
+* - Toggle event sync for native state changes
+* - SSR-safe (no DOM ops outside browser)
+* - Optional external isOpen ref for v-model integration
 *
-* Accessibility: This composable handles pointer interactions only. For accessible
-* components (dialogs, popovers, menus), pair with `useHotkey` for Escape key
-* dismissal per WCAG/APG requirements.
+* Perfect for building select, combobox, tooltip, and menu components
+* without wrapping the Popover compound component.
 */
+function usePopover(options = {}) {
+	const { id: _id, positionArea = "bottom", positionTry = "most-width bottom", showDelay = 0, hideDelay = 0 } = options;
+	const id = _id ?? /* @__PURE__ */ useId$1();
+	const isOpen = options.isOpen ?? shallowRef(false);
+	const showTimer = showDelay > 0 ? useTimer(() => {
+		isOpen.value = true;
+	}, { duration: showDelay }) : void 0;
+	const hideTimer = hideDelay > 0 ? useTimer(() => {
+		isOpen.value = false;
+	}, { duration: hideDelay }) : void 0;
+	function open() {
+		hideTimer?.stop();
+		if (showTimer) showTimer.start();
+		else isOpen.value = true;
+	}
+	function close() {
+		showTimer?.stop();
+		if (hideTimer) hideTimer.start();
+		else isOpen.value = false;
+	}
+	function toggle() {
+		if (isOpen.value) close();
+		else open();
+	}
+	const anchorStyles = toRef(() => ({ anchorName: `--${id}` }));
+	const contentAttrs = toRef(() => ({
+		id,
+		popover: ""
+	}));
+	const contentStyles = toRef(() => ({
+		"position": "fixed",
+		"margin": "unset",
+		"inset-area": positionArea,
+		"position-area": positionArea,
+		"position-anchor": `--${id}`,
+		"position-try-fallbacks": positionTry
+	}));
+	/* v8 ignore start -- browser popover API */
+	function attach(el) {
+		onMounted(() => {
+			const element = toValue(el);
+			if (isOpen.value) element?.showPopover();
+		});
+		watch(isOpen, (value) => {
+			const element = toValue(el);
+			if (!element?.isConnected) return;
+			if (value === element.matches?.(":popover-open")) return;
+			if (value) element.showPopover?.();
+			else element.hidePopover?.();
+		});
+		useEventListener(el, "toggle", (e) => {
+			if (!toValue(el)?.isConnected) return;
+			isOpen.value = e.newState === "open";
+		});
+	}
+	/* v8 ignore stop */
+	return {
+		isOpen,
+		id,
+		open,
+		close,
+		toggle,
+		anchorStyles,
+		contentAttrs,
+		contentStyles,
+		attach
+	};
+}
+//#endregion
+//#region src/composables/createCombobox/adapters/client.ts
 /**
-* Detects clicks outside of the specified element(s).
-*
-* Uses two-phase detection (pointerdown → pointerup) to prevent false positives
-* when users drag from inside to outside an element.
-*
-* @param target Element ref(s) to detect clicks outside of. Accepts a single ref/getter or array of refs/getters.
-* @param handler Callback invoked when a click outside is detected.
-* @param options Configuration options.
-* @returns An object with methods to control the listener.
+* @module createCombobox/adapters/client
 *
-* @see https://0.vuetifyjs.com/composables/system/use-click-outside
-*
-* @example Native element ref
-* ```ts
-* const menuRef = useTemplateRef<HTMLElement>('menu')
+* @remarks
+* Default combobox adapter. Filters items client-side using createFilter.
+* Synchronous, zero debounce — items update immediately as the user types.
+*/
+var ClientAdapter = class {
+	options;
+	constructor(options = {}) {
+		this.options = options;
+	}
+	setup(context) {
+		const { mode, keys, filter: customFilter } = this.options;
+		const filter = createFilter({
+			mode,
+			keys,
+			customFilter: customFilter ? (query, item) => customFilter(String(query), item) : void 0
+		});
+		const values = toRef(() => context.items.value.map((t) => t.value));
+		const { items: filteredValues } = filter.apply(context.query, values);
+		const filtered = computed(() => {
+			if (!String(context.query.value).trim()) return new Set(context.items.value.map((t) => t.id));
+			const matchedValues = new Set(filteredValues.value);
+			const ids = /* @__PURE__ */ new Set();
+			for (const ticket of context.items.value) if (matchedValues.has(ticket.value)) ids.add(ticket.id);
+			return ids;
+		});
+		const isEmpty = toRef(() => filtered.value.size === 0);
+		return {
+			filtered,
+			isLoading: shallowRef(false),
+			isEmpty
+		};
+	}
+};
+//#endregion
+//#region src/composables/createCombobox/adapters/server.ts
+/**
+* @module createCombobox/adapters/server
 *
-* useClickOutside(menuRef, () => { isOpen.value = false })
-* ```
+* @remarks
+* Server-side combobox adapter. All filtering is performed externally.
+* The adapter is a pass-through — it shows all registered items and
+* exposes loading state for the consumer to control.
 *
-* @example Component ref (e.g., Atom)
-* ```ts
-* const atomRef = useTemplateRef<AtomExpose>('atom')
+* The consumer watches `query` via useComboboxContext() or slot props
+* and provides filtered items reactively.
+*/
+var ServerAdapter = class {
+	setup(context) {
+		const isLoading = shallowRef(false);
+		return {
+			filtered: toRef(() => {
+				return new Set(context.items.value.map((t) => t.id));
+			}),
+			isLoading,
+			isEmpty: toRef(() => context.items.value.length === 0)
+		};
+	}
+};
+//#endregion
+//#region src/composables/createCombobox/index.ts
+/**
+* @module createCombobox
 *
-* // Pass the exposed element TemplateRef via getter
-* useClickOutside(
-*   () => atomRef.value?.element,
-*   () => { isOpen.value = false }
-* )
-* ```
+* @remarks
+* Orchestrator composable that coordinates selection, popover, and virtual focus
+* for a combobox (autocomplete/typeahead) pattern. Does not extend the selection
+* chain — it composes existing primitives instead.
 *
-* @example Multiple targets
-* ```ts
-* const popoverRef = useTemplateRef<AtomExpose>('popover')
-* const anchorRef = useTemplateRef<HTMLElement>('anchor')
+* Key features:
+* - Adapter-based filtering (client-side or server-side via ClientAdapter/ServerAdapter)
+* - Single or multi-select mode
+* - Virtual focus keyboard navigation (aria-activedescendant pattern)
+* - Strict mode: reverts query to selected value on close if no match
+* - Popover-based dropdown positioning
+* - Context DI via createComboboxContext / useCombobox
+*/
+/**
+* Creates a combobox context that orchestrates selection, popover, virtual
+* focus, and adapter-based filtering into a single coordinated state.
 *
-* useClickOutside(
-*   [() => popoverRef.value?.element, anchorRef],
-*   () => { isOpen.value = false }
-* )
-* ```
+* @param options - Configuration for selection mode, filtering adapter, and behavior.
+* @returns A combobox context with all composed systems and action methods.
 *
-* @example Ignoring elements (CSS selectors or refs)
-* ```ts
-* useClickOutside(
-*  () => navRef.value?.element,
-*  () => { isOpen.value = false },
-*  { ignore: ['[data-app-bar]'] }
-* )
-* ```
+* @see https://0.vuetifyjs.com/composables/combobox/create-combobox
 *
-* @example Native dialog with bounds detection
+* @example
 * ```ts
-* // For native <dialog> elements, use bounds mode to detect backdrop clicks
-* const dialogRef = useTemplateRef<HTMLDialogElement>('dialog')
+* import { createCombobox } from '@vuetify/v0'
 *
-* useClickOutside(
-*   dialogRef,
-*   () => { dialogRef.value?.close() },
-*   { bounds: true }
-* )
+* const combobox = createCombobox({ strict: true })
+*
+* combobox.selection.register({ id: 'a', value: 'Apple' })
+* combobox.selection.register({ id: 'b', value: 'Banana' })
+*
+* combobox.open()
+* combobox.select('a') // query → 'Apple', dropdown closes
 * ```
 */
-function useClickOutside(target, handler, options = {}) {
-	const { capture = true, touchScrollThreshold = 30, detectIframe = false, ignore = [], bounds = false } = options;
-	const isPaused = shallowRef(false);
-	const isActive = toRef(() => !isPaused.value);
-	let initialTarget = null;
-	let startPosition = {
-		x: 0,
-		y: 0
-	};
-	let cleanupPointerDown;
-	let cleanupPointerUp;
-	let cleanupBlur;
-	/**
-	* Resolve target(s) to an array of HTMLElements.
-	*/
-	function getTargets() {
-		return toArray(target).map((source) => toValue(source)).filter((el) => !!el && /* @__PURE__ */ isFunction(el.contains));
-	}
-	/**
-	* Resolve ignore targets to a tuple of [selectors, elements].
-	* Called once per event to avoid repeated toValue() calls in hot path.
-	*/
-	function resolveIgnoreTargets() {
-		const ignoreTargets = toValue(ignore);
-		if (ignoreTargets.length === 0) return [[], []];
-		const selectors = [];
-		const elements = [];
-		for (const ignoreTarget of ignoreTargets) if (/* @__PURE__ */ isString(ignoreTarget)) selectors.push(ignoreTarget);
-		else {
-			const ignoreEl = toValue(ignoreTarget);
-			if (ignoreEl) elements.push(ignoreEl);
-		}
-		return [selectors, elements];
-	}
-	/**
-	* Check if an element matches resolved ignore targets.
-	*/
-	function isIgnored(el, selectors, elements) {
-		if (!el) return false;
-		for (const selector of selectors) try {
-			if (el.matches(selector) || !/* @__PURE__ */ isNull(el.closest(selector))) return true;
-		} catch {}
-		for (const ignoreEl of elements) if (ignoreEl === el || ignoreEl.contains(el)) return true;
-		return false;
-	}
-	/**
-	* Check if any element in the event path should be ignored.
-	*/
-	function shouldIgnore(path) {
-		const [selectors, elements] = resolveIgnoreTargets();
-		if (selectors.length === 0 && elements.length === 0) return false;
-		return path.some((node) => node instanceof Element && isIgnored(node, selectors, elements));
-	}
-	/**
-	* Check if the event target is outside all target elements (DOM containment).
-	*/
-	function isOutside(eventTarget) {
-		/* v8 ignore start -- defensive guards */
-		if (!eventTarget) return false;
-		if (!(eventTarget instanceof Node)) return false;
-		/* v8 ignore stop */
-		const targets = getTargets();
-		if (targets.length === 0) return false;
-		return targets.every((el) => {
-			if (/* @__PURE__ */ isNullOrUndefined(el) || !/* @__PURE__ */ isFunction(el.contains)) return false;
-			return el !== eventTarget && !el.contains(eventTarget);
-		});
-	}
-	/**
-	* Check if coordinates are outside all target elements' bounding rects.
-	*/
-	function isOutsideBounds(x, y) {
-		const targets = getTargets();
-		if (targets.length === 0) return false;
-		return targets.every((el) => {
-			const { left, right, top, bottom } = el.getBoundingClientRect();
-			return x < left || x > right || y < top || y > bottom;
-		});
-	}
-	/**
-	* Validate that the target is still in the DOM.
-	*/
-	function isValidTarget(eventTarget) {
-		if (!(eventTarget instanceof Element)) return false;
-		if (!eventTarget.isConnected) return false;
-		return true;
+function createCombobox(options = {}) {
+	const { multiple = false, mandatory = false, disabled = false, strict = false, error = false, errorMessages, adapter, displayValue = (v) => String(v ?? ""), id: _id, name, form } = options;
+	const id = _id ?? /* @__PURE__ */ useId$1();
+	const inputId = `${id}-input`;
+	const listboxId = `${id}-listbox`;
+	const descriptionId = `${id}-description`;
+	const errorId = `${id}-error`;
+	const hasDescription = shallowRef(false);
+	const hasError = shallowRef(false);
+	const errors = computed(() => {
+		const messages = toValue(errorMessages);
+		return messages ? toArray(messages) : [];
+	});
+	const isValid = toRef(() => {
+		if (toValue(error)) return false;
+		if (errors.value.length > 0) return false;
+		return null;
+	});
+	const selection = createSelection({
+		multiple,
+		mandatory,
+		disabled: toRef(() => toValue(disabled)),
+		events: true
+	});
+	const query = shallowRef("");
+	const pristine = shallowRef(true);
+	const inputEl = shallowRef(null);
+	const version = shallowRef(0);
+	selection.on("register:ticket", () => {
+		version.value++;
+	});
+	selection.on("unregister:ticket", () => {
+		version.value++;
+	});
+	const items = computed(() => {
+		version.value;
+		return [...selection.values()];
+	});
+	const { filtered, isLoading, isEmpty } = (adapter ?? new ClientAdapter()).setup({
+		query,
+		items
+	});
+	const popover = usePopover({ id });
+	const isOpen = popover.isOpen;
+	const cursor = useVirtualFocus(() => selection.values().filter((ticket) => filtered.value.has(ticket.id) && !toValue(ticket.disabled)).map((ticket) => ({
+		id: ticket.id,
+		el: () => document.querySelector(`#${CSS.escape(`${id}-option-${ticket.id}`)}`),
+		disabled: ticket.disabled
+	})), {
+		control: inputEl,
+		target: () => null,
+		orientation: "vertical"
+	});
+	const selectedId = toRef(() => selection.selectedIds.values().next().value);
+	const display = toRef(() => {
+		if (!pristine.value) return query.value;
+		if (toValue(multiple)) return query.value;
+		const ticket = /* @__PURE__ */ isUndefined(selectedId.value) ? void 0 : selection.get(selectedId.value);
+		return ticket ? displayValue(ticket.value) : "";
+	});
+	function open() {
+		if (!isOpen.value && !toValue(disabled)) isOpen.value = true;
 	}
-	/* v8 ignore start -- event handlers tested via integration, not unit */
-	/**
-	* Handle pointerdown - store initial target and position.
-	*/
-	function onPointerDown(event) {
-		if (isPaused.value) return;
-		if (event.defaultPrevented) return;
-		initialTarget = event.composedPath()[0] ?? event.target;
-		startPosition = {
-			x: event.clientX,
-			y: event.clientY
-		};
+	function close() {
+		query.value = "";
+		pristine.value = true;
+		isOpen.value = false;
 	}
-	/**
-	* Handle pointerup - check if it's an outside click.
-	*/
-	function onPointerUp(event) {
-		if (isPaused.value) return;
-		if (event.defaultPrevented) return;
-		if (!initialTarget) return;
-		const pointerdownTarget = initialTarget;
-		initialTarget = null;
-		if (!isValidTarget(pointerdownTarget)) return;
-		const path = event.composedPath();
-		const pointerupTarget = path[0] ?? event.target;
-		if (event.pointerType === "touch") {
-			const dx = Math.abs(event.clientX - startPosition.x);
-			const dy = Math.abs(event.clientY - startPosition.y);
-			if (dx >= touchScrollThreshold || dy >= touchScrollThreshold) return;
-		}
-		if ((bounds ? isOutsideBounds(startPosition.x, startPosition.y) && isOutsideBounds(event.clientX, event.clientY) : isOutside(pointerdownTarget) && isOutside(pointerupTarget)) && !shouldIgnore(path)) handler(event);
+	function toggle() {
+		if (isOpen.value) close();
+		else open();
 	}
-	/**
-	* Handle window blur - detect focus moving to iframe.
-	*/
-	function onBlur(event) {
-		if (isPaused.value) return;
-		if (event.defaultPrevented) return;
-		if (document.activeElement instanceof HTMLIFrameElement) {
-			const iframeIsOutside = getTargets().every((el) => !el.contains(document.activeElement));
-			const [selectors, elements] = resolveIgnoreTargets();
-			if (iframeIsOutside && !isIgnored(document.activeElement, selectors, elements)) handler(event);
+	function select(itemId) {
+		if (toValue(multiple)) {
+			selection.toggle(itemId);
+			query.value = "";
+			pristine.value = true;
+			cursor.highlight(itemId);
+			inputEl.value?.focus();
+		} else {
+			selection.select(itemId);
+			query.value = "";
+			pristine.value = true;
+			close();
 		}
 	}
-	/* v8 ignore stop */
-	function setup() {
-		cleanupPointerDown = useDocumentEventListener("pointerdown", onPointerDown, capture);
-		cleanupPointerUp = useDocumentEventListener("pointerup", onPointerUp, capture);
-		if (!detectIframe) return;
-		cleanupBlur = useWindowEventListener("blur", onBlur, capture);
-	}
-	function cleanup() {
-		cleanupPointerDown?.();
-		cleanupPointerUp?.();
-		cleanupBlur?.();
-		cleanupPointerDown = void 0;
-		cleanupPointerUp = void 0;
-		cleanupBlur = void 0;
-	}
-	function pause() {
-		if (isPaused.value) return;
-		isPaused.value = true;
-		initialTarget = null;
-		cleanup();
-	}
-	function resume() {
-		if (!isPaused.value) return;
-		isPaused.value = false;
-		setup();
-	}
-	function stop() {
-		isPaused.value = true;
-		initialTarget = null;
-		cleanup();
+	function clear() {
+		query.value = "";
+		pristine.value = true;
+		for (const id of Array.from(selection.selectedIds)) selection.unselect(id);
 	}
-	setup();
-	onScopeDispose(stop, true);
+	watch(isOpen, (open) => {
+		if (!open) cursor.clear();
+	});
 	return {
-		isActive: shallowReadonly(isActive),
-		isPaused: shallowReadonly(isPaused),
-		pause,
-		resume,
-		stop
+		selection,
+		popover,
+		cursor,
+		query,
+		display,
+		pristine,
+		filtered,
+		isEmpty,
+		isLoading,
+		isOpen,
+		id,
+		inputId,
+		listboxId,
+		descriptionId,
+		errorId,
+		hasDescription,
+		hasError,
+		errors,
+		isValid,
+		inputEl,
+		multiple: toValue(multiple),
+		strict,
+		disabled,
+		name,
+		form,
+		open,
+		close,
+		toggle,
+		select,
+		clear
 	};
 }
+/**
+* Creates a combobox context with dependency injection support.
+*
+* @param options - Combobox options plus an optional namespace for DI.
+* @returns A context trinity: `[useCombobox, provideCombobox, defaultCombobox]`.
+*
+* @see https://0.vuetifyjs.com/composables/combobox/create-combobox
+*
+* @example
+* ```ts
+* import { createComboboxContext } from '@vuetify/v0'
+*
+* const [useCombobox, provideCombobox, combobox] = createComboboxContext({
+*   namespace: 'my-combobox',
+*   strict: true,
+* })
+* ```
+*/
+function createComboboxContext(options = {}) {
+	const { namespace = "v0:combobox", ...rest } = options;
+	const [useCombobox, _provideCombobox] = createContext(namespace);
+	const context = createCombobox(rest);
+	function provideCombobox(_context = context, app) {
+		return _provideCombobox(_context, app);
+	}
+	return createTrinity(useCombobox, provideCombobox, context);
+}
+/**
+* Injects the current combobox context from a parent provider.
+*
+* @param namespace - DI namespace. Defaults to `'v0:combobox'`.
+* @returns The combobox context from the nearest provider.
+*
+* @see https://0.vuetifyjs.com/composables/combobox/create-combobox
+*
+* @example
+* ```ts
+* import { useCombobox } from '@vuetify/v0'
+*
+* const combobox = useCombobox()
+* combobox.query.value = 'search term'
+* ```
+*/
+function useCombobox(namespace = "v0:combobox") {
+	return useContext(namespace);
+}
 //#endregion
-export { useElementIntersection as $, useRtl as A, createQueueContext as B, createStackPlugin as C, createHydration as Ct, createRtlContext as D, createBreadcrumbs as Dt, createRtl as E, useHydration as Et, createNotifications as F, multipleOpenStrategy as G, createNested as H, createNotificationsContext as I, useMediaQuery as J, singleOpenStrategy as K, createNotificationsPlugin as L, useRovingFocus as M, useRaf as N, createRtlFallback as O, createBreadcrumbsContext as Ot, usePopover as P, useLazy as Q, useNotifications as R, createStackContext as S, createFallbackHydration as St, createSlider as T, createHydrationPlugin as Tt, createNestedContext as U, useQueue as V, useNested as W, usePrefersDark as X, usePrefersContrast as Y, usePrefersReducedMotion as Z, useStorage as _, createOverflowContext as _t, useVirtualFocus as a, createDate as at, useStep as b, useResizeObserver as bt, useVirtual as c, useDate as ct, createTimeline as d, createBreakpointsPlugin as dt, useIntersectionObserver as et, createTimelineContext as f, useBreakpoints as ft, createStoragePlugin as g, createOverflow as gt, createStorageContext as h, useProxyModel as ht, useWindowEventListener as i, useForm as it, Vuetify0RtlAdapter as j, createRtlPlugin as k, useBreadcrumbs as kt, useToggleScope as l, createBreakpoints as lt, createStorage as m, useTimer as mt, useDocumentEventListener as n, createForm as nt, createVirtual as o, createDateContext as ot, useTimeline as p, toReactive as pt, useMutationObserver as q, useEventListener as r, createFormContext as rt, createVirtualContext as s, createDatePlugin as st, useClickOutside as t, useHotkey as tt, createValidation as u, createBreakpointsContext as ut, createStep as v, useOverflow as vt, useStack as w, createHydrationContext as wt, createStack as x, toElement as xt, createStepContext as y, useElementSize as yt, createQueue as z };
+export { useMediaQuery as $, createSlider as A, createHydrationPlugin as At, createNotifications as B, createStep as C, useOverflow as Ct, createStackContext as D, createFallbackHydration as Dt, createStack as E, toElement as Et, useRtl as F, createQueueContext as G, createNotificationsPlugin as H, Vuetify0RtlAdapter as I, createNestedContext as J, useQueue as K, useRovingFocus as L, createRtlContext as M, createBreadcrumbs as Mt, createRtlFallback as N, createBreadcrumbsContext as Nt, createStackPlugin as O, createHydration as Ot, createRtlPlugin as P, useBreadcrumbs as Pt, useMutationObserver as Q, useRaf as R, useStorage as S, createOverflowContext as St, useStep as T, useResizeObserver as Tt, useNotifications as U, createNotificationsContext as V, createQueue as W, multipleOpenStrategy as X, useNested as Y, singleOpenStrategy as Z, createTimelineContext as _, createBreakpointsContext as _t, ClientAdapter as a, useElementIntersection as at, createStorageContext as b, toReactive as bt, useEventListener as c, createForm as ct, createVirtual as d, createDate as dt, usePrefersContrast as et, createVirtualContext as f, createDateContext as ft, createTimeline as g, createBreakpoints as gt, createValidation as h, useClickOutside as ht, ServerAdapter as i, useTimer as it, createRtl as j, useHydration as jt, useStack as k, createHydrationContext as kt, useWindowEventListener as l, createFormContext as lt, useToggleScope as m, useDate as mt, createComboboxContext as n, usePrefersReducedMotion as nt, usePopover as o, useIntersectionObserver as ot, useVirtual as p, createDatePlugin as pt, createNested as q, useCombobox as r, useLazy as rt, useDocumentEventListener as s, useHotkey as st, createCombobox as t, usePrefersDark as tt, useVirtualFocus as u, useForm as ut, useTimeline as v, createBreakpointsPlugin as vt, createStepContext as w, useElementSize as wt, createStoragePlugin as x, createOverflow as xt, createStorage as y, useBreakpoints as yt, useProxyModel as z };