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

package/dist/{useClickOutside-DbOLg1uw.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-BRdxsC2M.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-1_ZeBY12.mjs";
-import { t as createRegistry } from "./createRegistry-CWpvSbCe.mjs";
-import { i as createModel, t as createSelection } from "./createSelection-MRyUZyW2.mjs";
-import { t as createSingle } from "./createSingle-BSciC9EJ.mjs";
-import "./createTokens-CQ9C7GTV.mjs";
-import { a as useLocale } from "./useLocale-Sh-2sNiG.mjs";
-import { c as useTimer } from "./useNotifications-CAVQ7hK6.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-BFSJsyv7.mjs";
-import { t as createGroup } from "./createGroup-aHt_kvtU.mjs";
-import "./createDataTable-H-PuVigU.mjs";
-import { a as useRules, o as isStandardSchema } from "./useRules-DK4AeNeC.mjs";
-import "./useFeatures-Dhnr-Lg2.mjs";
-import "./usePermissions-D9Oituwy.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-FMDQC81h.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,
@@ -826,135 +942,1133 @@ function useCombobox(namespace = "v0:combobox") {
 	return useContext(namespace);
 }
 //#endregion
-//#region src/composables/createForm/index.ts
+//#region src/composables/createSortable/index.ts
 /**
-* @module createForm
+* @module createSortable
 *
-* @see https://0.vuetifyjs.com/composables/forms/create-form
+* @see https://0.vuetifyjs.com/composables/data/create-sortable
 *
 * @remarks
-* Form composable that coordinates validation across multiple fields.
-*
-* Key features:
-* - Pure registry of ValidationContext instances
-* - Validations auto-register via useForm() injection
-* - Form-level submit, reset, and aggregate state
-* - Exposes disabled/readonly refs for component consumption
-* - Trinity pattern for DI
+* 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.
 *
-* Per-field validation logic lives in createValidation.
-* createForm is the mothership — it coordinates, not creates.
+* Pure logical composable — no DnD, no DOM, no keyboard. Drag-and-drop integration
+* composes with `useDragDrop`; keyboard reorder composes with `useVirtualFocus`.
 *
 * @example
 * ```ts
-* import { createForm } from '@vuetify/v0'
-*
-* const form = createForm()
-* const isValid = await form.validate()
-* if (isValid) form.submit()
-* ```
-*/
-/**
-* Creates a new form instance.
-*
-* A form is a pure registry of validation contexts. Validations register
-* themselves via `useForm()` injection. The form coordinates submit, reset,
-* and aggregate state across all registered validations.
-*
-* @param options The options for the form instance.
-* @returns A new form context.
-*
-* @see https://0.vuetifyjs.com/composables/forms/create-form
+* import { createSortable } from '@vuetify/v0'
+* import type { SortableTicketInput } from '@vuetify/v0'
 *
-* @example
-* ```ts
-* import { createForm, createValidation } from '@vuetify/v0'
-* import { shallowRef } from 'vue'
+* interface TaskTicket extends SortableTicketInput {
+*   value: { id: number; label: string }
+* }
 *
-* const form = createForm()
+* const sortable = createSortable<TaskTicket>()
+* const a = sortable.register({ value: { id: 1, label: 'A' } })
+* const b = sortable.register({ value: { id: 2, label: 'B' } })
 *
-* // Each validation is one input — form is just the coordinator
-* const email = shallowRef('')
-* const validation = createValidation({
-*   value: email,
-*   rules: ['required', 'email'],
+* sortable.move(a.id, 1)
+* sortable.on('move:ticket', ({ ticket, from, to }) => {
+*   console.log(`${ticket.value.label} moved ${from} → ${to}`)
 * })
-*
-* form.register({ value: validation })
-*
-* await form.submit()
-* form.reset()
 * ```
 */
-function createForm(options = {}) {
-	const { disabled = false, readonly = false, ..._options } = options;
-	const registry = createRegistry({
-		..._options,
-		reactive: true
-	});
-	const isValidating = computed(() => {
-		for (const ticket of registry.values()) if (ticket.value.isValidating.value) return true;
-		return false;
-	});
-	const isValid = computed(() => {
-		let hasNull = false;
-		let hasFields = false;
-		for (const ticket of registry.values()) {
-			hasFields = true;
-			if (ticket.value.isValid.value === false) return false;
-			if (/* @__PURE__ */ isNull(ticket.value.isValid.value)) hasNull = true;
-		}
-		if (!hasFields) return null;
-		return hasNull ? null : true;
-	});
-	function register(registration) {
-		return registry.register(registration);
-	}
-	function reset() {
-		for (const ticket of registry.values()) ticket.value.reset();
-	}
-	async function submit(id) {
-		const ids = id ? /* @__PURE__ */ toArray(id) : [...registry.keys()];
-		return (await Promise.all(ids.map(async (key) => {
-			const ticket = registry.get(key);
-			if (!ticket) return true;
-			return ticket.value.validate();
-		}))).every(Boolean);
-	}
-	return {
-		...registry,
-		register,
-		submit,
-		reset,
-		disabled,
-		readonly,
-		isValid,
-		isValidating,
-		get size() {
-			return registry.size;
-		}
-	};
-}
 /**
-* Creates a new form context using the Trinity pattern.
-*
-* @param options The options for the form context.
-* @returns A Trinity tuple: [useFormContext, provideFormContext, formContext]
+* Create an ordered-list state primitive.
 *
-* @see https://0.vuetifyjs.com/composables/forms/create-form
+* @param options Sortable options.
+* @returns A {@link SortableContext} that extends {@link ModelContext}.
 *
 * @example
 * ```ts
-* import { createFormContext } from '@vuetify/v0'
-*
-* export const [useMyForm, provideMyForm, myForm] = createFormContext()
+* const sortable = createSortable<Todo>()
+* sortable.onboard(todos.value.map(value => ({ value })))
 * ```
 */
-function createFormContext(_options = {}) {
-	const { namespace = "v0:form", ...options } = _options;
-	return createTrinity(namespace, createForm(options));
-}
-/**
+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.
+*
+* @param options Data grid context options including namespace
+* @returns A trinity tuple: [useDataGridContext, provideDataGridContext, defaultContext]
+*
+* @example
+* ```ts
+* 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 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);
+}
+/**
+* Returns the current data grid context from dependency injection.
+*
+* @param namespace The namespace for the data grid context. @default 'v0:data-grid'
+* @returns The current data grid context
+*
+* @example
+* ```ts
+* const grid = useDataGrid<Project>()
+*
+* grid.layout.pin('id', 'left')
+* grid.rows.reset()
+* ```
+*/
+function useDataGrid(namespace = "v0:data-grid") {
+	return useContext(namespace);
+}
+//#endregion
+//#region src/composables/createForm/index.ts
+/**
+* @module createForm
+*
+* @see https://0.vuetifyjs.com/composables/forms/create-form
+*
+* @remarks
+* Form composable that coordinates validation across multiple fields.
+*
+* Key features:
+* - Pure registry of ValidationContext instances
+* - Validations auto-register via useForm() injection
+* - Form-level submit, reset, and aggregate state
+* - Exposes disabled/readonly refs for component consumption
+* - Trinity pattern for DI
+*
+* Per-field validation logic lives in createValidation.
+* createForm is the mothership — it coordinates, not creates.
+*
+* @example
+* ```ts
+* import { createForm } from '@vuetify/v0'
+*
+* const form = createForm()
+* const isValid = await form.validate()
+* if (isValid) form.submit()
+* ```
+*/
+/**
+* Creates a new form instance.
+*
+* A form is a pure registry of validation contexts. Validations register
+* themselves via `useForm()` injection. The form coordinates submit, reset,
+* and aggregate state across all registered validations.
+*
+* @param options The options for the form instance.
+* @returns A new form context.
+*
+* @see https://0.vuetifyjs.com/composables/forms/create-form
+*
+* @example
+* ```ts
+* import { createForm, createValidation } from '@vuetify/v0'
+* import { shallowRef } from 'vue'
+*
+* const form = createForm()
+*
+* // Each validation is one input — form is just the coordinator
+* const email = shallowRef('')
+* const validation = createValidation({
+*   value: email,
+*   rules: ['required', 'email'],
+* })
+*
+* form.register({ value: validation })
+*
+* await form.submit()
+* form.reset()
+* ```
+*/
+function createForm(options = {}) {
+	const { disabled = false, readonly = false, ..._options } = options;
+	const registry = createRegistry({
+		..._options,
+		reactive: true
+	});
+	const isValidating = computed(() => {
+		for (const ticket of registry.values()) if (ticket.value.isValidating.value) return true;
+		return false;
+	});
+	const isValid = computed(() => {
+		let hasNull = false;
+		let hasFields = false;
+		for (const ticket of registry.values()) {
+			hasFields = true;
+			if (ticket.value.isValid.value === false) return false;
+			if (/* @__PURE__ */ isNull(ticket.value.isValid.value)) hasNull = true;
+		}
+		if (!hasFields) return null;
+		return hasNull ? null : true;
+	});
+	function register(registration) {
+		return registry.register(registration);
+	}
+	function reset() {
+		for (const ticket of registry.values()) ticket.value.reset();
+	}
+	async function submit(id) {
+		const ids = id ? /* @__PURE__ */ toArray(id) : [...registry.keys()];
+		return (await Promise.all(ids.map(async (key) => {
+			const ticket = registry.get(key);
+			if (!ticket) return true;
+			return ticket.value.validate();
+		}))).every(Boolean);
+	}
+	return {
+		...registry,
+		register,
+		submit,
+		reset,
+		disabled,
+		readonly,
+		isValid,
+		isValidating,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+/**
+* Creates a new form context using the Trinity pattern.
+*
+* @param options The options for the form context.
+* @returns A Trinity tuple: [useFormContext, provideFormContext, formContext]
+*
+* @see https://0.vuetifyjs.com/composables/forms/create-form
+*
+* @example
+* ```ts
+* import { createFormContext } from '@vuetify/v0'
+*
+* export const [useMyForm, provideMyForm, myForm] = createFormContext()
+* ```
+*/
+function createFormContext(_options = {}) {
+	const { namespace = "v0:form", ...options } = _options;
+	return createTrinity(namespace, createForm(options));
+}
+/**
 * Returns the current form instance.
 *
 * @param namespace The namespace for the form context. Defaults to `'v0:form'`.
@@ -1191,173 +2305,32 @@ function createInput(options) {
 		isPristine.value = true;
 		isTouched.value = false;
 		validation.reset();
-	}
-	return {
-		id,
-		label,
-		name,
-		form,
-		required,
-		descriptionId,
-		errorId,
-		descriptions,
-		fieldErrors,
-		hasDescription,
-		hasError,
-		value,
-		isDirty,
-		isFocused,
-		isDisabled,
-		isReadonly,
-		isPristine,
-		isTouched,
-		errors,
-		isValid,
-		isValidating: validation.isValidating,
-		validate,
-		reset,
-		state
-	};
-}
-//#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;
-		}
+	}
+	return {
+		id,
+		label,
+		name,
+		form,
+		required,
+		descriptionId,
+		errorId,
+		descriptions,
+		fieldErrors,
+		hasDescription,
+		hasError,
+		value,
+		isDirty,
+		isFocused,
+		isDisabled,
+		isReadonly,
+		isPristine,
+		isTouched,
+		errors,
+		isValid,
+		isValidating: validation.isValidating,
+		validate,
+		reset,
+		state
 	};
 }
 //#endregion
@@ -3023,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'
@@ -3093,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 */
 	}
@@ -3111,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;
-		}),
+		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,
@@ -5134,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
@@ -7778,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
 /**
@@ -8262,4 +9104,4 @@ function useClickOutside(target, handler, options = {}) {
 	};
 }
 //#endregion
-export { createTimelineContext as $, useIntersectionObserver as A, createInput as At, createDateContext as B, ComboboxAdapter as Bt, usePresence as C, createNumberField as Ct, usePrefersReducedMotion as D, useNested as Dt, usePrefersDark as E, createNestedContext as Et, PointerAdapter as F, createCombobox as Ft, createBreakpointsPlugin as G, useBreadcrumbs as Gt, useDate as H, usePopover as Ht, DragDropAdapter as I, createComboboxContext as It, toHighlight as J, useBreakpoints as K, useMutationObserver as L, useCombobox as Lt, useHotkey as M, createForm as Mt, useDragDrop as N, createFormContext as Nt, useLazy as O, createKanban as Ot, KeyboardAdapter as P, useForm as Pt, createTimeline as Q, useDelay as R, ServerComboboxAdapter as Rt, useProxyModel as S, createOtp as St, usePrefersContrast as T, createNested as Tt, createBreakpoints as U, createBreadcrumbs as Ut, createDatePlugin as V, useVirtualFocus as Vt, createBreakpointsContext as W, createBreadcrumbsContext as Wt, createVirtualContext as X, createVirtual as Y, useVirtual as Z, createRtlPlugin as _, createFallbackHydration as _t, useToggleScope as a, createRating as at, useRovingFocus as b, createHydrationPlugin as bt, createStoragePlugin as c, createProgress as ct, createStackContext as d, createOverflow as dt, useTimeline as et, createStackPlugin as f, createOverflowContext as ft, createRtlFallback as g, toElement as gt, createRtlContext as h, useResizeObserver as ht, useWindowEventListener as i, createSlider as it, useImage as j, createValidation as jt, useElementIntersection as k, createSortable as kt, useStorage as l, createProgressContext as lt, createRtl as m, useElementSize as mt, useDocumentEventListener as n, createStepContext as nt, createStorage as o, createRatingContext as ot, useStack as p, useOverflow as pt, toReactive as q, useEventListener as r, useStep as rt, createStorageContext as s, useRating as st, useClickOutside as t, createStep as tt, createStack as u, useProgress as ut, useRtl as v, createHydration as vt, useMediaQuery as w, createNumeric as wt, useRaf as x, useHydration as xt, V0RtlAdapter as y, createHydrationContext as yt, createDate as z, ClientComboboxAdapter 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 };