@vuetify/v0 0.0.9 → 0.0.10

package/dist/{composables-DTW0WfTC.js → composables-TCjvMHyU.mjs}

@@ -1,9 +1,21 @@
-import { a as isNullOrUndefined, d as mergeDeep, i as isFunction, l as isString, n as isArray, o as isNumber, r as isBoolean, s as isObject, t as genId, u as isUndefined } from "./utilities-rsKHgU2m.js";
-import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, s as __LOGGER_ENABLED__, t as IN_BROWSER } from "./globals-Cfd1Dr_o.js";
+import { a as isNull, c as isObject, d as isUndefined, f as mergeDeep, i as isFunction, n as isArray, o as isNullOrUndefined, r as isBoolean, s as isNumber, t as genId, u as isString } from "./utilities-C26nB74O.mjs";
+import { a as SUPPORTS_OBSERVER, i as SUPPORTS_MUTATION_OBSERVER, n as SUPPORTS_INTERSECTION_OBSERVER, s as __LOGGER_ENABLED__, t as IN_BROWSER } from "./globals-y0mJ6Eg7.mjs";
 import { computed, getCurrentInstance, getCurrentScope, inject, isRef, onMounted, onScopeDispose, onUnmounted, provide, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch } from "vue";
 
 //#region src/composables/createContext/index.ts
 /**
+* @module createContext
+*
+* @see https://0.vuetifyjs.com/composables/foundation/create-context
+*
+* @remarks
+* Factory for creating type-safe Vue dependency injection contexts.
+*
+* Provides a wrapper around Vue's provide/inject that throws errors when context is not found,
+* eliminating silent failures and improving developer experience. Supports both app-level and
+* component-level provision.
+*/
+/**
 * Injects a context provided by an ancestor component.
 *
 * @param key The key of the context to inject.
@@ -130,7 +142,7 @@ function createPlugin(options) {
 /**
 * Creates a new trinity for a context composable and its provider.
 *
-* @param createContext The function that retrieves/uses the context (typically named `useContext`).
+* @param useContext The function that retrieves/uses the context (typically named `useContext`).
 * @param provideContext The function that provides the context to descendants.
 * @param context The default context instance to use when no custom context is provided.
 * @template Z The type of the context.
@@ -166,9 +178,9 @@ function createPlugin(options) {
 * }
 * ```
 */
-function createTrinity(createContext$1, provideContext$1, context) {
+function createTrinity(useContext$1, provideContext$1, context) {
 	return [
-		createContext$1,
+		useContext$1,
 		(_context = context, app) => provideContext$1(_context, app),
 		context
 	];
@@ -177,6 +189,16 @@ function createTrinity(createContext$1, provideContext$1, context) {
 //#endregion
 //#region src/composables/toArray/index.ts
 /**
+* @module toArray
+*
+* @remarks
+* Utility function to normalize single values and arrays into arrays.
+*
+* Converts single values into single-element arrays, passes arrays through unchanged,
+* and handles null/undefined by returning empty arrays. Perfect for functions that
+* accept both single values and arrays as input (e.g., ID | ID[]).
+*/
+/**
 * Converts a value to an array.
 *
 * @param value The value to convert.
@@ -202,6 +224,21 @@ function toArray(value) {
 //#endregion
 //#region src/composables/toReactive/index.ts
 /**
+* @module toReactive
+*
+* @remarks
+* Utility function to convert values and refs into reactive proxies with ref unwrapping.
+*
+* Key features:
+* - Automatic ref unwrapping
+* - Deep reactive proxying
+* - Map and Set support with ref unwrapping
+* - Nested object/array reactivity
+* - Type preservation
+*
+* Perfect for creating reactive versions of plain objects while automatically unwrapping refs.
+*/
+/**
 * Converts a `MaybeRef` to a `UnwrapNestedRefs`.
 *
 * @param objectRef The object to convert.
@@ -322,6 +359,23 @@ function toReactive(objectRef) {
 //#endregion
 //#region src/composables/useHydration/index.ts
 /**
+* @module useHydration
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+*
+* @remarks
+* SSR hydration state management composable.
+*
+* Key features:
+* - Hydration state detection (browser vs SSR)
+* - Root component detection
+* - Readonly hydration state refs
+* - Plugin installation support
+* - Perfect for hydration-safe rendering
+*
+* Essential for composables that need to behave differently during SSR vs client-side.
+*/
+/**
 * Creates a new hydration instance.
 *
 * @returns A new hydration instance.
@@ -446,6 +500,24 @@ function useHydration(namespace = "v0:hydration") {
 //#endregion
 //#region src/composables/useBreakpoints/index.ts
 /**
+* @module useBreakpoints
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
+*
+* @remarks
+* Responsive breakpoint detection composable with window resize handling.
+*
+* Key features:
+* - Window matchMedia integration
+* - Six built-in breakpoints (xs, sm, md, lg, xl, xxl)
+* - Automatic resize listener with cleanup
+* - SSR-safe (checks IN_BROWSER)
+* - Hydration-aware
+* - Custom breakpoint configuration
+*
+* Perfect for responsive layouts and conditional rendering based on screen size.
+*/
+/**
 * Creates default breakpoint configuration.
 *
 * @returns The default breakpoint configuration object.
@@ -693,6 +765,21 @@ function useBreakpoints(namespace = "v0:breakpoints") {
 //#endregion
 //#region src/composables/useEventListener/index.ts
 /**
+* @module useEventListener
+*
+* @remarks
+* Event listener composable with automatic cleanup on scope disposal.
+*
+* Key features:
+* - Supports Window, Document, and HTMLElement targets
+* - Reactive targets, events, and listeners
+* - Event options support (capture, passive, once)
+* - Automatic removeEventListener on unmount
+* - Multiple overloads for type safety
+*
+* Perfect for safely managing event listeners in Vue components.
+*/
+/**
 * Attaches an event listener to a target.
 *
 * @param target The target to attach the event listener to.
@@ -910,6 +997,23 @@ var Vuetify0LoggerAdapter = class {
 //#endregion
 //#region src/composables/useLogger/index.ts
 /**
+* @module useLogger
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-logger
+*
+* @remarks
+* Logging composable with adapter pattern supporting console, consola, and pino.
+*
+* Key features:
+* - Multiple log levels (trace, debug, info, warn, error, fatal)
+* - Adapter pattern for console/consola/pino integration
+* - Enable/disable logging
+* - Fallback logger for undefined loggers
+* - Context logging support
+*
+* Uses adapter pattern to abstract logging implementation.
+*/
+/**
 * Creates a new logger instance.
 *
 * @param options The options for the logger instance.
@@ -1086,7 +1190,7 @@ function createLoggerPlugin(_options = {}) {
 			provideLoggerContext(context, app);
 		},
 		setup: (_app) => {
-			if (process.env.NODE_ENV !== "production" && IN_BROWSER) window.__v0Logger__ = context;
+			if (__DEV__ && IN_BROWSER) window.__v0Logger__ = context;
 		}
 	});
 }
@@ -1124,6 +1228,21 @@ function useLogger(namespace = "v0:logger") {
 //#endregion
 //#region src/composables/useRegistry/index.ts
 /**
+* @module useRegistry
+*
+* @remarks
+* A foundational composable for managing collections of items (tickets) with:
+* - Unique ID-based access
+* - Index-based ordering
+* - Value-based reverse lookup
+* - Automatic reindexing
+* - Optional event emission
+* - Performance-optimized caching
+*
+* The registry serves as the base for many other composables in the system,
+* including useSelection, useForm, useTimeline, and more.
+*/
+/**
 * Creates a new registry instance.
 *
 * @param options The options for the registry instance.
@@ -1249,14 +1368,14 @@ function useRegistry(options) {
 	}
 	function values() {
 		const cached = cache.get("values");
-		if (cached != void 0) return cached;
+		if (!/* @__PURE__ */ isUndefined(cached)) return cached;
 		const values$1 = Array.from(collection.values());
 		cache.set("values", values$1);
 		return values$1;
 	}
 	function entries() {
 		const cached = cache.get("entries");
-		if (cached != void 0) return cached;
+		if (!/* @__PURE__ */ isUndefined(cached)) return cached;
 		const entries$1 = Array.from(collection.entries());
 		cache.set("entries", entries$1);
 		return entries$1;
@@ -1274,6 +1393,7 @@ function useRegistry(options) {
 	function reindex() {
 		if (catalog.size > 0) catalog.clear();
 		if (directory.size > 0) directory.clear();
+		invalidate();
 		let index = 0;
 		for (const ticket of values()) {
 			if (ticket.index !== index) {
@@ -1284,7 +1404,7 @@ function useRegistry(options) {
 			assign(ticket.value, ticket.id);
 			index++;
 		}
-		invalidate();
+		emit("reindex:registry");
 	}
 	function register(registration = {}) {
 		const size = collection.size;
@@ -1293,9 +1413,10 @@ function useRegistry(options) {
 			logger.warn(`Ticket with id "${id}" already exists in the registry. Skipping registration.`);
 			return get(id);
 		}
+		const valueIsUndefined = /* @__PURE__ */ isUndefined(registration.value);
 		const index = registration.index ?? size;
-		const value = registration.value === void 0 ? index : registration.value;
-		const valueIsIndex = registration.value === void 0;
+		const value = valueIsUndefined ? index : registration.value;
+		const valueIsIndex = valueIsUndefined;
 		const ticket = {
 			...registration,
 			id,
@@ -1403,6 +1524,21 @@ function createRegistryContext(_options) {
 //#endregion
 //#region src/composables/useSelection/index.ts
 /**
+* @module useSelection
+*
+* @remarks
+* Base composable for managing selected items in a collection with Set-based tracking.
+*
+* Key features:
+* - Set-based selectedIds for O(1) selection checks
+* - Mandatory selection mode (prevents deselecting last item)
+* - Auto-enrollment option (selects non-disabled items on register)
+* - Disabled item filtering
+* - Computed selectedItems and selectedValues Sets
+*
+* Extends useRegistry and serves as the base for useSingle, useGroup, useStep, and useFeatures.
+*/
+/**
 * Creates a new selection instance for managing multiple selected items.
 *
 * Extends `useRegistry` with selection tracking via a reactive `Set` of selected IDs.
@@ -1448,11 +1584,10 @@ function createRegistryContext(_options) {
 * console.log(Array.from(selection.selectedValues.value)) // ['Item 1', 'Item 3']
 * ```
 */
-function createSelection(options) {
+function createSelection(_options = {}) {
+	const { disabled = false, enroll = false, mandatory = false, multiple = false,...options } = _options;
 	const registry = useRegistry(options);
 	const selectedIds = shallowReactive(/* @__PURE__ */ new Set());
-	const enroll = options?.enroll ?? false;
-	const mandatory = options?.mandatory ?? false;
 	const selectedItems = computed(() => {
 		return new Set(Array.from(selectedIds).map((id) => registry.get(id)));
 	});
@@ -1460,7 +1595,7 @@ function createSelection(options) {
 		return new Set(Array.from(selectedItems.value).map((item) => item?.value));
 	});
 	function seek(direction = "first", from) {
-		return registry.seek(direction, from, (ticket) => !ticket.disabled);
+		return registry.seek(direction, from, (ticket) => !toValue(ticket.disabled));
 	}
 	function mandate() {
 		if (!mandatory || registry.size === 0 || selectedIds.size > 0) return;
@@ -1469,7 +1604,8 @@ function createSelection(options) {
 	}
 	function select(id) {
 		const item = registry.get(id);
-		if (!item || item.disabled) return;
+		if (!item || toValue(item.disabled)) return;
+		if (!multiple) selectedIds.clear();
 		selectedIds.add(id);
 	}
 	function unselect(id) {
@@ -1477,7 +1613,7 @@ function createSelection(options) {
 		selectedIds.delete(id);
 	}
 	function toggle(id) {
-		if (selectedIds.has(id)) unselect(id);
+		if (selected(id)) unselect(id);
 		else select(id);
 	}
 	function selected(id) {
@@ -1489,13 +1625,13 @@ function createSelection(options) {
 			disabled: false,
 			...registration,
 			id,
-			isSelected: toRef(() => selectedIds.has(id)),
+			isSelected: toRef(() => selected(id)),
 			select: () => select(id),
 			unselect: () => unselect(id),
 			toggle: () => toggle(id)
 		};
 		const ticket = registry.register(item);
-		if (enroll && !item.disabled) selectedIds.add(ticket.id);
+		if (enroll && !toValue(item.disabled)) selectedIds.add(ticket.id);
 		if (mandatory === "force") mandate();
 		return ticket;
 	}
@@ -1510,6 +1646,7 @@ function createSelection(options) {
 	}
 	return {
 		...registry,
+		disabled,
 		selectedIds,
 		selectedItems,
 		selectedValues,
@@ -1591,6 +1728,20 @@ function useSelection(namespace = "v0:selection") {
 //#endregion
 //#region src/composables/useGroup/index.ts
 /**
+* @module useGroup
+*
+* @remarks
+* Multi-selection composable that extends useSelection with batch operation support.
+*
+* Key features:
+* - Batch operations (select/unselect/toggle accept ID | ID[])
+* - selectedIndexes computed Set for position-based tracking
+* - Perfect for checkboxes, multi-select dropdowns, filter panels
+*
+* Inheritance chain: useRegistry → useSelection → useGroup
+* Extended by: useFeatures
+*/
+/**
 * Creates a new group instance with batch selection operations.
 *
 * Extends `createSelection` to support selecting, unselecting, and toggling multiple items
@@ -1647,8 +1798,13 @@ function useSelection(namespace = "v0:selection") {
 * console.log(checkboxes.selectedIds) // Set { 'option-b', 'option-c' }
 * ```
 */
-function createGroup(options) {
-	const registry = createSelection(options);
+function createGroup(_options = {}) {
+	const { mandatory = false, multiple = true,...options } = _options;
+	const registry = createSelection({
+		...options,
+		mandatory,
+		multiple
+	});
 	const selectedIndexes = computed(() => {
 		return new Set(Array.from(registry.selectedItems.value).map((item) => item?.index));
 	});
@@ -1735,6 +1891,23 @@ function useGroup(namespace) {
 //#endregion
 //#region src/composables/useTokens/index.ts
 /**
+* @module useTokens
+*
+* @see https://0.vuetifyjs.com/composables/registration/use-tokens
+*
+* @remarks
+* Design token registry with alias resolution and W3C Design Tokens format support.
+*
+* Key features:
+* - Alias resolution with circular reference detection
+* - Nested token flattening with dot notation
+* - W3C Design Tokens format ($value, $type, $description, $extensions)
+* - Path-based resolution (e.g., {colors}.blue.500)
+* - Resolution caching for performance (~28,590 ops/sec)
+*
+* Used by useTheme, useLocale, and useFeatures for token-based configuration.
+*/
+/**
 * Creates a new token instance.
 *
 * @param tokens The tokens to use.
@@ -1974,6 +2147,24 @@ function flatten(tokens, prefix = "", flat = false) {
 //#endregion
 //#region src/composables/useFeatures/index.ts
 /**
+* @module useFeatures
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-features
+*
+* @remarks
+* Feature flag system with boolean and token-based features.
+*
+* Key features:
+* - Boolean features (true/false activation)
+* - Token features with $variation support
+* - Auto-selection of enabled features
+* - Multi-select support for feature combinations
+* - Perfect for A/B testing, progressive rollout, feature toggles
+*
+* Inheritance chain: useRegistry → createSelection → createGroup → createFeatures
+* Integrates with useTokens for token-based features.
+*/
+/**
 * Creates a new features instance.
 *
 * @param options The options for the features instance.
@@ -2133,6 +2324,21 @@ function useFeatures(namespace = "v0:features") {
 
 //#endregion
 //#region src/composables/useFilter/index.ts
+/**
+* @module useFilter
+*
+* @remarks
+* Reactive array filtering composable with multiple filter modes.
+*
+* Key features:
+* - Four filter modes: some, every, union, intersection
+* - Case-insensitive filtering
+* - Custom filter functions
+* - Reactive updates
+* - Perfect for search, multi-criteria filtering
+*
+* Filters arrays based on query strings with configurable matching strategies.
+*/
 function defaultFilter(query, item, keys, mode = "some") {
 	const queries = Array.isArray(query) ? query.map((q) => String(q).toLowerCase()) : [String(query).toLowerCase()];
 	function match(value, q) {
@@ -2190,6 +2396,22 @@ function useFilter(query, items, options = {}) {
 //#endregion
 //#region src/composables/useForm/index.ts
 /**
+* @module useForm
+*
+* @remarks
+* Form validation composable with async rule support and multiple validation modes.
+*
+* Key features:
+* - Sync and async validation rules
+* - Multiple validation modes (submit, change, combined)
+* - Tri-state isValid (null/true/false)
+* - isPristine tracking
+* - Silent validation mode
+* - Form-level validation and reset
+*
+* Each field is registered with validation rules and tracks its own state independently.
+*/
+/**
 * Creates a new form instance.
 *
 * @param options The options for the form instance.
@@ -2391,6 +2613,22 @@ function useForm(namespace = "v0:form") {
 //#endregion
 //#region src/composables/useIntersectionObserver/index.ts
 /**
+* @module useIntersectionObserver
+*
+* @remarks
+* IntersectionObserver composable with lifecycle management.
+*
+* Key features:
+* - IntersectionObserver API wrapper
+* - Pause/resume/stop functionality
+* - Automatic cleanup on unmount
+* - SSR-safe (checks SUPPORTS_INTERSECTION_OBSERVER)
+* - Hydration-aware
+* - Immediate callback option
+*
+* Perfect for lazy loading, infinite scroll, and visibility detection.
+*/
+/**
 * A composable that uses the Intersection Observer API to detect when an element
 * is visible in the viewport.
 *
@@ -2555,6 +2793,20 @@ function useElementIntersection(target, options = {}) {
 //#endregion
 //#region src/composables/useKeydown/index.ts
 /**
+* @module useKeydown
+*
+* @remarks
+* Keydown event listener composable with key filtering.
+*
+* Key features:
+* - Key-specific event handling
+* - preventDefault and stopPropagation options
+* - Automatic cleanup on scope disposal
+* - Auto-starts when in component scope
+*
+* Simplified wrapper around useEventListener for keyboard interactions.
+*/
+/**
 * A composable that adds a keydown event listener to the document.
 *
 * @param handlers The key handlers to add.
@@ -2602,6 +2854,19 @@ function useKeydown(handlers) {
 //#endregion
 //#region src/composables/useSingle/index.ts
 /**
+* @module useSingle
+*
+* @remarks
+* Single-selection composable that extends useSelection to enforce only one selected item.
+*
+* Key features:
+* - Auto-clears previous selection when selecting new item
+* - Singular computed properties (selectedId, selectedItem, selectedIndex, selectedValue)
+* - Perfect for tabs, radio buttons, theme selectors
+*
+* Inheritance chain: useRegistry → useSelection → useSingle
+*/
+/**
 * Creates a new single selection instance that enforces only one selected item at a time.
 *
 * Extends `createSelection` by automatically clearing previous selections when a new item is selected.
@@ -2651,26 +2916,24 @@ function useKeydown(handlers) {
 * console.log(tabs.selectedIds.size) // 1 (always enforces single selection)
 * ```
 */
-function createSingle(options) {
-	const registry = createSelection(options);
-	const mandatory = options?.mandatory ?? false;
+function createSingle(_options = {}) {
+	const { mandatory = false, multiple = false,...options } = _options;
+	const registry = createSelection({
+		...options,
+		mandatory,
+		multiple
+	});
 	const selectedId = computed(() => registry.selectedIds.values().next().value);
 	const selectedItem = computed(() => registry.selectedItems.value.values().next().value);
 	const selectedIndex = computed(() => selectedItem.value?.index ?? -1);
 	const selectedValue = computed(() => selectedItem.value?.value);
-	function select(id) {
-		const item = registry.get(id);
-		if (!item || item.disabled) return;
-		registry.selectedIds.clear();
-		registry.select(id);
-	}
 	function unselect(id) {
 		if (mandatory && registry.selectedIds.size === 1) return;
 		registry.selectedIds.delete(id);
 	}
 	function toggle(id) {
 		if (registry.selectedIds.has(id)) unselect(id);
-		else select(id);
+		else registry.select(id);
 	}
 	return {
 		...registry,
@@ -2678,7 +2941,6 @@ function createSingle(options) {
 		selectedItem,
 		selectedIndex,
 		selectedValue,
-		select,
 		unselect,
 		toggle,
 		get size() {
@@ -2783,6 +3045,21 @@ var Vuetify0LocaleAdapter = class {
 //#endregion
 //#region src/composables/useLocale/index.ts
 /**
+* @module useLocale
+*
+* @remarks
+* Internationalization (i18n) composable with adapter pattern for message translation.
+*
+* Key features:
+* - Locale selection with createSingle
+* - Token-based message storage with useTokens
+* - Numbered and named placeholder support ({0}, {name})
+* - Number formatting with Intl.NumberFormat
+* - Adapter pattern for integration with i18n providers
+*
+* Integrates with createSingle for locale selection and useTokens for message resolution.
+*/
+/**
 * Creates a new locale instance.
 *
 * @param options The options for the locale instance.
@@ -2919,6 +3196,22 @@ function useLocale(namespace = "v0:locale") {
 //#endregion
 //#region src/composables/useMutationObserver/index.ts
 /**
+* @module useMutationObserver
+*
+* @remarks
+* MutationObserver composable with lifecycle management.
+*
+* Key features:
+* - MutationObserver API wrapper
+* - Pause/resume/stop functionality
+* - Automatic cleanup on unmount
+* - SSR-safe (checks SUPPORTS_MUTATION_OBSERVER)
+* - Hydration-aware
+* - Configurable observation options (childList, attributes, characterData, etc.)
+*
+* Perfect for detecting DOM changes and responding to mutations.
+*/
+/**
 * A composable that uses the Mutation Observer API to detect changes in the DOM.
 *
 * @param target The element to observe.
@@ -3061,6 +3354,23 @@ var Vuetify0PermissionAdapter = class extends PermissionAdapter {
 //#endregion
 //#region src/composables/usePermissions/index.ts
 /**
+* @module usePermissions
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+*
+* @remarks
+* Permission management composable with support for RBAC and ABAC patterns.
+*
+* Key features:
+* - Role-Based Access Control (RBAC) support
+* - Attribute-Based Access Control (ABAC) with context
+* - Functional permission conditions
+* - Token-based permission storage
+* - Adapter pattern for custom permission systems
+*
+* Built on useTokens for flexible permission configuration.
+*/
+/**
 * Creates a new permissions instance.
 *
 * @param options The options for the permissions instance.
@@ -3207,15 +3517,27 @@ function usePermissions(namespace = "v0:permissions") {
 //#endregion
 //#region src/composables/useProxyModel/index.ts
 /**
-* Creates a proxy model that can be used to bind to a selection.
+* @module useProxyModel
+*
+* @remarks
+* Proxy composable for bidirectional sync between selection registry and v-model.
+*
+* Key features:
+* - Bidirectional synchronization
+* - Array and single-value modes
+* - Automatic cleanup on scope disposal
+* - Perfect for form controls with selection backing
+*
+* Bridges the gap between selection composables and Vue's v-model.
+*/
+/**
+* Syncs a ref with a selection registry bidirectionally.
 *
 * @param registry The selection registry to bind to.
-* @param initial The initial value of the model.
+* @param model The ref to sync.
 * @param options The options for the proxy model.
-* @param transformIn A function to transform the value before setting it.
-* @param transformOut A function to transform the value before getting it.
 * @template Z The type of the selection ticket.
-* @returns A proxy model that can be used to bind to a selection.
+* @returns A function to stop the sync.
 *
 * @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
 *
@@ -3223,50 +3545,55 @@ function usePermissions(namespace = "v0:permissions") {
 * ```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 model = useProxyModel(registry, 'Item 1')
+* const stop = useProxyModel(registry, model)
 * ```
 */
-function useProxyModel(registry, _initial, options, _transformIn, _transformOut) {
-	const reactivity = options?.deep ? ref : shallowRef;
-	const initial = unref(_initial);
-	const internal = reactivity(initial ? toArray(initial) : []);
-	const isModelArray = /* @__PURE__ */ isArray(initial);
+function useProxyModel(registry, model, options) {
+	const multiple = options?.multiple ?? false;
+	const _transformIn = options?.transformIn;
+	const _transformOut = options?.transformOut;
 	function transformIn(val) {
-		return /* @__PURE__ */ isFunction(_transformIn) ? _transformIn(val) : toArray(val);
+		const value = toValue(val);
+		return toArray(/* @__PURE__ */ isFunction(_transformIn) ? _transformIn(value) : value);
 	}
 	function transformOut(val) {
 		if (/* @__PURE__ */ isFunction(_transformOut)) return _transformOut(val);
-		return isModelArray ? val : val[0];
-	}
-	const model = computed({
-		get() {
-			return transformOut(internal.value);
-		},
-		set(val) {
-			internal.value = transformIn(val);
+		return multiple ? val : val[0];
+	}
+	const modelAsArray = transformIn(model);
+	const pending = new Set(modelAsArray);
+	for (const value of modelAsArray) {
+		const ids = registry.browse(value);
+		if (/* @__PURE__ */ isArray(ids)) {
+			for (const id of ids) registry.select(id);
+			pending.delete(value);
+		} else if (ids) {
+			registry.select(ids);
+			pending.delete(value);
 		}
-	});
-	const registryWatcher = watch(registry.selectedValues, (val) => {
-		modelWatcher.pause();
-		model.value = Array.from(toValue(val));
-		modelWatcher.resume();
-	});
-	const modelWatcher = watch(model, (val) => {
+	}
+	const registryWatch = watch(registry.selectedValues, (val) => {
+		modelWatch.pause();
+		model.value = transformOut(Array.from(toValue(val)));
+		modelWatch.resume();
+	}, { flush: "sync" });
+	const modelWatch = watch(model, (val) => {
+		registryWatch.pause();
 		const currentIds = new Set(toValue(registry.selectedIds));
 		const targetIds = /* @__PURE__ */ new Set();
-		for (const value of toArray(val)) {
+		for (const value of transformIn(val)) {
 			const ids = registry.browse(value);
 			if (/* @__PURE__ */ isArray(ids)) for (const single of ids) targetIds.add(single);
 			else if (ids) targetIds.add(ids);
 		}
-		registryWatcher.pause();
-		if (isModelArray) {
+		if (multiple) {
 			for (const id of currentIds.difference(targetIds)) registry.selectedIds.delete(id);
 			for (const id of targetIds.difference(currentIds)) registry.selectedIds.add(id);
 		} else {
@@ -3275,55 +3602,48 @@ function useProxyModel(registry, _initial, options, _transformIn, _transformOut)
 			if (last !== void 0) registry.unselect(last);
 			if (next !== void 0) registry.select(next);
 		}
-		registryWatcher.resume();
+		registryWatch.resume();
+	}, {
+		flush: "sync",
+		deep: multiple
 	});
 	function onRegister(ticket) {
-		if (!internal.value.includes(ticket.value)) return;
-		registryWatcher.pause();
-		modelWatcher.pause();
+		if (!pending.has(ticket.value) || ticket.disabled) return;
+		registryWatch.pause();
+		modelWatch.pause();
 		registry.select(ticket.id);
-		registryWatcher.resume();
-		modelWatcher.resume();
-	}
-	function onUnregister(ticket) {
-		if (!internal.value.includes(ticket.value)) return;
-		registryWatcher.pause();
-		modelWatcher.pause();
-		registry.unselect(ticket.id);
-		registryWatcher.resume();
-		modelWatcher.resume();
-	}
-	function onUpdate(ticket) {
-		const hasValue = internal.value.includes(ticket.value);
-		const isSelected = toValue(registry.selectedIds).has(ticket.id);
-		if (!hasValue && isSelected) onUnregister(ticket);
-		else if (hasValue && !isSelected) onRegister(ticket);
-	}
-	function onClear() {
-		registryWatcher.pause();
-		modelWatcher.pause();
-		registry.selectedIds.clear();
-		registryWatcher.resume();
-		modelWatcher.resume();
+		pending.delete(ticket.value);
+		modelWatch.resume();
+		registryWatch.resume();
 	}
 	registry.on("register:ticket", onRegister);
-	registry.on("unregister:ticket", onUnregister);
-	registry.on("update:ticket", onUpdate);
-	registry.on("clear:registry", onClear);
-	onScopeDispose(() => {
-		registryWatcher();
-		modelWatcher();
-		registry.off("register:item", onRegister);
-		registry.off("unregister:ticket", onUnregister);
-		registry.off("update:ticket", onUpdate);
-		registry.off("clear:registry", onClear);
-	}, true);
-	return model;
+	function stop() {
+		registryWatch();
+		modelWatch();
+		registry.off("register:ticket", onRegister);
+	}
+	onScopeDispose(stop, true);
+	return stop;
 }
 
 //#endregion
 //#region src/composables/useProxyRegistry/index.ts
 /**
+* @module useProxyRegistry
+*
+* @remarks
+* Proxy composable for reactive registry keys, values, entries, and size.
+*
+* Key features:
+* - Reactive proxy for registry data
+* - Deep or shallow reactivity options
+* - Event-based updates
+* - Automatic cleanup on scope disposal
+* - Transforms Map-based registry into reactive refs
+*
+* Perfect for exposing registry data as reactive computed properties.
+*/
+/**
 * Creates a proxy registry that provides reactive objects for registry data.
 *
 * @param registry The registry instance to proxy.
@@ -3373,6 +3693,21 @@ function useProxyRegistry(registry, options) {
 //#endregion
 //#region src/composables/useQueue/index.ts
 /**
+* @module useQueue
+*
+* @remarks
+* A queue composable for managing time-based collections with:
+* - Automatic timeout-based removal
+* - Pause/resume functionality
+* - FIFO (First In, First Out) ordering
+* - Manual dismissal support
+* - Queue progression management
+*
+* Built on top of useRegistry, the queue automatically manages timeouts for tickets,
+* ensuring only the first ticket in the queue is active at any time. When an ticket
+* expires or is removed, the next ticket in the queue automatically becomes active.
+*/
+/**
 * Creates a new queue instance
 *
 * @param options The options for the queue instance
@@ -3538,6 +3873,22 @@ function useQueue(namespace = "v0:queue") {
 //#endregion
 //#region src/composables/useResizeObserver/index.ts
 /**
+* @module useResizeObserver
+*
+* @remarks
+* ResizeObserver composable with lifecycle management.
+*
+* Key features:
+* - ResizeObserver API wrapper
+* - Pause/resume/stop functionality
+* - Automatic cleanup on unmount
+* - SSR-safe (checks SUPPORTS_OBSERVER)
+* - Hydration-aware
+* - Box model options (content-box/border-box)
+*
+* Perfect for responsive components and size-based rendering.
+*/
+/**
 * A composable that uses the Resize Observer API to detect when an element's
 * size changes.
 *
@@ -3689,10 +4040,24 @@ function useElementSize(target) {
 //#endregion
 //#region src/composables/useStep/index.ts
 /**
-* Creates a new step instance with circular navigation through items.
+* @module useStep
+*
+* @remarks
+* Navigation composable that extends useSingle with first/last/next/prev/step methods.
+*
+* Key features:
+* - Configurable circular or bounded navigation
+* - Automatic disabled item skipping
+* - Arbitrary step counts (positive/negative)
+* - Perfect for wizards, carousels, pagination, onboarding flows
+*
+* Inheritance chain: useRegistry → useSelection → useSingle → useStep
+*/
+/**
+* Creates a new step instance with navigation through items.
 *
 * Extends `createSingle` with `first()`, `last()`, `next()`, `prev()`, and `step(count)` methods
-* for sequential navigation. Automatically wraps around at boundaries (circular navigation).
+* for sequential navigation. Supports both circular (wrapping) and bounded (stopping at edges) modes.
 *
 * @param options The options for the step instance.
 * @template Z The type of the step ticket.
@@ -3701,7 +4066,7 @@ function useElementSize(target) {
 *
 * @remarks
 * **Key Features:**
-* - **Circular Navigation**: Wrapping at start/end boundaries
+* - **Configurable Navigation**: `circular: true` for wrapping, `false` for bounded (default: false)
 * - **Disabled Item Skipping**: Automatically skips disabled items during navigation
 * - **Bidirectional**: Forward (`next`, positive `step`) and backward (`prev`, negative `step`)
 * - **Safe Edge Cases**: Handles empty registries and all-disabled scenarios gracefully
@@ -3709,15 +4074,20 @@ function useElementSize(target) {
 * **Navigation Methods:**
 * - `first()`: Select first non-disabled item
 * - `last()`: Select last non-disabled item
-* - `next()`: Move to next item (wraps to first)
-* - `prev()`: Move to previous item (wraps to last)
+* - `next()`: Move to next item (wraps if circular, stops at end if bounded)
+* - `prev()`: Move to previous item (wraps if circular, stops at start if bounded)
 * - `step(count)`: Move by `count` positions (negative for backward)
 *
-* **Wrapping Behavior:**
-* - Uses modulo arithmetic for circular wrapping: `((index % length) + length) % length`
+* **Circular Mode (`circular: true`):**
+* - Uses modulo arithmetic for wrapping: `((index % length) + length) % length`
 * - Works correctly with negative indexes and large step counts
-* - Continues searching if landing on disabled items (up to registry length iterations)
-* - Returns early if all items are disabled to prevent infinite loops
+* - Perfect for carousels, theme switchers, infinite scrolling
+*
+* **Bounded Mode (`circular: false`, default):**
+* - Navigation stops at boundaries (no wrapping)
+* - `next()` on last item does nothing
+* - `prev()` on first item does nothing
+* - Perfect for pagination, wizards with explicit completion, forms
 *
 * **Inheritance Chain:**
 * `useRegistry` → `createSelection` → `createSingle` → `createStep`
@@ -3728,26 +4098,31 @@ function useElementSize(target) {
 * ```ts
 * import { createStep } from '@vuetify/v0'
 *
-* const wizard = createStep({ mandatory: true })
-*
-* wizard.onboard([
-*   { id: 'account', value: 'Account Info' },
-*   { id: 'payment', value: 'Payment Details' },
-*   { id: 'review', value: 'Review', disabled: true },
-*   { id: 'confirm', value: 'Confirmation' },
+* // Bounded navigation (default) - for pagination
+* const pagination = createStep({ circular: false })
+* pagination.onboard([
+*   { id: 'page-1', value: 1 },
+*   { id: 'page-2', value: 2 },
+*   { id: 'page-3', value: 3 },
 * ])
-*
-* wizard.first() // Select 'account'
-* console.log(wizard.selectedId.value) // 'account'
-*
-* wizard.next() // Move to 'payment'
-* wizard.next() // Skip disabled 'review', move to 'confirm'
-* wizard.next() // Wrap around to 'account'
-*
-* wizard.step(-2) // Go back 2 steps (wraps correctly)
+* pagination.first() // Select page 1
+* pagination.prev() // Does nothing (already at first)
+* pagination.next() // Select page 2
+*
+* // Circular navigation - for carousels
+* const carousel = createStep({ circular: true })
+* carousel.onboard([
+*   { id: 'slide-1', value: 'First' },
+*   { id: 'slide-2', value: 'Second' },
+*   { id: 'slide-3', value: 'Third' },
+* ])
+* carousel.first()
+* carousel.prev() // Wraps to 'slide-3'
+* carousel.next() // Wraps to 'slide-1'
 * ```
 */
-function createStep(options) {
+function createStep(_options = {}) {
+	const { circular = false,...options } = _options;
 	const registry = createSingle(options);
 	function first() {
 		const ticket = registry.seek("first");
@@ -3769,12 +4144,15 @@ function createStep(options) {
 	function step(count = 1) {
 		const length = registry.size;
 		if (!length) return;
+		const currentIndex = registry.selectedIndex.value;
 		const direction = Math.sign(count || 1);
 		let hops = 0;
-		let index = wrapped(length, registry.selectedIndex.value + count);
+		let index = circular ? wrapped(length, currentIndex + count) : currentIndex + count;
+		if (!circular && (index < 0 || index >= length)) return;
 		let id = registry.lookup(index);
-		while (id !== void 0 && registry.get(id)?.disabled && hops < length) {
-			index = wrapped(length, index + direction);
+		while (id !== void 0 && toValue(registry.get(id)?.disabled) && hops < length) {
+			index = circular ? wrapped(length, index + direction) : index + direction;
+			if (!circular && (index < 0 || index >= length)) return;
 			id = registry.lookup(index);
 			hops++;
 		}
@@ -3884,6 +4262,21 @@ var MemoryAdapter = class {
 
 //#endregion
 //#region src/composables/useStorage/index.ts
+/**
+* @module useStorage
+*
+* @remarks
+* Reactive storage composable with adapter pattern for localStorage, sessionStorage, or memory.
+*
+* Key features:
+* - Reactive refs that sync with storage
+* - localStorage, sessionStorage, and memory adapters
+* - Custom serialization support
+* - SSR fallback to memory adapter
+* - Automatic cleanup on remove/clear
+*
+* Uses adapter pattern to abstract storage implementation details.
+*/
 const [useStorageContext, provideStorageContext] = createContext("v0:storage");
 /**
 * Creates a new storage instance.
@@ -4049,14 +4442,15 @@ var ThemeAdapter = class {
 	constructor(prefix) {
 		this.prefix = prefix;
 	}
-	generate(colors) {
+	generate(colors, isDark) {
 		let css = "";
 		for (const theme in colors) {
 			const themeColors = colors[theme];
 			if (!themeColors) continue;
 			const vars = Object.entries(themeColors).map(([key, val]) => `  --${this.prefix}-${key}: ${val};`).join("\n");
-			css += `.${this.prefix}-theme--${theme} {\n${vars}\n}\n`;
+			css += `[data-theme="${theme}"] {\n${vars}\n}\n`;
 		}
+		if (isDark !== void 0) css += `:root {\n  color-scheme: ${isDark ? "dark" : "light"};\n}\n`;
 		return css;
 	}
 };
@@ -4075,9 +4469,35 @@ var Vuetify0ThemeAdapter = class extends ThemeAdapter {
 		this.cspNonce = options.cspNonce;
 		this.stylesheetId = options.stylesheetId ?? this.stylesheetId;
 	}
-	update(colors) {
+	setup(app, context, target) {
+		if (IN_BROWSER) {
+			onScopeDispose(watch([context.colors, context.isDark], ([colors, isDark]) => {
+				this.update(colors, isDark);
+			}, { immediate: true }), true);
+			if (/* @__PURE__ */ isNull(target)) return;
+			const targetEl = target instanceof HTMLElement ? target : /* @__PURE__ */ isString(target) ? document.querySelector(target) : app._container || document.querySelector("#app") || document.body;
+			if (!targetEl) return;
+			onScopeDispose(watch(context.selectedId, (id) => {
+				if (!id) return;
+				targetEl.dataset.theme = String(id);
+			}, { immediate: true }), true);
+		} else {
+			const head = app._context?.provides?.usehead ?? app._context?.provides?.head;
+			if (head?.push) {
+				const id = context.selectedId.value;
+				head.push({
+					htmlAttrs: { "data-theme": id ? String(id) : "" },
+					style: [{
+						innerHTML: this.generate(context.colors.value, context.isDark.value),
+						id: this.stylesheetId
+					}]
+				});
+			}
+		}
+	}
+	update(colors, isDark) {
 		if (!IN_BROWSER) return;
-		this.upsert(this.generate(colors));
+		this.upsert(this.generate(colors, isDark));
 	}
 	upsert(styles) {
 		if (!IN_BROWSER) return;
@@ -4095,6 +4515,24 @@ var Vuetify0ThemeAdapter = class extends ThemeAdapter {
 //#endregion
 //#region src/composables/useTheme/index.ts
 /**
+* @module useTheme
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-theme
+*
+* @remarks
+* Theme management composable with token resolution and CSS variable injection.
+*
+* Key features:
+* - Single-selection theme switching (extends createSingle)
+* - Token alias resolution via useTokens
+* - Lazy theme loading (compute colors only when selected)
+* - CSS variable generation via adapter pattern
+* - SSR support with head integration
+* - Theme cycling
+*
+* Integrates with createSingle for selection and useTokens for color resolution.
+*/
+/**
 * Creates a new theme instance.
 *
 * @param options The options for the theme instance.
@@ -4153,6 +4591,7 @@ function createTheme(_options = {}) {
 		}
 		return resolved;
 	});
+	const isDark = toRef(() => registry.selectedItem.value?.dark ?? false);
 	function cycle(themes$1 = names.value) {
 		const current = themes$1.indexOf(registry.selectedId.value ?? "");
 		const next = current === -1 ? 0 : (current + 1) % themes$1.length;
@@ -4174,6 +4613,7 @@ function createTheme(_options = {}) {
 	return {
 		...registry,
 		colors,
+		isDark,
 		register,
 		cycle,
 		get size() {
@@ -4279,34 +4719,7 @@ function createThemePlugin(_options = {}) {
 			provideThemeContext(context, app);
 		},
 		setup: (app) => {
-			if (IN_BROWSER) {
-				onScopeDispose(watch(context.colors, (colors) => {
-					adapter.update(colors);
-				}, { immediate: true }), true);
-				if (target === null) return;
-				const targetEl = target instanceof HTMLElement ? target : /* @__PURE__ */ isString(target) ? document.querySelector(target) : app._container || document.querySelector("#app") || document.body;
-				if (!targetEl) return;
-				let prevClass = "";
-				onScopeDispose(watch(context.selectedId, (id) => {
-					if (!id) return;
-					const themeClass = `${adapter.prefix}-theme--${id}`;
-					if (prevClass) targetEl.classList.remove(prevClass);
-					targetEl.classList.add(themeClass);
-					prevClass = themeClass;
-				}, { immediate: true }), true);
-			} else {
-				const head = app._context?.provides?.usehead ?? app._context?.provides?.head;
-				if (head?.push) {
-					const id = context.selectedId.value;
-					head.push({
-						htmlAttrs: { class: id ? `${adapter.prefix}-theme--${id}` : "" },
-						style: [{
-							innerHTML: adapter.generate(context.colors.value),
-							id: adapter.stylesheetId
-						}]
-					});
-				}
-			}
+			adapter.setup(app, context, target);
 		}
 	});
 }
@@ -4340,6 +4753,21 @@ function useTheme(namespace = "v0:theme") {
 //#endregion
 //#region src/composables/useTimeline/index.ts
 /**
+* @module useTimeline
+*
+* @remarks
+* Bounded undo/redo system with overflow management.
+*
+* Key features:
+* - Fixed-size history (default: 10 items)
+* - Undo/redo stack management
+* - Overflow queue (preserves oldest items)
+* - Automatic reindexing after operations
+* - Perfect for command pattern, history tracking
+*
+* Extends useRegistry with temporal navigation capabilities.
+*/
+/**
 * Creates a new timeline instance.
 *
 * @param _options The options for the timeline instance.