@vuetify/v0 1.0.0-alpha.4 → 1.0.0-beta.0

package/dist/{useClickOutside-B8naChaQ.mjs → useClickOutside-DoOgNtrj.mjs}

@@ -1,22 +1,22 @@
-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-BAe6tA_x.mjs";
-import { clamp, instanceExists, isArray, isElement, isFunction, isNull, isNullOrUndefined, isNumber, isObject, isString, isThenable, isUndefined, mergeDeep, range, resolveIds, resolveIndexes, useId as useId$1 } from "./utilities/index.mjs";
-import { i as useContext, t as createTrinity } from "./createTrinity-BTCs1pYx.mjs";
-import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-DPSSa-YR.mjs";
-import { t as createRegistry } from "./createRegistry-Db_juawd.mjs";
-import { i as createModel, t as createSelection } from "./createSelection-BeKZMxha.mjs";
-import { t as createSingle } from "./createSingle-Dms2efxr.mjs";
-import "./createTokens-B1lwHZvO.mjs";
-import { a as useLocale } from "./useLocale-BUms59Bw.mjs";
-import { c as useTimer } from "./useNotifications-BPTmZWQy.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-DB-krEA-.mjs";
+import { V0Error, clamp, instanceExists, isArray, isElement, isFunction, isNaN, isNull, isNullOrUndefined, isNumber, isObject, isString, isThenable, isUndefined, mergeDeep, range, resolveIds, resolveIndexes, useId as useId$1 } from "./utilities/index.mjs";
+import { i as useContext, n as createContext, t as createTrinity } from "./createTrinity-z-3q9QWR.mjs";
+import { a as createPlugin, i as useLogger, o as createPluginContext } from "./useLogger-CTgAedNH.mjs";
+import { t as createRegistry } from "./createRegistry-tJ1PPNIr.mjs";
+import { i as createModel, t as createSelection } from "./createSelection-DEqhvdoj.mjs";
+import { t as createSingle } from "./createSingle-ClzWqRCe.mjs";
+import "./createTokens-mNxs8DQ3.mjs";
+import { a as useLocale } from "./useLocale-CbpoxbVU.mjs";
+import { c as useTimer } from "./useNotifications-BkKGUl_1.mjs";
 import { t as toArray } from "./toArray-CD2-OxAz.mjs";
-import { a as createFilter } from "./adapter-C9cR4AcY.mjs";
-import { t as createGroup } from "./createGroup-BSGtfBUE.mjs";
-import "./createDataTable-DDr2yY-A.mjs";
-import { a as useRules, o as isStandardSchema } from "./useRules-DNhljkyO.mjs";
-import "./useFeatures-x2iKp0C8.mjs";
-import "./usePermissions-CTi-3pBk.mjs";
+import { a as createFilter } from "./adapter-BCVxBtDp.mjs";
+import { t as createGroup } from "./createGroup-DsKJMuRd.mjs";
+import { a as extractLeaves, t as createDataTable } from "./createDataTable-DlFQyBTN.mjs";
+import { a as useRules, o as isStandardSchema } from "./useRules-mD_DY9dy.mjs";
+import "./useFeatures-B-A-eOo-.mjs";
+import "./usePermissions-BYOrKcnk.mjs";
 import { t as MemoryStorageAdapter } from "./memory-BMpJcQjQ.mjs";
-import "./useTheme-3vW3kFNg.mjs";
+import "./useTheme-B1lUya5B.mjs";
 import { computed, effectScope, hasInjectionContext, isReadonly, isRef, nextTick, onMounted, onScopeDispose, onWatcherCleanup, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
 //#region src/composables/createBreadcrumbs/index.ts
 /**
@@ -170,6 +170,123 @@ function useBreadcrumbs(namespace = "v0:breadcrumbs") {
 	return useContext(namespace);
 }
 //#endregion
+//#region src/composables/useDelay/index.ts
+/**
+* @module useDelay
+*
+* @see https://0.vuetifyjs.com/composables/system/use-delay
+*
+* @remarks
+* Schedule open and close transitions with configurable delays.
+*
+* Composes `useTimer` for the underlying lifecycle (start / stop / pause / resume,
+* plus reactive `isActive`, `isPaused`, `remaining`) and adds direction tracking
+* (`isOpening`) and promise-based resolution.
+*
+* Key features:
+* - Reactive `openDelay` and `closeDelay` via `MaybeRefOrGetter`
+* - `start(isOpening)` returns a `Promise<boolean>` that resolves once the delay elapses
+* - Per-call `minDelay` floor enforces a minimum delay
+* - Automatic cleanup on scope disposal (timer cleared, pending promise settled with current direction)
+* - SSR-safe
+*
+* @example
+* ```ts
+* import { useDelay } from '@vuetify/v0'
+*
+* const delay = useDelay(isOpening => isVisible.value = isOpening, {
+*   openDelay: 300,
+*   closeDelay: 200,
+* })
+*
+* delay.start(true)
+* delay.start(false, { minDelay: 500 })
+* ```
+*/
+/**
+* Schedule open and close transitions with configurable delays.
+*
+* Composes `useTimer` for the lifecycle (`start` / `stop` / `pause` / `resume` plus
+* reactive `isActive`, `isPaused`, `remaining`) and adds direction tracking
+* (`isOpening`) and promise-based resolution.
+*
+* @param callback Optional callback invoked once a started delay elapses; receives the resolved direction.
+* @param options Reactive delay settings.
+* @returns Lifecycle controls and reactive state.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-delay
+*
+* @example
+* ```ts
+* const delay = useDelay(isOpening => isVisible.value = isOpening, {
+*   openDelay: 300,
+*   closeDelay: 200,
+* })
+*
+* delay.start(true)
+* delay.start(false, { minDelay: 500 })
+* delay.pause()
+* delay.resume()
+* delay.stop()
+* ```
+*/
+function useDelay(callback, options = {}) {
+	const { openDelay, closeDelay } = options;
+	const isOpening = shallowRef(false);
+	let minDelay = 0;
+	let resolver;
+	function fire() {
+		const direction = isOpening.value;
+		const resolve = resolver;
+		resolver = void 0;
+		resolve?.(direction);
+		callback?.(direction);
+	}
+	function duration() {
+		const raw = isOpening.value ? toValue(openDelay) : toValue(closeDelay);
+		return Math.max(minDelay, raw ?? 0);
+	}
+	const timer = useTimer(fire, { duration });
+	function start(direction, options = {}) {
+		const previous = resolver;
+		resolver = void 0;
+		isOpening.value = direction;
+		minDelay = options.minDelay ?? 0;
+		previous?.(direction);
+		const ms = duration();
+		return new Promise((resolve) => {
+			resolver = resolve;
+			if (ms <= 0) {
+				timer.stop();
+				fire();
+				return;
+			}
+			timer.start();
+		});
+	}
+	function stop() {
+		const resolve = resolver;
+		resolver = void 0;
+		timer.stop();
+		resolve?.(isOpening.value);
+	}
+	onScopeDispose(() => {
+		const resolve = resolver;
+		resolver = void 0;
+		resolve?.(isOpening.value);
+	}, true);
+	return {
+		start,
+		stop,
+		pause: timer.pause,
+		resume: timer.resume,
+		isActive: shallowReadonly(timer.isActive),
+		isPaused: shallowReadonly(timer.isPaused),
+		remaining: shallowReadonly(timer.remaining),
+		isOpening: shallowReadonly(isOpening)
+	};
+}
+//#endregion
 //#region src/composables/usePopover/index.ts
 /**
 * @module usePopover
@@ -178,52 +295,50 @@ function useBreadcrumbs(namespace = "v0:breadcrumbs") {
 *
 * @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.
+* Manages open/close state, anchor styles, content attributes, bidirectional
+* sync between reactive state and native popover events, and configurable
+* open / close delays via `useDelay`.
 *
 * Key features:
 * - Native popover API (showPopover/hidePopover)
 * - CSS anchor positioning (position-area, position-try-fallbacks)
+* - Reactive open/close delays via `useDelay`
 * - Toggle event sync for native state changes
 * - SSR-safe (no DOM ops outside browser)
 * - Optional external isOpen ref for v-model integration
 *
-* Perfect for building select, combobox, tooltip, and menu components
-* without wrapping the Popover compound component.
-*
 * @example
 * ```ts
 * import { usePopover } from '@vuetify/v0'
 *
-* const popover = usePopover()
+* const popover = usePopover({ openDelay: 200, closeDelay: 100 })
 * popover.open()
 * popover.toggle()
 * ```
 */
 function usePopover(options = {}) {
-	const { id: _id, positionArea = "bottom", positionTry = "most-width bottom", showDelay = 0, hideDelay = 0 } = options;
+	const { id: _id, positionArea = "bottom", positionTry = "most-width bottom", openDelay, closeDelay } = 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;
+	const delay = useDelay((direction) => {
+		isOpen.value = direction;
+	}, {
+		openDelay,
+		closeDelay
+	});
 	function open() {
-		hideTimer?.stop();
-		if (showTimer) showTimer.start();
-		else isOpen.value = true;
+		delay.start(true);
 	}
 	function close() {
-		showTimer?.stop();
-		if (hideTimer) hideTimer.start();
-		else isOpen.value = false;
+		delay.start(false);
 	}
 	function toggle() {
 		if (isOpen.value) close();
 		else open();
 	}
+	function cancel() {
+		delay.stop();
+	}
 	const anchorStyles = toRef(() => ({ anchorName: `--${id}` }));
 	const contentAttrs = toRef(() => ({
 		id,
@@ -241,7 +356,7 @@ function usePopover(options = {}) {
 	function attach(el) {
 		onMounted(() => {
 			const element = toValue(el);
-			if (isOpen.value) element?.showPopover();
+			if (isOpen.value) element?.showPopover?.();
 		});
 		watch(isOpen, (value) => {
 			const element = toValue(el);
@@ -262,6 +377,7 @@ function usePopover(options = {}) {
 		open,
 		close,
 		toggle,
+		cancel,
 		anchorStyles,
 		contentAttrs,
 		contentStyles,
@@ -785,44 +901,1042 @@ function createCombobox(options = {}) {
 	};
 }
 /**
-* 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]`.
+* 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/forms/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;
+	return createTrinity(namespace, createCombobox(rest));
+}
+/**
+* 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/forms/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
+//#region src/composables/createSortable/index.ts
+/**
+* @module createSortable
+*
+* @see https://0.vuetifyjs.com/composables/data/create-sortable
+*
+* @remarks
+* Headless ordered-list primitive. Extends `createModel` with mutation primitives
+* (`swap`, `reorder`) and an enriched `move:ticket` event on the registry event
+* bus. Honors `disabled` as a real mutation gate at both root and per-ticket scope.
+*
+* Pure logical composable — no DnD, no DOM, no keyboard. Drag-and-drop integration
+* composes with `useDragDrop`; keyboard reorder composes with `useVirtualFocus`.
+*
+* @example
+* ```ts
+* import { createSortable } from '@vuetify/v0'
+* import type { SortableTicketInput } from '@vuetify/v0'
+*
+* interface TaskTicket extends SortableTicketInput {
+*   value: { id: number; label: string }
+* }
+*
+* const sortable = createSortable<TaskTicket>()
+* const a = sortable.register({ value: { id: 1, label: 'A' } })
+* const b = sortable.register({ value: { id: 2, label: 'B' } })
+*
+* sortable.move(a.id, 1)
+* sortable.on('move:ticket', ({ ticket, from, to }) => {
+*   console.log(`${ticket.value.label} moved ${from} → ${to}`)
+* })
+* ```
+*/
+/**
+* Create an ordered-list state primitive.
+*
+* @param options Sortable options.
+* @returns A {@link SortableContext} that extends {@link ModelContext}.
+*
+* @example
+* ```ts
+* const sortable = createSortable<Todo>()
+* sortable.onboard(todos.value.map(value => ({ value })))
+* ```
+*/
+function createSortable(_options = {}) {
+	const { disabled, ...options } = _options;
+	const model = createModel({
+		...options,
+		events: true,
+		disabled
+	});
+	const logger = useLogger();
+	function move(id, toIndex) {
+		if (toValue(disabled)) return void 0;
+		const ticket = model.get(id);
+		if (!ticket) return void 0;
+		if (toValue(ticket.disabled)) return void 0;
+		const from = ticket.index;
+		const result = model.move(id, toIndex);
+		if (result && result.index !== from) model.emit("move:ticket", {
+			ticket: result,
+			from,
+			to: result.index
+		});
+		return result;
+	}
+	function swap(a, b) {
+		if (toValue(disabled)) return;
+		if (a === b) return;
+		const ta = model.get(a);
+		const tb = model.get(b);
+		if (!ta || !tb) return;
+		if (toValue(ta.disabled) || toValue(tb.disabled)) return;
+		const indexA = ta.index;
+		const indexB = tb.index;
+		model.batch(() => {
+			const ra = model.move(a, indexB);
+			if (ra && ra.index !== indexA) model.emit("move:ticket", {
+				ticket: ra,
+				from: indexA,
+				to: ra.index
+			});
+			const rb = model.move(b, indexA);
+			if (rb && rb.index !== indexB) model.emit("move:ticket", {
+				ticket: rb,
+				from: indexB,
+				to: rb.index
+			});
+		});
+	}
+	function reorder(ids) {
+		if (toValue(disabled)) return;
+		const currentSize = model.size;
+		if (ids.length !== currentSize) {
+			logger.warn(`Reorder expected ${currentSize} ids, got ${ids.length}.`);
+			return;
+		}
+		const known = new Set(model.keys());
+		const seen = /* @__PURE__ */ new Set();
+		for (const id of ids) {
+			if (!known.has(id)) {
+				logger.warn(`Reorder contains unknown id "${String(id)}".`);
+				return;
+			}
+			if (seen.has(id)) {
+				logger.warn(`Reorder contains duplicate id "${String(id)}".`);
+				return;
+			}
+			seen.add(id);
+		}
+		const froms = /* @__PURE__ */ new Map();
+		for (const id of ids) {
+			const ticket = model.get(id);
+			if (ticket) froms.set(id, ticket.index);
+		}
+		model.batch(() => {
+			model.reorder(ids);
+			for (const [index, id] of ids.entries()) {
+				const from = froms.get(id);
+				if (from === index) continue;
+				const ticket = model.get(id);
+				if (ticket) model.emit("move:ticket", {
+					ticket,
+					from,
+					to: index
+				});
+			}
+		});
+	}
+	return {
+		...model,
+		move,
+		swap,
+		reorder,
+		get size() {
+			return model.size;
+		}
+	};
+}
+//#endregion
+//#region src/composables/useToggleScope/index.ts
+/**
+* @module useToggleScope
+*
+* @see https://0.vuetifyjs.com/composables/system/use-toggle-scope
+*
+* @remarks
+* Conditionally manages an effect scope based on a reactive boolean condition.
+* When the source becomes true, creates and runs an effect scope. When false, stops the scope.
+* All reactive effects created within the scoped function are automatically cleaned up on deactivation.
+*
+* Key features:
+* - Uses Vue's effectScope for efficient reactive effect lifecycle management
+* - Automatic cleanup when condition becomes false
+* - Supports optional reset callback for scope restart capability
+* - Handles rapid toggling and parent scope disposal safely
+* - SSR-safe (effectScope is part of Vue core)
+*
+* Perfect for conditional side effects, feature flags, and performance optimization
+* by only running reactive effects when needed.
+*
+* @example
+* ```ts
+* import { shallowRef } from 'vue'
+* import { useToggleScope } from '@vuetify/v0'
+*
+* const isEnabled = shallowRef(false)
+* const { isActive } = useToggleScope(isEnabled, () => {
+*   // effects run while isEnabled is true
+* })
+* ```
+*/
+/**
+* Conditionally manages an effect scope based on a reactive boolean source.
+*
+* @param source A reactive boolean value or getter that controls the scope lifecycle
+* @param fn The function to run within the effect scope. Can optionally receive controls for manual scope management.
+* @returns Controls object with isActive state and start/stop/reset methods
+*
+* @see https://vuejs.org/api/reactivity-advanced.html#effectscope
+* @see https://0.vuetifyjs.com/composables/system/use-toggle-scope
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { useToggleScope } from '@vuetify/v0'
+*
+* const isEnabled = ref(false)
+*
+* const { isActive } = useToggleScope(isEnabled, () => {
+*   // This code runs when isEnabled becomes true
+*   const unwatch = watch(someRef, () => {
+*     console.log('Watching...')
+*   })
+*
+*   // Cleanup happens automatically when isEnabled becomes false
+* })
+*
+* // Toggle the scope on/off
+* isEnabled.value = true  // Starts the scope
+* console.log(isActive.value) // true
+* isEnabled.value = false // Stops and cleans up
+* console.log(isActive.value) // false
+* ```
+*
+* @example
+* With manual controls:
+* ```ts
+* const isEnabled = ref(true)
+*
+* useToggleScope(isEnabled, (controls) => {
+*   // Access controls inside the scope
+*   console.log('Active:', controls.isActive.value)
+*
+*   // Manually reset the scope if needed
+*   someEvent.on('reset', () => controls.reset())
+* })
+* ```
+*/
+function useToggleScope(source, fn) {
+	const scope = shallowRef();
+	const isActive = toRef(() => !!scope.value);
+	function start() {
+		if (scope.value) return;
+		scope.value = effectScope();
+		scope.value.run(() => fn.length > 0 ? fn(controls) : fn());
+	}
+	function stop() {
+		scope.value?.stop();
+		scope.value = void 0;
+	}
+	function reset() {
+		stop();
+		start();
+	}
+	const controls = {
+		isActive: shallowReadonly(isActive),
+		start,
+		stop,
+		reset
+	};
+	watch(source, (active) => {
+		if (active && !scope.value) start();
+		else if (!active) stop();
+	}, { immediate: true });
+	onScopeDispose(stop, true);
+	return controls;
+}
+//#endregion
+//#region src/composables/createDataGrid/editing.ts
+/**
+* @module createDataGrid/editing
+*
+* @remarks
+* Cell editing state management. Tracks active cell, validation errors,
+* and dirty (staged but uncommitted) edits. Does not mutate source data —
+* commit fires a callback for the consumer to handle.
+*
+* When a `registry` is provided, editing state for rows that get
+* unregistered (or wiped via `clear`) is pruned automatically so consumers
+* can never observe `active` pointing at a phantom row or stale entries
+* lingering in `dirty`.
+*
+* @internal Consumed only by `createDataGrid`. This is a fully decoupled 2D
+* cell-edit primitive — it imports nothing from `createDataGrid` /
+* `createDataTable` (only `#v0/utilities`, `#v0/types`, and Vue), so it is a
+* latent composable. It is parameterized over a row type `T` (defaulting to
+* `unknown`), but a type parameter is not an import — the primitive stays
+* fully decoupled from the grid's concrete ticket types and deliberately
+* row-agnostic: `T` is intentionally unconstrained, so do not narrow it to
+* the grid's `Record<string, unknown>` when promoting. Promote it to a
+* standalone `createCellEditing/`
+* composable the moment a second consumer appears (e.g. an editable
+* `createDataTable`). See `.claude/rules/composables.md` §"Sub-modules:
+* inline, private sibling, or promote".
+*/
+/**
+* Creates cell editing state for a data grid.
+*
+* @param options Cell editing configuration including columns and commit callback
+* @returns Cell editing state and controls
+*
+* @example
+* ```ts
+* const editing = createCellEditing({
+*   columns: [{ id: 'name', editable: true }],
+*   registry: table,
+*   onEdit (row, column, value) { ... },
+* })
+*
+* editing.edit(1, 'name')
+* editing.commit('Alice')
+* ```
+*/
+function createCellEditing(options) {
+	const { columns, onEdit, lookup, registry } = options;
+	function resolveColumn(column) {
+		for (const col of toValue(columns)) if (col.id === column) return col;
+	}
+	const active = shallowRef(null);
+	const error = shallowRef(null);
+	const dirty = shallowReactive(/* @__PURE__ */ new Map());
+	function edit(row, column) {
+		const col = resolveColumn(column);
+		if (!col) return;
+		if (/* @__PURE__ */ isFunction(col.editable)) {
+			const item = lookup?.(row);
+			if (/* @__PURE__ */ isUndefined(item) || !col.editable(item)) return;
+		} else if (col.editable !== true) return;
+		error.value = null;
+		active.value = {
+			row,
+			column
+		};
+	}
+	function commit(value) {
+		const cell = active.value;
+		if (!cell) return;
+		const col = resolveColumn(cell.column);
+		if (col?.validate) {
+			const result = col.validate(value, lookup?.(cell.row));
+			if (result !== true && /* @__PURE__ */ isString(result) && result.length > 0) {
+				error.value = result;
+				return;
+			}
+		}
+		const entry = dirty.get(cell.row);
+		if (entry) {
+			entry.delete(cell.column);
+			if (entry.size === 0) dirty.delete(cell.row);
+		}
+		error.value = null;
+		active.value = null;
+		onEdit?.(cell.row, cell.column, value);
+	}
+	function cancel() {
+		const cell = active.value;
+		if (cell) {
+			const entry = dirty.get(cell.row);
+			if (entry) {
+				entry.delete(cell.column);
+				if (entry.size === 0) dirty.delete(cell.row);
+			}
+		}
+		error.value = null;
+		active.value = null;
+	}
+	function onUnregister(data) {
+		const ticket = data;
+		if (active.value?.row === ticket.id) {
+			active.value = null;
+			error.value = null;
+		}
+		dirty.delete(ticket.id);
+	}
+	function onClear() {
+		active.value = null;
+		error.value = null;
+		dirty.clear();
+	}
+	if (registry) {
+		registry.on("unregister:ticket", onUnregister);
+		registry.on("clear:registry", onClear);
+		onScopeDispose(() => {
+			registry.off("unregister:ticket", onUnregister);
+			registry.off("clear:registry", onClear);
+		}, true);
+	}
+	return {
+		active,
+		edit,
+		commit,
+		cancel,
+		error,
+		dirty
+	};
+}
+//#endregion
+//#region src/composables/createDataGrid/layout.ts
+/**
+* @module createDataGrid/layout
+*
+* @remarks
+* Manages column layout state for data grids: sizing (percentages 0-100),
+* pinning (left/right/scrollable regions), delta-based resizing compatible
+* with the Splitter two-panel model, column reordering, and visibility.
+*
+* Column existence, display order, AND grid layout config (size, pin,
+* min/max, resizable, reorderable) all live on the table's columns registry
+* (passed in as the only argument). `createRegistry` preserves the extra
+* grid fields on each ticket, so layout reads its config straight off the
+* registered ticket — there is no separate defs array. Columns onboarded
+* before OR after the layout is built are picked up identically: an initial
+* loop seeds the already-registered set and a `register:ticket` handler seeds
+* the rest. Removed columns have their pin/size/visibility state pruned via
+* unregister events.
+*
+* Sizing uses percentages so it is compatible with the Splitter component.
+* Offsets are computed per-region (left, scrollable, right) independently
+* and over visible columns only — hidden columns are excluded from the
+* render set without auto-redistribution (headless: the consumer rebalances
+* via `distribute()` or CSS).
+*
+* @internal Private sibling of `createDataGrid`, and intentionally NOT a
+* promotion candidate: it is bound to the table's `DataTableColumnTicket`
+* types, so it is parent-specific glue rather than a reusable primitive. See
+* `.claude/rules/composables.md` §"Sub-modules: inline, private sibling, or
+* promote".
+*/
+const DEFAULT_EXTRAS = {
+	minSize: 2,
+	maxSize: 100,
+	resizable: true,
+	reorderable: true
+};
+function offsets(cols, reverse = false) {
+	let offset = 0;
+	const start = reverse ? cols.length - 1 : 0;
+	const step = reverse ? -1 : 1;
+	const end = reverse ? -1 : cols.length;
+	for (let i = start; i !== end; i += step) {
+		cols[i].offset = offset;
+		offset += cols[i].size;
+	}
+}
+/**
+* Creates a column layout manager for a data grid.
+*
+* Reads column existence, display order, AND grid layout config (size, pin,
+* min/max, resizable, reorderable) from the table's columns registry. The
+* grid fields ride on each ticket — `createRegistry` preserves them — so
+* there is no separate defs array. Visibility is layout-local view state
+* (not a ticket field) kept here and reconciled via register / unregister /
+* clear events.
+*
+* Generic over the registry's input/output ticket types so the caller's
+* concrete grid column ticket (`DataGridColumnTicket`) flows through. Layout
+* only ever reads from the registry (`values`, `keys`, `on`, `reorder`,
+* `move`, `lookup`) — it never registers — so the output ticket need only be
+* readable as a {@link GridColumnDef}.
+*
+* @param cols The table's columns registry — source of truth for which
+*             columns exist, in what order, and their layout config
+* @returns Column layout state and mutation methods
+*/
+function createColumnLayout(cols) {
+	const logger = useLogger();
+	const configs = /* @__PURE__ */ new Map();
+	const group = createGroup({ multiple: true });
+	const sizes = shallowReactive(/* @__PURE__ */ new Map());
+	const hidden = shallowReactive(/* @__PURE__ */ new Set());
+	const order = [];
+	function record(id) {
+		if (!order.includes(id)) order.push(id);
+	}
+	/** Even share over the currently-registered leaves: explicit sizes are
+	*  honored, unsized columns split the remaining percentage. */
+	function share(id) {
+		const leaves = /* @__PURE__ */ extractLeaves(cols.values());
+		let used = 0;
+		let unsized = 0;
+		for (const leaf of leaves) {
+			const size = configs.get(String(leaf.id))?.size;
+			if (/* @__PURE__ */ isUndefined(size)) unsized++;
+			else used += size;
+		}
+		const own = configs.get(id)?.size;
+		if (!/* @__PURE__ */ isUndefined(own)) return own;
+		const remainder = Math.max(0, 100 - used);
+		return unsized > 0 ? remainder / unsized : 0;
+	}
+	function seedLeaf(leaf) {
+		const id = String(leaf.id);
+		if (!configs.has(id)) configs.set(id, {
+			size: leaf.size,
+			minSize: leaf.minSize ?? DEFAULT_EXTRAS.minSize,
+			maxSize: leaf.maxSize ?? DEFAULT_EXTRAS.maxSize,
+			resizable: leaf.resizable ?? DEFAULT_EXTRAS.resizable,
+			reorderable: leaf.reorderable ?? DEFAULT_EXTRAS.reorderable,
+			pinned: leaf.pinned ?? false
+		});
+		if (!group.has(id)) group.register({
+			id,
+			value: id
+		});
+		if (!sizes.has(id)) sizes.set(id, share(id));
+		for (const other of /* @__PURE__ */ extractLeaves(cols.values())) {
+			const otherId = String(other.id);
+			if (configs.has(otherId) && /* @__PURE__ */ isUndefined(configs.get(otherId)?.size)) sizes.set(otherId, share(otherId));
+		}
+		const config = configs.get(id);
+		if (config.pinned === "left") group.select(id);
+		else if (config.pinned === "right") group.mix(id);
+	}
+	function dropLeaf(id) {
+		group.unregister(id);
+		configs.delete(id);
+		sizes.delete(id);
+		hidden.delete(id);
+	}
+	function leavesOf(ticket) {
+		return /* @__PURE__ */ extractLeaves([ticket]);
+	}
+	for (const ticket of cols.values()) {
+		record(String(ticket.id));
+		for (const leaf of leavesOf(ticket)) seedLeaf(leaf);
+	}
+	cols.on("register:ticket", (ticket) => {
+		record(String(ticket.id));
+		for (const leaf of leavesOf(ticket)) seedLeaf(leaf);
+	});
+	cols.on("unregister:ticket", (ticket) => {
+		const top = order.indexOf(String(ticket.id));
+		if (top !== -1) order.splice(top, 1);
+		for (const leaf of leavesOf(ticket)) dropLeaf(String(leaf.id));
+	});
+	cols.on("clear:registry", () => {
+		group.clear();
+		configs.clear();
+		sizes.clear();
+		hidden.clear();
+		order.length = 0;
+	});
+	function position(id) {
+		if (group.selectedIds.has(id)) return "left";
+		if (group.mixed(id)) return "right";
+		return false;
+	}
+	function resolve(includeHidden) {
+		const resolved = [];
+		let index = 0;
+		for (const ticket of /* @__PURE__ */ extractLeaves(cols.values())) {
+			const id = String(ticket.id);
+			const visible = !hidden.has(id);
+			if (!includeHidden && !visible) continue;
+			const meta = configs.get(id) ?? DEFAULT_EXTRAS;
+			resolved.push({
+				id,
+				index: index++,
+				size: sizes.get(id) ?? 0,
+				offset: 0,
+				pinned: position(id),
+				resizable: meta.resizable,
+				reorderable: meta.reorderable,
+				minSize: meta.minSize,
+				maxSize: meta.maxSize,
+				visible
+			});
+		}
+		return resolved;
+	}
+	function split(resolved) {
+		const left = [];
+		const scrollable = [];
+		const right = [];
+		for (const col of resolved) if (col.pinned === "left") left.push(col);
+		else if (col.pinned === "right") right.push(col);
+		else scrollable.push(col);
+		offsets(left);
+		offsets(scrollable);
+		offsets(right, true);
+		return {
+			left,
+			scrollable,
+			right
+		};
+	}
+	const pinned = computed(() => split(resolve(false)));
+	const columns = computed(() => {
+		const { left, scrollable, right } = pinned.value;
+		return [
+			...left,
+			...scrollable,
+			...right
+		];
+	});
+	const allColumns = computed(() => resolve(true));
+	function pin(id, pos) {
+		if (!group.has(id)) return;
+		group.unselect(id);
+		group.unmix(id);
+		if (pos === "left") group.select(id);
+		else if (pos === "right") group.mix(id);
+	}
+	function resize(id, delta) {
+		const { left, scrollable, right } = pinned.value;
+		const all = [
+			...left,
+			...scrollable,
+			...right
+		];
+		const target = all.find((c) => c.id === id);
+		if (!target || !target.resizable) return;
+		const allIndex = all.findIndex((c) => c.id === id);
+		if (allIndex === -1 || allIndex === all.length - 1) return;
+		const neighbor = all[allIndex + 1];
+		const total = target.size + neighbor.size;
+		const lower = Math.max(target.minSize, total - neighbor.maxSize);
+		const upper = Math.min(target.maxSize, total - neighbor.minSize);
+		const clamped = /* @__PURE__ */ clamp(target.size + delta, lower, upper);
+		sizes.set(id, clamped);
+		sizes.set(neighbor.id, total - clamped);
+	}
+	function reorder(from, to) {
+		if (from === to) return;
+		const tops = [...cols.values()];
+		const ids = [];
+		const leafToTop = [];
+		for (const [top, ticket] of tops.entries()) for (const leaf of /* @__PURE__ */ extractLeaves([ticket])) {
+			ids.push(String(leaf.id));
+			leafToTop.push(top);
+		}
+		const visible = ids.filter((id) => !hidden.has(id));
+		const fromId = visible[from];
+		const toId = visible[to];
+		if (/* @__PURE__ */ isUndefined(fromId) || /* @__PURE__ */ isUndefined(toId)) return;
+		const fromTop = leafToTop[ids.indexOf(fromId)];
+		const toTop = leafToTop[ids.indexOf(toId)];
+		if (/* @__PURE__ */ isUndefined(fromTop) || /* @__PURE__ */ isUndefined(toTop) || fromTop === toTop) return;
+		if (tops[fromTop]?.reorderable === false) return;
+		const id = cols.lookup(fromTop);
+		if (/* @__PURE__ */ isUndefined(id)) return;
+		cols.move(id, toTop);
+	}
+	function distribute(incoming) {
+		const tickets = /* @__PURE__ */ extractLeaves(cols.values());
+		if (incoming.length !== tickets.length) {
+			logger.warn(`createDataGrid: distribute() expected ${tickets.length} sizes but received ${incoming.length}; ignoring.`);
+			return;
+		}
+		const sum = incoming.reduce((acc, value) => acc + value, 0);
+		if (sum <= 0) {
+			logger.warn(`createDataGrid: distribute() received sizes summing to ${sum}; expected a positive total.`);
+			return;
+		}
+		const metas = tickets.map((ticket) => configs.get(String(ticket.id)) ?? DEFAULT_EXTRAS);
+		let current = incoming.map((value, i) => /* @__PURE__ */ clamp(value / sum * 100, metas[i].minSize, metas[i].maxSize));
+		let residual = 100 - current.reduce((acc, value) => acc + value, 0);
+		const max = tickets.length * 2;
+		for (let pass = 0; pass < max && Math.abs(residual) >= 1e-6; pass++) {
+			const room = current.map((value, i) => residual > 0 ? metas[i].maxSize - value : value - metas[i].minSize);
+			const available = room.reduce((acc, value) => acc + Math.max(0, value), 0);
+			if (available <= 0) break;
+			current = current.map((value, i) => room[i] <= 0 ? value : value + residual * (room[i] / available));
+			residual = 100 - current.reduce((acc, value) => acc + value, 0);
+		}
+		if (Math.abs(residual) >= 1e-6) logger.warn(`createDataGrid: distribute() could not reach 100 within min/max constraints (off by ${residual.toFixed(2)})`);
+		for (const [i, ticket] of tickets.entries()) sizes.set(String(ticket.id), current[i]);
+	}
+	function show(id) {
+		hidden.delete(id);
+	}
+	function hide(id) {
+		hidden.add(id);
+	}
+	function toggle(id) {
+		if (hidden.has(id)) hidden.delete(id);
+		else hidden.add(id);
+	}
+	function reset() {
+		for (const ticket of /* @__PURE__ */ extractLeaves(cols.values())) {
+			const id = String(ticket.id);
+			sizes.set(id, share(id));
+		}
+		cols.reorder([...order]);
+		hidden.clear();
+		for (const ticket of /* @__PURE__ */ extractLeaves(cols.values())) {
+			const id = String(ticket.id);
+			group.unselect(id);
+			group.unmix(id);
+		}
+		for (const [id, config] of configs) if (config.pinned === "left") group.select(id);
+		else if (config.pinned === "right") group.mix(id);
+	}
+	return {
+		pinned,
+		columns,
+		all: allColumns,
+		pin,
+		resize,
+		reorder,
+		distribute,
+		show,
+		hide,
+		toggle,
+		reset
+	};
+}
+//#endregion
+//#region src/composables/createDataGrid/spanning.ts
+/**
+* @module createDataGrid/spanning
+*
+* @remarks
+* Computes a row span map from visible items. For each cell, determines
+* rowSpan and whether it's hidden (covered by a span from a previous row).
+* Spans do not cross page boundaries. Each row is addressed by a key: either a
+* `key(item, index)` projection (the grid passes the registry ticket id) or,
+* absent that, the row's `itemKey` value. Rows whose resolved key is
+* `undefined` cannot be addressed in the resulting map and are skipped.
+*
+* @internal Consumed only by `createDataGrid`. Fully decoupled (items ref +
+* columns + key + span fn — no grid/table types), so it is a latent composable.
+* Promote it to a standalone `createRowSpanning/` composable on a second
+* consumer. See `.claude/rules/composables.md` §"Sub-modules: inline, private
+* sibling, or promote".
+*/
+/**
+* Computes a row span map from visible items.
+*
+* @param options Row spanning configuration
+* @returns A computed map of item ID to column to SpanEntry
+*
+* @example
+* ```ts
+* const spans = createRowSpanning({
+*   items: computed(() => grid.items.value),
+*   columns: ['group', 'ticker', 'value'],
+*   span: (item, column) => column === 'group' ? 3 : 1,
+* })
+*
+* spans.value.get(id)?.get('group') // { rowSpan: 3, hidden: false }
+* ```
+*/
+function createRowSpanning(options) {
+	const { items, columns, key, itemKey = "id", span } = options;
+	return computed(() => {
+		const result = /* @__PURE__ */ new Map();
+		if (!span) return result;
+		const list = items.value;
+		const resolved = toValue(columns);
+		const covered = Array.from({ length: resolved.length }).fill(0);
+		for (let row = 0; row < list.length; row++) {
+			const item = list[row];
+			const id = key ? key(item, row) : item[itemKey];
+			if (/* @__PURE__ */ isUndefined(id)) continue;
+			const cells = /* @__PURE__ */ new Map();
+			for (const [col, column] of resolved.entries()) if (covered[col] > 0) {
+				cells.set(column, {
+					rowSpan: 1,
+					hidden: true
+				});
+				covered[col]--;
+			} else {
+				const raw = span(item, column);
+				const rowSpan = Math.min(Math.max(1, /* @__PURE__ */ isNaN(raw) ? 1 : raw), list.length - row);
+				cells.set(column, {
+					rowSpan,
+					hidden: false
+				});
+				if (rowSpan > 1) covered[col] = rowSpan - 1;
+			}
+			result.set(id, cells);
+		}
+		return result;
+	});
+}
+//#endregion
+//#region src/composables/createDataGrid/index.ts
+/**
+* @module createDataGrid
+*
+* @see https://0.vuetifyjs.com/composables/data/create-data-grid
+*
+* @remarks
+* Main factory that wires together column layout, cell editing, row ordering,
+* and row spanning on top of a createDataTable pipeline. Row ordering is
+* provided by a createSortable instance synced to the table's row registry
+* via register / unregister events; the ordered ids are applied post-sort,
+* pre-pagination by overriding the `items` projection.
+*
+* Rows are registered through the inherited registry surface (`register`,
+* `onboard`, `unregister`, `clear`) — they are not passed as an `items`
+* option to the factory.
+*
+* Follows the trinity pattern for dependency injection.
+*
+* @example
+* ```ts
+* const grid = createDataGrid()
+*
+* grid.columns.onboard([
+*   { id: 'name', sortable: true },
+*   { id: 'progress', editable: true },
+* ])
+*
+* grid.onboard(rows.map(value => ({ id: value.id, value })))
+* grid.layout.pin('name', 'left')
+* grid.editing.edit(row.id, 'progress')
+* ```
+*/
+/**
+* Creates a data grid instance with layout, editing, row ordering, and spanning
+* layered on top of the createDataTable pipeline.
+*
+* Rows live on the inherited registry surface — register them with
+* `grid.onboard(rows.map(value => ({ id: value.id, value })))` or
+* `grid.register({ id, value })`.
+*
+* @param options Data grid options
+* @returns Data grid context
+*
+* @example
+* ```ts
+* const grid = createDataGrid({ pagination: { initial: 1 } })
+*
+* grid.columns.onboard([
+*   { id: 'name', sortable: true },
+*   { id: 'progress', editable: true, validate: v => Number(v) >= 0 || 'must be positive' },
+* ])
+*
+* grid.onboard(rows.map(value => ({ id: value.id, value })))
+* grid.layout.pin('name', 'left')
+* grid.rows.move(rowId, 0)
+* grid.editing.edit(row.id, 'progress')
+* ```
+*/
+function createDataGrid(_options = {}) {
+	const { editing: editingOptions, preserveRowOrder = false, rowSpanning, ...options } = _options;
+	const table = createDataTable(options);
+	const sortable = createSortable({ reactive: true });
+	const dirty = shallowRef(false);
+	table.on("register:ticket", (ticket) => {
+		sortable.register({
+			id: ticket.id,
+			value: ticket.id
+		});
+	});
+	table.on("unregister:ticket", (ticket) => {
+		sortable.unregister(ticket.id);
+	});
+	table.on("clear:registry", () => {
+		sortable.clear();
+		dirty.value = false;
+	});
+	const order = toRef(() => sortable.keys());
+	const sortedIds = computed(() => {
+		const buckets = /* @__PURE__ */ new Map();
+		for (const ticket of table.values()) {
+			const value = ticket.value;
+			const queue = buckets.get(value);
+			if (queue) queue.push(ticket.id);
+			else buckets.set(value, [ticket.id]);
+		}
+		const ids = [];
+		for (const value of table.sortedItems.value) {
+			const id = buckets.get(value)?.shift();
+			if (!/* @__PURE__ */ isUndefined(id)) ids.push(id);
+		}
+		return ids;
+	});
+	function move(id, toIndex) {
+		if (!dirty.value) {
+			const sorted = sortedIds.value;
+			const seen = new Set(sorted);
+			const rest = sortable.keys().filter((key) => !seen.has(key));
+			sortable.reorder([...sorted, ...rest]);
+		}
+		sortable.move(id, toIndex);
+		dirty.value = true;
+	}
+	function reset() {
+		if (sortable.size > 0) sortable.reorder(table.keys());
+		dirty.value = false;
+	}
+	useToggleScope(() => !toValue(preserveRowOrder), () => {
+		watch(table.sort.columns, reset, { flush: "sync" });
+	});
+	const page = computed(() => {
+		if (!dirty.value) {
+			const start = table.pagination.pageStart.value;
+			return {
+				items: table.items.value,
+				ids: table.total.value > table.sortedItems.value.length ? sortedIds.value : sortedIds.value.slice(start, start + table.items.value.length)
+			};
+		}
+		const sorted = table.sortedItems.value;
+		const ids = sortedIds.value;
+		const byId = /* @__PURE__ */ new Map();
+		for (let i = 0; i < sorted.length; i++) byId.set(ids[i], sorted[i]);
+		const seen = new Set(order.value);
+		const items = [];
+		const ordered = [];
+		for (const id of order.value) {
+			const value = byId.get(id);
+			if (!/* @__PURE__ */ isUndefined(value)) {
+				items.push(value);
+				ordered.push(id);
+			}
+		}
+		for (const [i, element] of sorted.entries()) {
+			const id = ids[i];
+			if (!seen.has(id)) {
+				items.push(element);
+				ordered.push(id);
+			}
+		}
+		if (table.total.value > sorted.length) return {
+			items,
+			ids: ordered
+		};
+		const start = table.pagination.pageStart.value;
+		const stop = table.pagination.pageStop.value;
+		return {
+			items: items.slice(start, stop),
+			ids: ordered.slice(start, stop)
+		};
+	});
+	const pageOrderedItems = toRef(() => page.value.items);
+	const layout = createColumnLayout(table.columns);
+	function lookup(row) {
+		return table.get(row)?.value;
+	}
+	const editing = createCellEditing({
+		columns: () => table.leaves.value.filter((col) => col.editable === true || /* @__PURE__ */ isFunction(col.editable)).map((col) => ({
+			id: String(col.id),
+			editable: col.editable,
+			validate: col.validate
+		})),
+		lookup,
+		registry: table,
+		onEdit: editingOptions?.onEdit ? (row, column, value) => {
+			const item = lookup(row);
+			if (!/* @__PURE__ */ isUndefined(item)) editingOptions.onEdit(row, column, value, item);
+		} : void 0
+	});
+	const spans = createRowSpanning({
+		items: pageOrderedItems,
+		columns: () => table.leaves.value.map((col) => col.id),
+		key: (_item, index) => page.value.ids[index],
+		span(item, column) {
+			const col = table.leaves.value.find((leaf) => String(leaf.id) === column);
+			if (col && /* @__PURE__ */ isFunction(col.span)) return col.span(item);
+			return rowSpanning?.(item, column) ?? 1;
+		}
+	});
+	return {
+		...table,
+		items: pageOrderedItems,
+		layout,
+		rows: {
+			order,
+			move,
+			reset
+		},
+		editing,
+		spans,
+		get size() {
+			return table.size;
+		}
+	};
+}
+/**
+* Creates a data grid context with dependency injection support.
 *
-* @see https://0.vuetifyjs.com/composables/forms/create-combobox
+* @param options Data grid context options including namespace
+* @returns A trinity tuple: [useDataGridContext, provideDataGridContext, defaultContext]
 *
 * @example
 * ```ts
-* import { createComboboxContext } from '@vuetify/v0'
-*
-* const [useCombobox, provideCombobox, combobox] = createComboboxContext({
-*   namespace: 'my-combobox',
-*   strict: true,
+* const [useDataGrid, provideDataGrid, grid] = createDataGridContext({
+*   namespace: 'v0:projects',
 * })
+*
+* grid.columns.onboard(columns)
+* grid.onboard(rows.map(value => ({ id: value.id, value })))
+* provideDataGrid()
+* const ctx = useDataGrid()
 * ```
 */
-function createComboboxContext(options = {}) {
-	const { namespace = "v0:combobox", ...rest } = options;
-	return createTrinity(namespace, createCombobox(rest));
+function createDataGridContext(_options = {}) {
+	const { namespace = "v0:data-grid", ...options } = _options;
+	const [useDataGridContext, _provideDataGridContext] = createContext(namespace);
+	const context = createDataGrid(options);
+	function provideDataGridContext(_context = context, app) {
+		return _provideDataGridContext(_context, app);
+	}
+	return createTrinity(useDataGridContext, provideDataGridContext, 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.
+* Returns the current data grid context from dependency injection.
 *
-* @see https://0.vuetifyjs.com/composables/forms/create-combobox
+* @param namespace The namespace for the data grid context. @default 'v0:data-grid'
+* @returns The current data grid context
 *
 * @example
 * ```ts
-* import { useCombobox } from '@vuetify/v0'
+* const grid = useDataGrid<Project>()
 *
-* const combobox = useCombobox()
-* combobox.query.value = 'search term'
+* grid.layout.pin('id', 'left')
+* grid.rows.reset()
 * ```
 */
-function useCombobox(namespace = "v0:combobox") {
+function useDataGrid(namespace = "v0:data-grid") {
 	return useContext(namespace);
 }
 //#endregion
@@ -1220,147 +2334,6 @@ function createInput(options) {
 	};
 }
 //#endregion
-//#region src/composables/createSortable/index.ts
-/**
-* @module createSortable
-*
-* @see https://0.vuetifyjs.com/composables/data/create-sortable
-*
-* @remarks
-* Headless ordered-list primitive. Extends `createModel` with mutation primitives
-* (`swap`, `reorder`) and an enriched `move:ticket` event on the registry event
-* bus. Honors `disabled` as a real mutation gate at both root and per-ticket scope.
-*
-* Pure logical composable — no DnD, no DOM, no keyboard. Drag-and-drop integration
-* composes with `useDragDrop`; keyboard reorder composes with `useVirtualFocus`.
-*
-* @example
-* ```ts
-* import { createSortable } from '@vuetify/v0'
-* import type { SortableTicketInput } from '@vuetify/v0'
-*
-* interface TaskTicket extends SortableTicketInput {
-*   value: { id: number; label: string }
-* }
-*
-* const sortable = createSortable<TaskTicket>()
-* const a = sortable.register({ value: { id: 1, label: 'A' } })
-* const b = sortable.register({ value: { id: 2, label: 'B' } })
-*
-* sortable.move(a.id, 1)
-* sortable.on('move:ticket', ({ ticket, from, to }) => {
-*   console.log(`${ticket.value.label} moved ${from} → ${to}`)
-* })
-* ```
-*/
-/**
-* Create an ordered-list state primitive.
-*
-* @param options Sortable options.
-* @returns A {@link SortableContext} that extends {@link ModelContext}.
-*
-* @example
-* ```ts
-* const sortable = createSortable<Todo>()
-* sortable.onboard(todos.value.map(value => ({ value })))
-* ```
-*/
-function createSortable(_options = {}) {
-	const { disabled, ...options } = _options;
-	const model = createModel({
-		...options,
-		events: true,
-		disabled
-	});
-	const logger = useLogger();
-	function move(id, toIndex) {
-		if (toValue(disabled)) return void 0;
-		const ticket = model.get(id);
-		if (!ticket) return void 0;
-		if (toValue(ticket.disabled)) return void 0;
-		const from = ticket.index;
-		const result = model.move(id, toIndex);
-		if (result && result.index !== from) model.emit("move:ticket", {
-			ticket: result,
-			from,
-			to: result.index
-		});
-		return result;
-	}
-	function swap(a, b) {
-		if (toValue(disabled)) return;
-		if (a === b) return;
-		const ta = model.get(a);
-		const tb = model.get(b);
-		if (!ta || !tb) return;
-		if (toValue(ta.disabled) || toValue(tb.disabled)) return;
-		const indexA = ta.index;
-		const indexB = tb.index;
-		model.batch(() => {
-			const ra = model.move(a, indexB);
-			if (ra && ra.index !== indexA) model.emit("move:ticket", {
-				ticket: ra,
-				from: indexA,
-				to: ra.index
-			});
-			const rb = model.move(b, indexA);
-			if (rb && rb.index !== indexB) model.emit("move:ticket", {
-				ticket: rb,
-				from: indexB,
-				to: rb.index
-			});
-		});
-	}
-	function reorder(ids) {
-		if (toValue(disabled)) return;
-		const currentSize = model.size;
-		if (ids.length !== currentSize) {
-			logger.warn(`Reorder expected ${currentSize} ids, got ${ids.length}.`);
-			return;
-		}
-		const known = new Set(model.keys());
-		const seen = /* @__PURE__ */ new Set();
-		for (const id of ids) {
-			if (!known.has(id)) {
-				logger.warn(`Reorder contains unknown id "${String(id)}".`);
-				return;
-			}
-			if (seen.has(id)) {
-				logger.warn(`Reorder contains duplicate id "${String(id)}".`);
-				return;
-			}
-			seen.add(id);
-		}
-		const froms = /* @__PURE__ */ new Map();
-		for (const id of ids) {
-			const ticket = model.get(id);
-			if (ticket) froms.set(id, ticket.index);
-		}
-		model.batch(() => {
-			model.reorder(ids);
-			for (const [index, id] of ids.entries()) {
-				const from = froms.get(id);
-				if (from === index) continue;
-				const ticket = model.get(id);
-				if (ticket) model.emit("move:ticket", {
-					ticket,
-					from,
-					to: index
-				});
-			}
-		});
-	}
-	return {
-		...model,
-		move,
-		swap,
-		reorder,
-		get size() {
-			return model.size;
-		}
-	};
-}
-//#endregion
 //#region src/composables/createKanban/index.ts
 /**
 * @module createKanban
@@ -2405,6 +3378,193 @@ function createNumberField(options = {}) {
 	};
 }
 //#endregion
+//#region src/composables/createOtp/index.ts
+/**
+* @module createOtp
+*
+* @see https://0.vuetifyjs.com/composables/forms/create-otp
+*
+* @remarks
+* Headless state for a fixed-length one-time-password / verification-code value.
+* Owns the joined string, per-character pattern matching, length contract,
+* completion edge detection with a decisional async `onComplete` hook, and
+* validation through `createInput`. Rendering, focus, and per-element event
+* wiring are the consumer's responsibility.
+*
+* @example
+* ```ts
+* import { createOtp } from '@vuetify/v0'
+*
+* const otp = createOtp({
+*   length: 6,
+*   pattern: 'numeric',
+*   onComplete: async value => {
+*     const ok = await verify(value)
+*     return ok
+*   },
+* })
+*
+* otp.write(0, '4')
+* otp.distribute('12345', 1) // returns 5; value becomes '412345'
+* otp.isComplete.value  // true
+* ```
+*/
+const PRESETS = {
+	numeric: /^[0-9]$/,
+	alphanumeric: /^[a-zA-Z0-9]$/,
+	alphabetic: /^[a-zA-Z]$/
+};
+const WARNED_PATTERNS = /* @__PURE__ */ new WeakSet();
+function createOtp(options = {}) {
+	const { value = shallowRef(""), length = 6, pattern = "numeric", disabled = false, readonly: _readonly = false, onComplete, ...inputOptions } = options;
+	const logger = useLogger();
+	const errorRef = shallowRef(false);
+	const errorMessagesRef = shallowRef(void 0);
+	const input = createInput({
+		...inputOptions,
+		value,
+		disabled,
+		readonly: _readonly,
+		error: errorRef,
+		errorMessages: errorMessagesRef
+	});
+	const lengthRef = toRef(() => toValue(length));
+	let lastCompleted = "";
+	function compile(resolved) {
+		if (/* @__PURE__ */ isString(resolved)) return PRESETS[resolved];
+		if (process.env.NODE_ENV !== "production" && !WARNED_PATTERNS.has(resolved)) {
+			WARNED_PATTERNS.add(resolved);
+			if (resolved.test("aa") || resolved.test("00")) logger.warn("createOtp: pattern matches multi-character input; per-character matching may behave unexpectedly");
+		}
+		return resolved;
+	}
+	function accepts(char) {
+		if (char.length !== 1) return false;
+		return compile(toValue(pattern)).test(char);
+	}
+	function filterAccepted(text) {
+		let out = "";
+		for (const ch of text) if (accepts(ch)) out += ch;
+		return out;
+	}
+	const isPending = shallowRef(false);
+	function isLocked() {
+		return toValue(disabled) || toValue(_readonly) || isPending.value;
+	}
+	function clearRejection() {
+		if (errorRef.value || errorMessagesRef.value) {
+			errorRef.value = false;
+			errorMessagesRef.value = void 0;
+		}
+	}
+	function write(index, char) {
+		if (isLocked()) return;
+		const max = toValue(lengthRef);
+		if (index < 0 || index >= max) return;
+		if (char === "") {
+			clearRejection();
+			value.value = value.value.slice(0, index);
+			return;
+		}
+		const first = char[0];
+		if (!accepts(first)) return;
+		clearRejection();
+		const current = value.value;
+		const head = current.slice(0, index);
+		const tail = current.slice(index + 1);
+		value.value = (head + first + tail).slice(0, max);
+	}
+	function distribute(text, index = 0) {
+		if (isLocked()) return 0;
+		const max = toValue(lengthRef);
+		const start = /* @__PURE__ */ clamp(index, 0, max);
+		const filtered = filterAccepted(text);
+		if (filtered.length === 0) return 0;
+		clearRejection();
+		const head = value.value.slice(0, start);
+		const next = (head + filtered).slice(0, max);
+		value.value = next;
+		return next.length - head.length;
+	}
+	function clear() {
+		if (isLocked()) return;
+		clearRejection();
+		lastCompleted = "";
+		value.value = "";
+	}
+	function fill(text) {
+		if (isLocked()) return;
+		const max = toValue(lengthRef);
+		const filtered = filterAccepted(text).slice(0, max);
+		if (text.length === 0 || filtered.length > 0) clearRejection();
+		value.value = filtered;
+	}
+	function reject() {
+		errorRef.value = true;
+		errorMessagesRef.value = ["Invalid code"];
+		lastCompleted = "";
+		value.value = "";
+	}
+	const isComplete = toRef(() => {
+		const max = toValue(lengthRef);
+		const v = value.value;
+		if (v.length !== max) return false;
+		const re = compile(toValue(pattern));
+		for (const ch of v) if (!re.test(ch)) return false;
+		return true;
+	});
+	watch(value, (next) => {
+		if (!isComplete.value) {
+			lastCompleted = "";
+			return;
+		}
+		if (!onComplete) return;
+		if (isLocked()) return;
+		if (next === lastCompleted) return;
+		lastCompleted = next;
+		let result;
+		try {
+			result = onComplete(next);
+		} catch (error) {
+			logger.warn("createOtp: onComplete threw", error);
+			reject();
+			return;
+		}
+		if (/* @__PURE__ */ isThenable(result)) {
+			isPending.value = true;
+			result.then((ok) => {
+				isPending.value = false;
+				if (ok === false) reject();
+			}, (error) => {
+				isPending.value = false;
+				logger.warn("createOtp: onComplete rejected", error);
+				reject();
+			});
+			return;
+		}
+		if (result === false) reject();
+	});
+	return {
+		value,
+		length: lengthRef,
+		input: {
+			...input,
+			reset() {
+				clearRejection();
+				lastCompleted = "";
+				input.reset();
+			}
+		},
+		isComplete,
+		isValidating: isPending,
+		write,
+		distribute,
+		clear,
+		fill,
+		accepts
+	};
+}
+//#endregion
 //#region src/composables/useHydration/index.ts
 /**
 * @module useHydration
@@ -2808,7 +3968,7 @@ function useElementSize(target) {
 	return {
 		width: shallowReadonly(width),
 		height: shallowReadonly(height),
-		isActive,
+		isActive: shallowReadonly(isActive),
 		isPaused: shallowReadonly(isPaused),
 		pause,
 		resume,
@@ -2836,6 +3996,20 @@ function useElementSize(target) {
 * Use variable mode (default) for items with different widths like Breadcrumbs.
 * Use uniform mode (itemWidth option) for same-width items like Pagination buttons.
 *
+* ## Item registration contract
+*
+* Every child item must call `measure(index, el)` on mount and
+* `measure(index, undefined)` on unmount, regardless of mode. The width arg
+* is recorded in both modes but **only consumed by uniform mode for
+* isOverflowing's count** — capacity in uniform mode is derived purely
+* from `itemWidth`. Variable mode uses the per-item widths for both
+* capacity and isOverflowing.
+*
+* Consumers that compute their own capacity outside this composable (e.g.,
+* with a separate registry) still need the measure() calls if they want
+* `isOverflowing` to reflect reality — without them the count source is
+* empty and the signal is permanently false.
+*
 * @example
 * ```ts
 * import { useTemplateRef } from 'vue'
@@ -2906,8 +4080,8 @@ function createOverflow(options = {}) {
 		/* v8 ignore start -- browser-only measurement code */
 		if (!IN_BROWSER) return;
 		const style = getComputedStyle(el);
-		const marginX = Number.parseFloat(style.marginLeft) + Number.parseFloat(style.marginRight);
-		const w = el.offsetWidth + marginX;
+		const marginX = (Number.parseFloat(style.marginLeft) || 0) + (Number.parseFloat(style.marginRight) || 0);
+		const w = (el.offsetWidth || 0) + marginX;
 		if (widths.value.get(index) !== w) widths.value = new Map(widths.value).set(index, w);
 		/* v8 ignore stop */
 	}
@@ -2924,36 +4098,42 @@ function createOverflow(options = {}) {
 		}
 		return sum;
 	});
+	const capacity = computed(() => {
+		const available = width.value - toValue(reserved);
+		if (width.value === 0) return Infinity;
+		if (available <= 0) return 0;
+		const g = toValue(gap);
+		const uniformWidth = toValue(itemWidth) ?? 0;
+		if (!/* @__PURE__ */ isUndefined(itemWidth) && uniformWidth <= 0) return Infinity;
+		if (uniformWidth > 0) {
+			const subsequent = uniformWidth + g;
+			if (available < uniformWidth) return 0;
+			return Math.max(1, Math.floor((available - uniformWidth) / subsequent) + 1);
+		}
+		const entries = [...widths.value.entries()].toSorted((a, b) => a[0] - b[0]);
+		if (toValue(reverse)) entries.reverse();
+		let sum = 0;
+		let count = 0;
+		for (const [, w] of entries) {
+			const next = sum + w + (count > 0 ? g : 0);
+			if (next > available) break;
+			sum = next;
+			count++;
+		}
+		return count;
+	});
 	return {
 		container,
-		width,
-		capacity: computed(() => {
-			const available = width.value - toValue(reserved);
-			if (width.value === 0) return Infinity;
-			if (available <= 0) return 0;
-			const g = toValue(gap);
-			const uniformWidth = toValue(itemWidth) ?? 0;
-			if (!/* @__PURE__ */ isUndefined(itemWidth) && uniformWidth <= 0) return Infinity;
-			if (uniformWidth > 0) {
-				const subsequent = uniformWidth + g;
-				if (available < uniformWidth) return 0;
-				return Math.max(1, Math.floor((available - uniformWidth) / subsequent) + 1);
-			}
-			const entries = [...widths.value.entries()].toSorted((a, b) => a[0] - b[0]);
-			if (toValue(reverse)) entries.reverse();
-			let sum = 0;
-			let count = 0;
-			for (const [, w] of entries) {
-				const next = sum + w + (count > 0 ? g : 0);
-				if (next > available) break;
-				sum = next;
-				count++;
-			}
-			return count;
-		}),
+		width,
+		capacity,
 		total,
 		isOverflowing: toRef(() => {
 			if (width.value === 0) return false;
+			if (!/* @__PURE__ */ isUndefined(itemWidth)) {
+				const cap = capacity.value;
+				if (cap === Infinity) return false;
+				return widths.value.size > cap;
+			}
 			return total.value > width.value - toValue(reserved);
 		}),
 		measure,
@@ -4226,6 +5406,124 @@ function useVirtual(namespace = "v0:virtual") {
 	return useContext(namespace);
 }
 //#endregion
+//#region src/composables/toHighlight/index.ts
+/**
+* @module toHighlight
+*
+* @see https://0.vuetifyjs.com/composables/transformers/to-highlight
+*
+* @remarks
+* Pure transformer — no DOM, no state, no registry, no reactivity. Splits text
+* into matched and unmatched chunks given a query string, an array of query
+* strings, or pre-computed `[start, end]` match ranges (e.g., from createFilter).
+* Returns a plain array; wrap the call in `computed()` for reactive recomputation.
+*
+* @example
+* ```ts
+* import { toHighlight } from '@vuetify/v0'
+*
+* const chunks = toHighlight('Hello World', 'World')
+* // [{ text: 'Hello ', match: false }, { text: 'World', match: true }]
+* ```
+*/
+function merge(ranges) {
+	const sorted = ranges.filter((span) => span[0] < span[1]).toSorted((a, b) => a[0] - b[0]);
+	const merged = [];
+	for (const span of sorted) {
+		const last = merged.at(-1);
+		if (last && span[0] <= last[1]) last[1] = Math.max(last[1], span[1]);
+		else merged.push([span[0], span[1]]);
+	}
+	return merged;
+}
+function chunk(text, ranges) {
+	const chunks = [];
+	let cursor = 0;
+	for (const [start, end] of ranges) {
+		if (cursor < start) chunks.push({
+			text: text.slice(cursor, start),
+			match: false
+		});
+		chunks.push({
+			text: text.slice(start, end),
+			match: true
+		});
+		cursor = end;
+	}
+	if (cursor < text.length) chunks.push({
+		text: text.slice(cursor),
+		match: false
+	});
+	return chunks;
+}
+function find(text, query, matchAll, ignoreCase) {
+	const terms = (/* @__PURE__ */ toArray(query)).filter(Boolean);
+	const haystack = ignoreCase ? text.toLocaleLowerCase() : text;
+	const spans = [];
+	for (const term of terms) {
+		const needle = ignoreCase ? term.toLocaleLowerCase() : term;
+		let index = haystack.indexOf(needle);
+		if (index !== -1) {
+			spans.push([index, index + term.length]);
+			if (matchAll) {
+				index = haystack.indexOf(needle, index + term.length);
+				while (index !== -1) {
+					spans.push([index, index + term.length]);
+					index = haystack.indexOf(needle, index + term.length);
+				}
+			}
+		}
+	}
+	return merge(spans);
+}
+/**
+* Splits text into matched and unmatched chunks.
+*
+* Pure transformer — returns a plain array. Wrap the call in `computed()` for
+* reactive recomputation.
+*
+* Priority: `options.matches` (when non-empty) → `query` → no-match fallback.
+*
+* @param text The source string to split.
+* @param query One or more search terms. Empty strings are ignored. Case sensitivity controlled by `options.ignoreCase`.
+* @param options Optional `matches`, `matchAll`, `ignoreCase`.
+* @returns A `HighlightChunk[]` array.
+*
+* @see https://0.vuetifyjs.com/composables/transformers/to-highlight
+*
+* @example
+* ```ts
+* import { computed, shallowRef } from 'vue'
+* import { toHighlight } from '@vuetify/v0'
+*
+* const query = shallowRef('World')
+* const chunks = computed(() => toHighlight('Hello World', query))
+*
+* console.log(chunks.value)
+* // [{ text: 'Hello ', match: false }, { text: 'World', match: true }]
+* ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function toHighlight(text, query, options = {}) {
+	const _text = toValue(text);
+	const _query = toValue(query);
+	const _matches = toValue(options.matches);
+	const matchAll = toValue(options.matchAll) ?? false;
+	const ignoreCase = toValue(options.ignoreCase) ?? false;
+	if (_matches?.length) return chunk(_text, merge(_matches));
+	if (_query) {
+		const ranges = find(_text, _query, matchAll, ignoreCase);
+		return ranges.length > 0 ? chunk(_text, ranges) : [{
+			text: _text,
+			match: false
+		}];
+	}
+	return [{
+		text: _text,
+		match: false
+	}];
+}
+//#endregion
 //#region src/composables/toReactive/index.ts
 /**
 * @module toReactive
@@ -4829,127 +6127,13 @@ function createDatePlugin(options) {
 * ```
 */
 function useDate(namespace = "v0:date") {
-	if (!/* @__PURE__ */ instanceExists()) throw new Error("[v0] useDate() must be called inside a Vue component with createDatePlugin installed.\n\nExample:\n  import { V0DateAdapter } from '@vuetify/v0/date'\n  import { createDatePlugin } from '@vuetify/v0'\n\n  app.use(createDatePlugin({ adapter: new V0DateAdapter() }))");
+	if (!/* @__PURE__ */ instanceExists()) throw new V0Error("[v0] useDate() must be called inside a Vue component with createDatePlugin installed.\n\nExample:\n  import { V0DateAdapter } from '@vuetify/v0/date'\n  import { createDatePlugin } from '@vuetify/v0'\n\n  app.use(createDatePlugin({ adapter: new V0DateAdapter() }))", {
+		code: "V0_PLUGIN_MISSING",
+		plugin: "createDatePlugin"
+	});
 	return useContext(namespace);
 }
 //#endregion
-//#region src/composables/useDelay/index.ts
-/**
-* @module useDelay
-*
-* @see https://0.vuetifyjs.com/composables/system/use-delay
-*
-* @remarks
-* Schedule open and close transitions with configurable delays.
-*
-* Composes `useTimer` for the underlying lifecycle (start / stop / pause / resume,
-* plus reactive `isActive`, `isPaused`, `remaining`) and adds direction tracking
-* (`isOpening`) and promise-based resolution.
-*
-* Key features:
-* - Reactive `openDelay` and `closeDelay` via `MaybeRefOrGetter`
-* - `start(isOpening)` returns a `Promise<boolean>` that resolves once the delay elapses
-* - Per-call `minDelay` floor enforces a minimum delay
-* - Automatic cleanup on scope disposal (timer cleared, pending promise settled with current direction)
-* - SSR-safe
-*
-* @example
-* ```ts
-* import { useDelay } from '@vuetify/v0'
-*
-* const delay = useDelay(isOpening => isVisible.value = isOpening, {
-*   openDelay: 300,
-*   closeDelay: 200,
-* })
-*
-* delay.start(true)
-* delay.start(false, { minDelay: 500 })
-* ```
-*/
-/**
-* Schedule open and close transitions with configurable delays.
-*
-* Composes `useTimer` for the lifecycle (`start` / `stop` / `pause` / `resume` plus
-* reactive `isActive`, `isPaused`, `remaining`) and adds direction tracking
-* (`isOpening`) and promise-based resolution.
-*
-* @param callback Optional callback invoked once a started delay elapses; receives the resolved direction.
-* @param options Reactive delay settings.
-* @returns Lifecycle controls and reactive state.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-delay
-*
-* @example
-* ```ts
-* const delay = useDelay(isOpening => isVisible.value = isOpening, {
-*   openDelay: 300,
-*   closeDelay: 200,
-* })
-*
-* delay.start(true)
-* delay.start(false, { minDelay: 500 })
-* delay.pause()
-* delay.resume()
-* delay.stop()
-* ```
-*/
-function useDelay(callback, options = {}) {
-	const { openDelay, closeDelay } = options;
-	const isOpening = shallowRef(false);
-	let minDelay = 0;
-	let resolver;
-	function fire() {
-		const direction = isOpening.value;
-		const resolve = resolver;
-		resolver = void 0;
-		resolve?.(direction);
-		callback?.(direction);
-	}
-	function duration() {
-		const raw = isOpening.value ? toValue(openDelay) : toValue(closeDelay);
-		return Math.max(minDelay, raw ?? 0);
-	}
-	const timer = useTimer(fire, { duration });
-	function start(direction, options = {}) {
-		const previous = resolver;
-		resolver = void 0;
-		isOpening.value = direction;
-		minDelay = options.minDelay ?? 0;
-		previous?.(direction);
-		const ms = duration();
-		return new Promise((resolve) => {
-			resolver = resolve;
-			if (ms <= 0) {
-				timer.stop();
-				fire();
-				return;
-			}
-			timer.start();
-		});
-	}
-	function stop() {
-		const resolve = resolver;
-		resolver = void 0;
-		timer.stop();
-		resolve?.(isOpening.value);
-	}
-	onScopeDispose(() => {
-		const resolve = resolver;
-		resolver = void 0;
-		resolve?.(isOpening.value);
-	}, true);
-	return {
-		start,
-		stop,
-		pause: timer.pause,
-		resume: timer.resume,
-		isActive: shallowReadonly(timer.isActive),
-		isPaused: shallowReadonly(timer.isPaused),
-		remaining: shallowReadonly(timer.remaining),
-		isOpening: shallowReadonly(isOpening)
-	};
-}
-//#endregion
 //#region src/composables/useMutationObserver/index.ts
 /**
 * @module useMutationObserver
@@ -7473,114 +8657,77 @@ function createStorageFallback() {
 }
 const [createStorageContext, createStoragePlugin, useStorage] = createPluginContext("v0:storage", (options) => createStorage(options), { fallback: () => createStorageFallback() });
 //#endregion
-//#region src/composables/useToggleScope/index.ts
+//#region src/composables/useTooltip/index.ts
 /**
-* @module useToggleScope
+* @module useTooltip
 *
-* @see https://0.vuetifyjs.com/composables/system/use-toggle-scope
+* @see https://0.vuetifyjs.com/composables/plugins/use-tooltip
 *
 * @remarks
-* Conditionally manages an effect scope based on a reactive boolean condition.
-* When the source becomes true, creates and runs an effect scope. When false, stops the scope.
-* All reactive effects created within the scoped function are automatically cleaned up on deactivation.
-*
-* Key features:
-* - Uses Vue's effectScope for efficient reactive effect lifecycle management
-* - Automatic cleanup when condition becomes false
-* - Supports optional reset callback for scope restart capability
-* - Handles rapid toggling and parent scope disposal safely
-* - SSR-safe (effectScope is part of Vue core)
+* Region-scoped tooltip coordination plugin. Holds shared delay defaults and
+* a small registry of currently-open tooltips so individual tooltip instances
+* can skip their open delay when another tooltip is already visible (the
+* "warmup" pattern from React Aria / Radix).
 *
-* Perfect for conditional side effects, feature flags, and performance optimization
-* by only running reactive effects when needed.
+* Use the plugin form (`app.use(createTooltipPlugin())`) for app-wide
+* defaults.
 *
 * @example
 * ```ts
-* import { shallowRef } from 'vue'
-* import { useToggleScope } from '@vuetify/v0'
+* import { createTooltipPlugin } from '@vuetify/v0'
 *
-* const isEnabled = shallowRef(false)
-* const { isActive } = useToggleScope(isEnabled, () => {
-*   // effects run while isEnabled is true
-* })
+* app.use(createTooltipPlugin({ openDelay: 500 }))
 * ```
 */
+function createTooltip(options = {}) {
+	const openDelay = toRef(() => toValue(options.openDelay) ?? 700);
+	const closeDelay = toRef(() => toValue(options.closeDelay) ?? 150);
+	const skipDelay = toRef(() => toValue(options.skipDelay) ?? 300);
+	const disabled = toRef(() => toValue(options.disabled) ?? false);
+	const registry = createRegistry({
+		reactive: true,
+		events: true
+	});
+	let lastClosedAt = null;
+	registry.on("unregister:ticket", () => {
+		lastClosedAt = Date.now();
+	});
+	const isAnyOpen = toRef(() => registry.size > 0);
+	function shouldSkipOpenDelay() {
+		if (isAnyOpen.value) return true;
+		if (/* @__PURE__ */ isNull(lastClosedAt)) return false;
+		return Date.now() - lastClosedAt < skipDelay.value;
+	}
+	onScopeDispose(() => registry.dispose(), true);
+	return {
+		openDelay,
+		closeDelay,
+		skipDelay,
+		disabled,
+		isAnyOpen,
+		shouldSkipOpenDelay,
+		register: registry.register,
+		unregister: registry.unregister
+	};
+}
 /**
-* Conditionally manages an effect scope based on a reactive boolean source.
-*
-* @param source A reactive boolean value or getter that controls the scope lifecycle
-* @param fn The function to run within the effect scope. Can optionally receive controls for manual scope management.
-* @returns Controls object with isActive state and start/stop/reset methods
-*
-* @see https://vuejs.org/api/reactivity-advanced.html#effectscope
-* @see https://0.vuetifyjs.com/composables/system/use-toggle-scope
-*
-* @example
-* ```ts
-* import { ref } from 'vue'
-* import { useToggleScope } from '@vuetify/v0'
-*
-* const isEnabled = ref(false)
-*
-* const { isActive } = useToggleScope(isEnabled, () => {
-*   // This code runs when isEnabled becomes true
-*   const unwatch = watch(someRef, () => {
-*     console.log('Watching...')
-*   })
-*
-*   // Cleanup happens automatically when isEnabled becomes false
-* })
-*
-* // Toggle the scope on/off
-* isEnabled.value = true  // Starts the scope
-* console.log(isActive.value) // true
-* isEnabled.value = false // Stops and cleans up
-* console.log(isActive.value) // false
-* ```
+* Synthesized fallback used when `useTooltip()` is called without
+* `app.use(createTooltipPlugin())`. Returns a fresh context with the
+* documented defaults — `<Tooltip.Root>` keeps working but warmup
+* coordination is per-instance instead of region-wide.
 *
 * @example
-* With manual controls:
 * ```ts
-* const isEnabled = ref(true)
-*
-* useToggleScope(isEnabled, (controls) => {
-*   // Access controls inside the scope
-*   console.log('Active:', controls.isActive.value)
+* import { createTooltipFallback } from '@vuetify/v0'
 *
-*   // Manually reset the scope if needed
-*   someEvent.on('reset', () => controls.reset())
-* })
+* const tooltip = createTooltipFallback()
+* console.log(tooltip.openDelay.value) // 700
 * ```
 */
-function useToggleScope(source, fn) {
-	const scope = shallowRef();
-	const isActive = toRef(() => !!scope.value);
-	function start() {
-		if (scope.value) return;
-		scope.value = effectScope();
-		scope.value.run(() => fn.length > 0 ? fn(controls) : fn());
-	}
-	function stop() {
-		scope.value?.stop();
-		scope.value = void 0;
-	}
-	function reset() {
-		stop();
-		start();
-	}
-	const controls = {
-		isActive: shallowReadonly(isActive),
-		start,
-		stop,
-		reset
-	};
-	watch(source, (active) => {
-		if (active && !scope.value) start();
-		else if (!active) stop();
-	}, { immediate: true });
-	onScopeDispose(stop, true);
-	return controls;
+function createTooltipFallback() {
+	return createTooltip();
 }
+const [createTooltipContext, createTooltipPlugin, useTooltip] = createPluginContext("v0:tooltip", createTooltip, { fallback: () => createTooltipFallback() });
 //#endregion
 //#region src/composables/useEventListener/index.ts
 /**
@@ -7957,4 +9104,4 @@ function useClickOutside(target, handler, options = {}) {
 	};
 }
 //#endregion
-export { useTimeline as $, useIntersectionObserver as A, createForm as At, createDateContext as B, usePopover as Bt, usePresence as C, createNested as Ct, usePrefersReducedMotion as D, createSortable as Dt, usePrefersDark as E, createKanban as Et, PointerAdapter as F, useCombobox as Ft, createBreakpointsPlugin as G, useDate as H, createBreadcrumbsContext as Ht, DragDropAdapter as I, ServerComboboxAdapter as It, createVirtual as J, useBreakpoints as K, useMutationObserver as L, ClientComboboxAdapter as Lt, useHotkey as M, useForm as Mt, useDragDrop as N, createCombobox as Nt, useLazy as O, createInput as Ot, KeyboardAdapter as P, createComboboxContext as Pt, createTimelineContext as Q, useDelay as R, ComboboxAdapter as Rt, useProxyModel as S, createNumeric as St, usePrefersContrast as T, useNested as Tt, createBreakpoints as U, useBreadcrumbs as Ut, createDatePlugin as V, createBreadcrumbs as Vt, createBreakpointsContext as W, useVirtual as X, createVirtualContext as Y, createTimeline as Z, createRtlPlugin as _, createHydration as _t, useToggleScope as a, createRatingContext as at, useRovingFocus as b, useHydration as bt, createStoragePlugin as c, createProgressContext as ct, createStackContext as d, createOverflowContext as dt, createStep as et, createStackPlugin as f, useOverflow as ft, createRtlFallback as g, createFallbackHydration as gt, createRtlContext as h, toElement as ht, useWindowEventListener as i, createRating as it, useImage as j, createFormContext as jt, useElementIntersection as k, createValidation as kt, useStorage as l, useProgress as lt, createRtl as m, useResizeObserver as mt, useDocumentEventListener as n, useStep as nt, createStorage as o, useRating as ot, useStack as p, useElementSize as pt, toReactive as q, useEventListener as r, createSlider as rt, createStorageContext as s, createProgress as st, useClickOutside as t, createStepContext as tt, createStack as u, createOverflow as ut, useRtl as v, createHydrationContext as vt, useMediaQuery as w, createNestedContext as wt, useRaf as x, createNumberField as xt, V0RtlAdapter as y, createHydrationPlugin as yt, createDate as z, useVirtualFocus as zt };
+export { useVirtual as $, usePrefersReducedMotion as A, createKanban as At, useMutationObserver as B, createSortable as Bt, useRovingFocus as C, useHydration as Ct, useMediaQuery as D, createNested as Dt, usePresence as E, createNumeric as Et, useHotkey as F, useForm as Ft, createBreakpoints as G, ClientComboboxAdapter as Gt, createDateContext as H, createComboboxContext as Ht, useDragDrop as I, createDataGrid as It, useBreakpoints as J, usePopover as Jt, createBreakpointsContext as K, ComboboxAdapter as Kt, KeyboardAdapter as L, createDataGridContext as Lt, useElementIntersection as M, createValidation as Mt, useIntersectionObserver as N, createForm as Nt, usePrefersContrast as O, createNestedContext as Ot, useImage as P, createFormContext as Pt, createVirtualContext as Q, useBreadcrumbs as Qt, PointerAdapter as R, useDataGrid as Rt, V0RtlAdapter as S, createHydrationPlugin as St, useProxyModel as T, createNumberField as Tt, createDatePlugin as U, useCombobox as Ut, createDate as V, createCombobox as Vt, useDate as W, ServerComboboxAdapter as Wt, toHighlight as X, createBreadcrumbs as Xt, toReactive as Y, useDelay as Yt, createVirtual as Z, createBreadcrumbsContext as Zt, createRtl as _, useResizeObserver as _t, createTooltipContext as a, useStep as at, createRtlPlugin as b, createHydration as bt, useTooltip as c, createRatingContext as ct, createStoragePlugin as d, createProgressContext as dt, createTimeline as et, useStorage as f, useProgress as ft, useStack as g, useElementSize as gt, createStackPlugin as h, useOverflow as ht, useWindowEventListener as i, createStepContext as it, useLazy as j, createInput as jt, usePrefersDark as k, useNested as kt, createStorage as l, useRating as lt, createStackContext as m, createOverflowContext as mt, useDocumentEventListener as n, useTimeline as nt, createTooltipFallback as o, createSlider as ot, createStack as p, createOverflow as pt, createBreakpointsPlugin as q, useVirtualFocus as qt, useEventListener as r, createStep as rt, createTooltipPlugin as s, createRating as st, useClickOutside as t, createTimelineContext as tt, createStorageContext as u, createProgress as ut, createRtlContext as v, toElement as vt, useRaf as w, createOtp as wt, useRtl as x, createHydrationContext as xt, createRtlFallback as y, createFallbackHydration as yt, DragDropAdapter as z, useToggleScope as zt };