@vuetify/v0 1.0.0-alpha.3 → 1.0.0-alpha.4

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

@@ -1,24 +1,23 @@
-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-zEjWBKCr.mjs";
-import { clamp, instanceExists, isArray, isElement, isFunction, isNull, isNullOrUndefined, isNumber, isObject, isString, isUndefined, mergeDeep, range, resolveIds, resolveIndexes, useId as useId$1 } from "./utilities/index.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-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-DvdRTrqC.mjs";
-import { t as createRegistry } from "./createRegistry-BXzdXAjq.mjs";
-import { i as createModel, t as createSelection } from "./createSelection-B3HJEPNg.mjs";
-import { t as createSingle } from "./createSingle-Dql8mRi-.mjs";
-import "./createTokens-DgFYsOrv.mjs";
-import { a as useLocale } from "./useLocale-BV8e3imF.mjs";
-import { c as useTimer } from "./useNotifications-vSJE6z6t.mjs";
-import { t as toArray } from "./toArray-as9BWxBK.mjs";
-import { n as createFilter } from "./adapter-gQ2SNKZq.mjs";
-import { t as createGroup } from "./createGroup-CGk6hY_Y.mjs";
-import "./createPagination-CHF7SmmK.mjs";
-import "./createDataTable-iODP6aKB.mjs";
-import { a as useRules, o as isStandardSchema } from "./useRules-BT6cgoTj.mjs";
-import "./useFeatures-BPOke6iP.mjs";
-import "./usePermissions-D3zPwKQc.mjs";
-import { t as MemoryAdapter } from "./memory-oYBvtkgx.mjs";
-import "./useTheme-cUZb2A9O.mjs";
-import { computed, effectScope, hasInjectionContext, isRef, nextTick, onMounted, onScopeDispose, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
+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 { 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 { t as MemoryStorageAdapter } from "./memory-BMpJcQjQ.mjs";
+import "./useTheme-3vW3kFNg.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
 /**
 * @module createBreadcrumbs
@@ -351,6 +350,7 @@ function createFocusTraversal(items, activate, options = {}) {
 	}
 	/** Focus first non-disabled item in the current row (grid mode) */
 	function rowFirst() {
+		/* v8 ignore next 2 -- defensive: rowFirst is only invoked in grid mode (cols > 0) */
 		const cols = toValue(_columns) ?? 0;
 		if (!cols) return first();
 		const all = items();
@@ -367,6 +367,7 @@ function createFocusTraversal(items, activate, options = {}) {
 	}
 	/** Focus last non-disabled item in the current row (grid mode) */
 	function rowLast() {
+		/* v8 ignore next 2 -- defensive: rowLast is only invoked in grid mode (cols > 0) */
 		const cols = toValue(_columns) ?? 0;
 		if (!cols) return last();
 		const all = items();
@@ -538,6 +539,9 @@ function useVirtualFocus(items, options) {
 	};
 }
 //#endregion
+//#region src/composables/createCombobox/adapters/adapter.ts
+var ComboboxAdapter = class {};
+//#endregion
 //#region src/composables/createCombobox/adapters/client.ts
 /**
 * @module createCombobox/adapters/client
@@ -546,9 +550,10 @@ function useVirtualFocus(items, options) {
 * Default combobox adapter. Filters items client-side using createFilter.
 * Synchronous, zero debounce — items update immediately as the user types.
 */
-var ClientAdapter = class {
+var ClientComboboxAdapter = class extends ComboboxAdapter {
 	options;
 	constructor(options = {}) {
+		super();
 		this.options = options;
 	}
 	setup(context) {
@@ -588,7 +593,7 @@ var ClientAdapter = class {
 * The consumer watches `query` via useComboboxContext() or slot props
 * and provides filtered items reactively.
 */
-var ServerAdapter = class {
+var ServerComboboxAdapter = class extends ComboboxAdapter {
 	setup(context) {
 		const isLoading = shallowRef(false);
 		return {
@@ -613,7 +618,7 @@ var ServerAdapter = class {
 * chain — it composes existing primitives instead.
 *
 * Key features:
-* - Adapter-based filtering (client-side or server-side via ClientAdapter/ServerAdapter)
+* - Adapter-based filtering (client-side or server-side via ClientComboboxAdapter/ServerComboboxAdapter)
 * - Single or multi-select mode
 * - Virtual focus keyboard navigation (aria-activedescendant pattern)
 * - Strict mode: reverts query to selected value on close if no match
@@ -690,7 +695,7 @@ function createCombobox(options = {}) {
 		version.value;
 		return [...selection.values()];
 	});
-	const { filtered, isLoading, isEmpty } = (adapter ?? new ClientAdapter()).setup({
+	const { filtered, isLoading, isEmpty } = (adapter ?? new ClientComboboxAdapter()).setup({
 		query,
 		items
 	});
@@ -1215,6 +1220,327 @@ 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
+*
+* @see https://0.vuetifyjs.com/composables/data/create-kanban
+*
+* @remarks
+* Headless data-flow management for two-level sortable boards. Wraps a column
+* sortable; each column ticket carries its own inner sortable on `column.items`.
+* Adds a `transfer` primitive for cross-column moves with reused `disabled`
+* gating and a destination-side `accept` predicate. Pure logic — no DnD, no DOM.
+*
+* @example
+* ```ts
+* import { createKanban } from '@vuetify/v0'
+* import type { SortableTicketInput } from '@vuetify/v0'
+*
+* interface CardTicket extends SortableTicketInput {
+*   value: { title: string }
+* }
+*
+* const kanban = createKanban<CardTicket>()
+*
+* const todo = kanban.columns.register({ value: { title: 'Todo' } })
+* const done = kanban.columns.register({ value: { title: 'Done' } })
+*
+* const card = todo.items.register({ value: { title: 'Write spec' } })
+*
+* kanban.on('transfer:ticket', ({ ticket, from, to }) => {
+*   console.log(ticket.value.title, from, '→', to)
+* })
+*
+* kanban.transfer(card.id, done.id, 0)
+* ```
+*/
+/**
+* Create a headless two-level sortable orchestrator.
+*
+* @param options Kanban options (currently only `disabled`).
+* @returns A {@link KanbanContext}.
+*
+* @example
+* ```ts
+* import { createKanban } from '@vuetify/v0'
+* import type { KanbanColumnTicketInput, SortableTicketInput } from '@vuetify/v0'
+*
+* interface CardTicket extends SortableTicketInput {
+*   value: { title: string }
+* }
+*
+* interface BoardColumn extends KanbanColumnTicketInput<CardTicket> {
+*   value: { title: string }
+* }
+*
+* const kanban = createKanban<CardTicket, BoardColumn>()
+*
+* const todo = kanban.columns.register({ value: { title: 'Todo' } })
+* const review = kanban.columns.register({
+*   value: { title: 'Review' },
+*   accept: card => card.value.title.length > 0,
+* })
+*
+* const spec = todo.items.register({ value: { title: 'Write spec' } })
+* kanban.transfer(spec.id, review.id, 0)
+* ```
+*/
+function createKanban(_options = {}) {
+	const { disabled, ...options } = _options;
+	const logger = useLogger();
+	const _columns = createSortable({
+		...options,
+		disabled
+	});
+	const lookup = createRegistry({ events: true });
+	const bus = createRegistry({ events: true });
+	const on = bus.on;
+	const off = bus.off;
+	const columns = {
+		..._columns,
+		register(registration) {
+			let ticket;
+			const items = createSortable({ disabled: () => !!toValue(disabled) || !!toValue(ticket?.disabled) });
+			items.on("register:ticket", (t) => {
+				lookup.upsert(t.id, { value: ticket.id });
+			});
+			items.on("unregister:ticket", (t) => {
+				lookup.get(t.id)?.unregister();
+			});
+			ticket = _columns.register({
+				...registration,
+				items
+			});
+			return ticket;
+		},
+		onboard(registrations) {
+			return _columns.batch(() => registrations.map((reg) => columns.register(reg)));
+		},
+		upsert(id, patch = {}, event) {
+			return /* @__PURE__ */ isUndefined(_columns.get(id)) ? columns.register({
+				...patch,
+				id
+			}) : _columns.upsert(id, patch, event);
+		},
+		get size() {
+			return _columns.size;
+		}
+	};
+	function isAccepted(accept, ticket, from, toIndex) {
+		if (/* @__PURE__ */ isUndefined(accept)) return true;
+		try {
+			const result = accept(ticket, from, toIndex);
+			if (/* @__PURE__ */ isThenable(result)) {
+				logger.warn("accept predicate returned a thenable; async predicates are not supported — treating as reject");
+				return false;
+			}
+			return Boolean(result);
+		} catch (error) {
+			logger.error("accept predicate threw; treating as reject", error);
+			return false;
+		}
+	}
+	columns.on("unregister:ticket", (column) => {
+		column.items.dispose();
+		for (const t of lookup.values()) if (t.value === column.id) t.unregister();
+	});
+	function transfer(id, toColumnId, toIndex) {
+		const fromColumnId = lookup.get(id)?.value;
+		if (/* @__PURE__ */ isUndefined(fromColumnId)) {
+			logger.warn(`unknown ticket id "${String(id)}"`);
+			return;
+		}
+		const source = columns.get(fromColumnId);
+		if (!source) {
+			logger.warn(`unknown source column id "${String(fromColumnId)}"`);
+			return;
+		}
+		const destination = columns.get(toColumnId);
+		if (!destination) {
+			logger.warn(`unknown destination column id "${String(toColumnId)}"`);
+			return;
+		}
+		const ticket = source.items.get(id);
+		if (!ticket) {
+			logger.warn(`ticket "${String(id)}" missing from source column "${String(fromColumnId)}"`);
+			return;
+		}
+		const fromIndex = ticket.index;
+		if (toColumnId === fromColumnId) return source.items.move(id, toIndex);
+		if (toValue(disabled) || toValue(source.disabled) || toValue(destination.disabled) || toValue(ticket.disabled)) return;
+		if (!isAccepted(destination.accept, ticket, fromColumnId, toIndex)) return void 0;
+		if (!/* @__PURE__ */ isUndefined(destination.items.get(id))) {
+			logger.warn(`id "${String(id)}" already exists in destination column "${String(toColumnId)}"`);
+			return;
+		}
+		let registered;
+		let moved;
+		destination.items.batch(() => {
+			const [input] = source.items.offboard([id]);
+			if (/* @__PURE__ */ isUndefined(input)) return;
+			registered = destination.items.register(input);
+			moved = registered.index === toIndex ? registered : destination.items.move(registered.id, toIndex);
+		});
+		const final = moved ?? registered;
+		if (final) bus.emit("transfer:ticket", {
+			ticket: final,
+			from: fromColumnId,
+			to: toColumnId,
+			fromIndex,
+			toIndex: final.index
+		});
+		return final;
+	}
+	return {
+		columns,
+		transfer,
+		on,
+		off
+	};
+}
+//#endregion
 //#region src/composables/createNested/index.ts
 /**
 * @module createNested
@@ -2468,6 +2794,7 @@ function useElementSize(target) {
 	const height = shallowRef(0);
 	const { pause: _pause, resume, stop, isActive, isPaused } = useResizeObserver(target, (entries) => {
 		const entry = entries[0];
+		/* v8 ignore next 4 -- defensive: ResizeObserver always passes an entry array with at least one entry */
 		if (entry) {
 			width.value = entry.contentRect.width;
 			height.value = entry.contentRect.height;
@@ -2626,6 +2953,7 @@ function createOverflow(options = {}) {
 		}),
 		total,
 		isOverflowing: toRef(() => {
+			if (width.value === 0) return false;
 			return total.value > width.value - toValue(reserved);
 		}),
 		measure,
@@ -2778,7 +3106,7 @@ function createProgress(options = {}) {
 		}
 		for (const [index, element] of clamped.entries()) {
 			const ticket = segments.value[index];
-			if (!ticket || !isRef(ticket.value)) continue;
+			if (!ticket || !isRef(ticket.value) || isReadonly(ticket.value)) continue;
 			ticket.value.value = element;
 		}
 	}
@@ -3636,6 +3964,7 @@ function createVirtual(items, _options = {}) {
 		/* v8 ignore stop */
 	});
 	useResizeObserver(element, (entries) => {
+		/* v8 ignore next -- defensive: ResizeObserver always emits at least one entry */
 		if (!entries[0]) return;
 		viewportHeight.value = entries[0].contentRect.height;
 		update();
@@ -3648,6 +3977,7 @@ function createVirtual(items, _options = {}) {
 		rebuild();
 	}, { immediate: true });
 	watch(element, () => {
+		/* v8 ignore next -- defensive: watch fires only when element is present */
 		if (!element.value) return;
 		if (direction === "reverse" && items.value.length > 0) {
 			const lastIndex = items.value.length - 1;
@@ -3666,6 +3996,7 @@ function createVirtual(items, _options = {}) {
 			anchorOffset = 0;
 		} else if (/* @__PURE__ */ isFunction(anchor)) {
 			const result = anchor(items.value);
+			/* v8 ignore next 4 -- function-anchor: tested with valid number return; non-number rejection branch is implicit */
 			if (/* @__PURE__ */ isNumber(result)) {
 				anchorIndex = result;
 				anchorOffset = element.value.scrollTop - (offsets.value[result] || 0);
@@ -3749,8 +4080,10 @@ function createVirtual(items, _options = {}) {
 		/* v8 ignore stop */
 	}
 	function resize(index, height) {
+		/* v8 ignore next -- early bail when height is already correct */
 		if (heights.value[index] === height) return;
 		heights.value[index] = height;
+		/* v8 ignore next -- first-call only: itemHeight bootstrapped from initial measurement */
 		if (!itemHeight.value) itemHeight.value = height;
 		if (IN_BROWSER) {
 			cancelAnimationFrame(rebuildRaf);
@@ -3767,6 +4100,7 @@ function createVirtual(items, _options = {}) {
 		/* v8 ignore stop */
 	}
 	function scrollTo(index, scrollOptions) {
+		/* v8 ignore next -- defensive: scrollTo only invoked after element mounts */
 		if (!element.value) return;
 		const targetOffset = offsets.value[index] || 0;
 		const behavior = scrollOptions?.behavior ?? "auto";
@@ -4286,11 +4620,11 @@ const [createBreakpointsContext, createBreakpointsPlugin, useBreakpoints] = crea
 *
 * @example Using the built-in Temporal adapter
 * ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { V0DateAdapter } from '@vuetify/v0/date'
 * import { createDatePlugin } from '@vuetify/v0'
 *
 * const app = createApp(App)
-* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+* app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
 *
 * // In a component:
 * const { adapter } = useDate()
@@ -4300,9 +4634,9 @@ const [createBreakpointsContext, createBreakpointsPlugin, useBreakpoints] = crea
 *
 * @example Custom adapter
 * ```ts
-* import type { DateAdapter } from '@vuetify/v0'
+* import { DateAdapter } from '@vuetify/v0'
 *
-* class DateFnsAdapter implements DateAdapter<Date> {
+* class DateFnsAdapter extends DateAdapter<Date> {
 *   // ... implementation
 * }
 *
@@ -4333,6 +4667,7 @@ const defaultLocales = {
 function deriveFirstDayOfWeek(locale) {
 	try {
 		const info = new Intl.Locale(locale).getWeekInfo?.();
+		/* v8 ignore next -- defensive: getWeekInfo always returns info in Node 22+ */
 		return info ? info.firstDay % 7 : 0;
 	} catch {
 		return 0;
@@ -4350,14 +4685,14 @@ function deriveFirstDayOfWeek(locale) {
 *
 * @example
 * ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { V0DateAdapter } from '@vuetify/v0/date'
 *
-* const { adapter } = createDate({ adapter: new Vuetify0DateAdapter() })
+* const { adapter } = createDate({ adapter: new V0DateAdapter() })
 * const today = adapter.date()
 *
 * // With locale options
 * const { adapter } = createDate({
-*   adapter: new Vuetify0DateAdapter(),
+*   adapter: new V0DateAdapter(),
 *   locale: 'de-DE',
 * })
 * ```
@@ -4412,10 +4747,10 @@ function createDate(options) {
 *
 * @example
 * ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { V0DateAdapter } from '@vuetify/v0/date'
 *
 * const [useAppDate, provideAppDate] = createDateContext({
-*   adapter: new Vuetify0DateAdapter(),
+*   adapter: new V0DateAdapter(),
 *   namespace: 'app:date',
 * })
 * ```
@@ -4436,14 +4771,14 @@ function createDateContext(options) {
 *
 * @example
 * ```ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { V0DateAdapter } from '@vuetify/v0/date'
 *
 * const app = createApp(App)
-* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+* app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
 *
 * // With locale options
 * app.use(createDatePlugin({
-*   adapter: new Vuetify0DateAdapter(),
+*   adapter: new V0DateAdapter(),
 *   locale: 'de-DE',
 * }))
 * ```
@@ -4477,10 +4812,10 @@ function createDatePlugin(options) {
 * @example
 * ```ts
 * // main.ts
-* import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+* import { V0DateAdapter } from '@vuetify/v0/date'
 * import { createDatePlugin } from '@vuetify/v0'
 *
-* app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+* app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
 * ```
 *
 * @example
@@ -4494,7 +4829,7 @@ 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 { Vuetify0DateAdapter } from '@vuetify/v0/date'\n  import { createDatePlugin } from '@vuetify/v0'\n\n  app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))");
+	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() }))");
 	return useContext(namespace);
 }
 //#endregion
@@ -4615,70 +4950,842 @@ function useDelay(callback, options = {}) {
 	};
 }
 //#endregion
-//#region src/composables/useHotkey/aliases.ts
+//#region src/composables/useMutationObserver/index.ts
 /**
-* Key alias mapping for consistent key normalization across the hotkey system.
+* @module useMutationObserver
 *
-* Maps user-friendly aliases to canonical key names that match
-* KeyboardEvent.key values (in lowercase) where possible.
+* @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
+*
+* @remarks
+* MutationObserver composable with lifecycle management.
+*
+* Key features:
+* - MutationObserver API wrapper
+* - `isActive` reactive flag
+* - `once` option for single-fire observation
+* - Pause/resume/stop functionality
+* - Automatic cleanup on unmount
+* - SSR-safe (checks SUPPORTS_MUTATION_OBSERVER)
+* - Hydration-aware
+* - Configurable observation options (childList, attributes, characterData, etc.)
+*
+* Perfect for detecting DOM changes and responding to mutations.
+*
+* @example
+* ```ts
+* import { useTemplateRef } from 'vue'
+* import { useMutationObserver } from '@vuetify/v0'
+*
+* const target = useTemplateRef('target')
+* useMutationObserver(target, records => {
+*   console.log(records)
+* }, { childList: true })
+* ```
 */
-const keyAliasMap = {
-	control: "ctrl",
-	command: "cmd",
-	option: "alt",
-	up: "arrowup",
-	down: "arrowdown",
-	left: "arrowleft",
-	right: "arrowright",
-	esc: "escape",
-	spacebar: " ",
-	space: " ",
-	return: "enter",
-	del: "delete",
-	plus: "+",
-	slash: "/",
-	underscore: "_",
-	minus: "-",
-	hyphen: "-"
-};
-/* @__NO_SIDE_EFFECTS__ */
-function normalizeKey(key) {
-	const lowerKey = key.toLowerCase();
-	return keyAliasMap[lowerKey] ?? lowerKey;
-}
-//#endregion
-//#region src/composables/useHotkey/parsing.ts
-const logger = /* @__PURE__ */ useLogger();
-const MODIFIERS = [
-	"ctrl",
-	"shift",
-	"alt",
-	"meta",
-	"cmd"
-];
 /**
-* Splits a single combination string into individual key parts.
+* A composable that uses the Mutation Observer API to detect changes in the DOM.
 *
-* A combination is a set of keys that must be pressed simultaneously.
-* e.g. `ctrl+k`, `shift+-`
+* @param target The element to observe.
+* @param callback The callback to execute when a mutation is observed.
+* @param options The options for the Mutation Observer.
+* @returns An object with methods to control the observer.
 *
-* @param combination - The combination string to parse
-* @param isInternal - Whether this is an internal call (suppresses warnings)
-* @returns Object with keys array and separators array
+* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+* @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
+*
+* @example
+* ```ts
+* import { ref } from 'vue'
+* import { useMutationObserver } from '@vuetify/v0'
+*
+* const container = ref<HTMLElement>()
+*
+* const { pause, resume, isPaused } = useMutationObserver(
+*   container,
+*   (mutations) => {
+*     mutations.forEach((mutation) => {
+*       if (mutation.type === 'childList') {
+*         console.log('Children changed:', mutation.addedNodes, mutation.removedNodes)
+*       } else if (mutation.type === 'attributes') {
+*         console.log('Attribute changed:', mutation.attributeName)
+*       }
+*     })
+*   },
+*   {
+*     childList: true,
+*     attributes: true,
+*     subtree: true
+*   }
+* )
+*
+* // Pause observation
+* pause()
+*
+* // Resume observation
+* resume()
+* ```
 */
-function splitKeyCombination(combination, isInternal = false) {
-	const emptyResult = {
-		keys: [],
-		separators: []
+function useMutationObserver(target, callback, options = {}) {
+	const observerOptions = {
+		childList: options.childList ?? true,
+		attributes: options.attributes ?? false,
+		characterData: options.characterData ?? false,
+		subtree: options.subtree ?? false,
+		attributeOldValue: options.attributeOldValue ?? false,
+		characterDataOldValue: options.characterDataOldValue ?? false,
+		attributeFilter: options.attributeFilter
 	};
-	if (!combination) {
-		if (!isInternal) logger.warn("Invalid hotkey combination: empty string provided");
-		return emptyResult;
-	}
-	if (combination.length > 1 && [
-		"+",
-		"/",
-		"_"
+	return createObserver(target, callback, {
+		supports: SUPPORTS_MUTATION_OBSERVER,
+		once: options.once,
+		create: (cb) => new MutationObserver((mutations) => {
+			cb(mutations.map((m) => ({
+				type: m.type,
+				target: m.target,
+				addedNodes: m.addedNodes,
+				removedNodes: m.removedNodes,
+				previousSibling: m.previousSibling,
+				nextSibling: m.nextSibling,
+				attributeName: m.attributeName,
+				attributeNamespace: m.attributeNamespace,
+				oldValue: m.oldValue
+			})));
+		}),
+		observe: (obs, el) => obs.observe(el, observerOptions),
+		immediate: options.immediate ? (el) => {
+			const emptyNodeList = {
+				length: 0,
+				item: () => null,
+				forEach: () => {},
+				*[Symbol.iterator]() {}
+			};
+			return [{
+				type: "childList",
+				target: el,
+				addedNodes: emptyNodeList,
+				removedNodes: emptyNodeList,
+				previousSibling: null,
+				nextSibling: null,
+				attributeName: null,
+				attributeNamespace: null,
+				oldValue: null
+			}];
+		} : void 0,
+		onceIncludesImmediate: true
+	});
+}
+//#endregion
+//#region src/composables/useDragDrop/adapters/adapter.ts
+/**
+* @module useDragDrop/adapters/adapter
+*
+* @remarks
+* Adapter contract and abstract base for useDragDrop. Concrete adapters extend
+* `DragDropAdapter<Z>` to share the `cleanup` field, `dispose()` lifecycle, and
+* the `locate()` DOM-walk helper.
+*/
+/**
+* Abstract base class for useDragDrop adapters. Provides a `cleanup` slot, a
+* `dispose()` lifecycle, and a `locate()` helper that walks the DOM to find the
+* draggable ticket whose `el` ancestors a given event target.
+*
+* @example
+* ```ts
+* import { DragDropAdapter, type DragDropAdapterContext } from '@vuetify/v0'
+*
+* class MyAdapter extends DragDropAdapter {
+*   setup (context: DragDropAdapterContext) {
+*     const stop = useEventListener(document, 'mousedown', event => {
+*       const ticket = this.locate(event.target, context)
+*       if (ticket) context.emit.start(ticket, { x: event.clientX, y: event.clientY }, 'pointer')
+*     })
+*     this.cleanup = () => stop()
+*   }
+* }
+* ```
+*/
+var DragDropAdapter = class {
+	cleanup = null;
+	dispose() {
+		this.cleanup?.();
+		this.cleanup = null;
+	}
+	locate(target, context) {
+		let element = /* @__PURE__ */ isElement(target) ? target : null;
+		while (element) {
+			for (const ticket of context.draggables.values()) if (ticket.el.value === element) return ticket;
+			element = element.parentElement;
+		}
+		return null;
+	}
+};
+//#endregion
+//#region src/composables/useDragDrop/adapters/pointer.ts
+/**
+* @module useDragDrop/adapters/pointer
+*
+* @remarks
+* Default pointer adapter for useDragDrop. Listens for `pointerdown` /
+* `pointermove` / `pointerup` / `pointercancel` on the document and emits the
+* drag lifecycle. Activation distance is configurable via `threshold`.
+*/
+/**
+* Default pointer adapter. Wires `pointerdown` / `pointermove` / `pointerup` /
+* `pointercancel` on the document and converts them into drag lifecycle calls.
+*
+* @example
+* ```ts
+* import { PointerAdapter, useDragDrop } from '@vuetify/v0'
+*
+* useDragDrop({ adapters: [new PointerAdapter({ threshold: 10 })] })
+* ```
+*/
+var PointerAdapter = class extends DragDropAdapter {
+	threshold;
+	constructor(options = {}) {
+		super();
+		this.threshold = options.threshold ?? 0;
+	}
+	setup(context) {
+		const logger = useLogger();
+		if (this.cleanup) {
+			logger.warn("PointerAdapter setup called twice; previous registration will be replaced");
+			this.dispose();
+		}
+		if (!IN_BROWSER) return;
+		let downSource = null;
+		let downOrigin = null;
+		let downId = null;
+		let started = false;
+		function reset() {
+			downSource = null;
+			downOrigin = null;
+			downId = null;
+			started = false;
+		}
+		const onDown = (event) => {
+			if (event.button !== 0) return;
+			if (downSource) return;
+			const ticket = this.locate(event.target, context);
+			if (!ticket) return;
+			downSource = ticket;
+			downOrigin = {
+				x: event.clientX,
+				y: event.clientY
+			};
+			downId = event.pointerId;
+			started = false;
+		};
+		const onMove = (event) => {
+			if (!downSource || !downOrigin || event.pointerId !== downId) return;
+			const point = {
+				x: event.clientX,
+				y: event.clientY
+			};
+			if (!started) {
+				const dx = point.x - downOrigin.x;
+				const dy = point.y - downOrigin.y;
+				if (this.threshold > 0 && Math.hypot(dx, dy) < this.threshold) return;
+				context.emit.start(downSource, downOrigin, "pointer");
+				started = true;
+			}
+			context.emit.move(point);
+		};
+		function onUp(event) {
+			if (event.pointerId !== downId) return;
+			if (downSource && started) context.emit.drop();
+			reset();
+		}
+		function onCancel(event) {
+			if (event.pointerId !== downId) return;
+			if (downSource && started) context.emit.cancel();
+			reset();
+		}
+		const stopDown = useEventListener(document, "pointerdown", onDown);
+		const stopMove = useEventListener(document, "pointermove", onMove);
+		const stopUp = useEventListener(document, "pointerup", onUp);
+		const stopCancel = useEventListener(document, "pointercancel", onCancel);
+		this.cleanup = () => {
+			stopDown();
+			stopMove();
+			stopUp();
+			stopCancel();
+		};
+	}
+};
+//#endregion
+//#region src/composables/useDragDrop/adapters/keyboard.ts
+/**
+* @module useDragDrop/adapters/keyboard
+*
+* @remarks
+* Default keyboard adapter for useDragDrop. Listens for `keydown` on the
+* document. Activation keys (default Space and Enter) start and drop drags;
+* arrow keys nudge the drag point by `step` px; Escape cancels.
+*/
+function isEditable(element) {
+	if (/* @__PURE__ */ isNull(element)) return false;
+	const tag = element.tagName;
+	if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+	if (element.isContentEditable) return true;
+	const role = element.getAttribute("role");
+	return role === "textbox" || role === "searchbox" || role === "combobox" || role === "spinbutton";
+}
+/**
+* Default keyboard adapter. Listens for `keydown` on the document; activation
+* keys start/drop drags, arrow keys nudge the drag point, Escape cancels.
+*
+* @example
+* ```ts
+* import { KeyboardAdapter, useDragDrop } from '@vuetify/v0'
+*
+* useDragDrop({ adapters: [new KeyboardAdapter({ activate: ['x'], step: 32 })] })
+* ```
+*/
+var KeyboardAdapter = class extends DragDropAdapter {
+	activate;
+	step;
+	constructor(options = {}) {
+		super();
+		this.activate = options.activate ?? [" ", "Enter"];
+		this.step = options.step ?? 16;
+	}
+	setup(context) {
+		const logger = useLogger();
+		if (this.cleanup) {
+			logger.warn("KeyboardAdapter setup called twice; previous registration will be replaced");
+			this.dispose();
+		}
+		if (!IN_BROWSER) return;
+		const onKeyDown = (event) => {
+			const focused = document.activeElement;
+			if (event.ctrlKey || event.metaKey || event.altKey || event.shiftKey) return;
+			if (isEditable(focused)) return;
+			const ticket = this.locate(focused, context);
+			const isActive = !/* @__PURE__ */ isNull(context.active.value);
+			if (this.activate.includes(event.key)) {
+				if (isActive) {
+					event.preventDefault();
+					context.emit.drop();
+				} else if (ticket) {
+					const el = ticket.el.value;
+					if (!el) {
+						logger.warn("KeyboardAdapter: cannot start drag — element is not mounted");
+						return;
+					}
+					event.preventDefault();
+					const rect = el.getBoundingClientRect();
+					context.emit.start(ticket, {
+						x: rect.left + rect.width / 2,
+						y: rect.top + rect.height / 2
+					}, "keyboard");
+				}
+				return;
+			}
+			if (event.key === "Escape" && isActive) {
+				event.preventDefault();
+				context.emit.cancel();
+				return;
+			}
+			if (isActive && event.key.startsWith("Arrow")) {
+				const active = context.active.value;
+				if (/* @__PURE__ */ isNull(active)) return;
+				const current = active.current;
+				let point = null;
+				switch (event.key) {
+					case "ArrowUp":
+						point = {
+							x: current.x,
+							y: current.y - this.step
+						};
+						break;
+					case "ArrowDown":
+						point = {
+							x: current.x,
+							y: current.y + this.step
+						};
+						break;
+					case "ArrowLeft":
+						point = {
+							x: current.x - this.step,
+							y: current.y
+						};
+						break;
+					case "ArrowRight":
+						point = {
+							x: current.x + this.step,
+							y: current.y
+						};
+						break;
+				}
+				if (point) {
+					event.preventDefault();
+					context.emit.move(point);
+				}
+			}
+		};
+		const stop = useEventListener(document, "keydown", onKeyDown);
+		this.cleanup = () => stop();
+	}
+};
+//#endregion
+//#region src/composables/useDragDrop/index.ts
+/**
+* @module useDragDrop
+*
+* @see https://0.vuetifyjs.com/composables/system/use-drag-drop
+*
+* @remarks
+* Headless drag-and-drop primitive. Owns two registries (draggables and zones)
+* plus the active-drag state. Pointer and keyboard adapters ship by default;
+* lifecycle hooks and a plugin array provide extension points.
+*
+* @example
+* ```ts
+* import { useDragDrop } from '@vuetify/v0'
+*
+* const dnd = useDragDrop()
+* ```
+*/
+/**
+* Pure math for resolving where in an oriented zone a pointer would drop.
+* Internal — consumers rely on the `position.index` / `position.indicator`
+* fields delivered to `onDrop`.
+*/
+function resolveDropPosition(point, rects, orientation) {
+	if (rects.length === 0) return null;
+	const axis = orientation === "vertical" ? "y" : "x";
+	const start = orientation === "vertical" ? "top" : "left";
+	const end = orientation === "vertical" ? "bottom" : "right";
+	const coord = point[axis];
+	if (coord < rects[0][start]) return {
+		index: 0,
+		edge: "before",
+		rect: rects[0]
+	};
+	const last = rects.at(-1);
+	if (coord > last[end]) return {
+		index: rects.length,
+		edge: "after",
+		rect: last
+	};
+	for (const [index, rect] of rects.entries()) if (coord >= rect[start] && coord <= rect[end]) {
+		if (coord < rect[start] + (rect[end] - rect[start]) / 2) return {
+			index,
+			edge: "before",
+			rect
+		};
+		return {
+			index: index + 1,
+			edge: "after",
+			rect
+		};
+	}
+	for (let index = 0; index < rects.length - 1; index++) {
+		const a = rects[index];
+		const b = rects[index + 1];
+		if (coord > a[end] && coord < b[start]) {
+			if (coord <= (a[end] + b[start]) / 2) return {
+				index: index + 1,
+				edge: "after",
+				rect: a
+			};
+			return {
+				index: index + 1,
+				edge: "before",
+				rect: b
+			};
+		}
+	}
+	return {
+		index: rects.length,
+		edge: "after",
+		rect: last
+	};
+}
+/**
+* Create a headless drag-and-drop context.
+*
+* @param options - Adapters, plugins, and lifecycle hooks. All optional.
+* @returns A `DragDropContext<Z>` exposing `draggables` / `zones` registries,
+*   the `active` drag, the `isDragging` boolean, and a programmatic `cancel()`.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-drag-drop
+*
+* @example
+* ```ts
+* import { useDragDrop } from '@vuetify/v0'
+* import { useTemplateRef } from 'vue'
+*
+* const dnd = useDragDrop<{ type: 'card', value: string }>()
+*
+* const draggable = useTemplateRef<HTMLElement>('draggable')
+* const dropzone = useTemplateRef<HTMLElement>('dropzone')
+*
+* dnd.draggables.register({ el: draggable, type: 'card', value: 'card-1' })
+* dnd.zones.register({
+*   el: dropzone,
+*   accept: ['card'],
+*   onDrop: (drag, position) => console.log(drag.value, position.index),
+* })
+* ```
+*/
+function useDragDrop(options = {}) {
+	const { plugins = [] } = options;
+	const logger = useLogger();
+	const _draggables = createRegistry({ events: true });
+	const _zones = createRegistry({ events: true });
+	const active = shallowRef(null);
+	const isDragging = toRef(() => !/* @__PURE__ */ isNull(active.value));
+	const scopes = /* @__PURE__ */ new Map();
+	const nodes = /* @__PURE__ */ new Map();
+	function next(fn, ...args) {
+		if (/* @__PURE__ */ isUndefined(fn)) return;
+		try {
+			fn(...args);
+		} catch (error) {
+			logger.error("useDragDrop hook threw", error);
+		}
+	}
+	function safeAccept(accept, drag) {
+		try {
+			if (/* @__PURE__ */ isNull(drag)) return false;
+			if (/* @__PURE__ */ isUndefined(accept)) return true;
+			if (/* @__PURE__ */ isArray(accept)) return accept.includes(drag.type);
+			const result = accept(drag);
+			if (/* @__PURE__ */ isThenable(result)) {
+				logger.warn("useDragDrop accept predicate returned a thenable; async predicates are not supported — treating as reject");
+				return false;
+			}
+			return Boolean(result);
+		} catch (error) {
+			logger.error("useDragDrop accept predicate threw; treating as reject", error);
+			return false;
+		}
+	}
+	const draggables = {
+		..._draggables,
+		register(registration) {
+			const id = registration.id ?? /* @__PURE__ */ useId$1();
+			const el = toRef(() => toValue(registration.el));
+			const dragging = toRef(() => active.value?.id === id);
+			const input = {
+				...registration,
+				id,
+				el,
+				isDragging: dragging
+			};
+			return _draggables.register(input);
+		}
+	};
+	const zones = {
+		..._zones,
+		register(registration) {
+			const id = registration.id ?? /* @__PURE__ */ useId$1();
+			const el = toRef(() => toValue(registration.el));
+			const isOver = toRef(() => active.value?.over === id);
+			const willAccept = toRef(() => safeAccept(registration.accept, active.value));
+			const rects = shallowRef([]);
+			function refresh() {
+				const zoneEl = el.value;
+				rects.value = zoneEl ? Array.from(zoneEl.children).map((child) => child.getBoundingClientRect()) : [];
+			}
+			const scope = effectScope();
+			scopes.set(id, scope);
+			scope.run(() => {
+				if (registration.orientation) {
+					watch(el, refresh, {
+						immediate: true,
+						flush: "post"
+					});
+					useResizeObserver(el, refresh);
+					useMutationObserver(el, refresh, { childList: true });
+					watch(() => active.value?.id, (id) => {
+						if (id) refresh();
+					});
+				}
+				watch(el, (current) => {
+					if (/* @__PURE__ */ isNull(current)) return;
+					nodes.set(current, id);
+					onWatcherCleanup(() => nodes.delete(current));
+				}, { immediate: true });
+			});
+			const indicator = computed(() => {
+				if (!registration.orientation || !isOver.value || !active.value) return null;
+				return resolveDropPosition(active.value.current, rects.value, registration.orientation);
+			});
+			const input = {
+				...registration,
+				id,
+				el,
+				isOver,
+				willAccept,
+				indicator
+			};
+			return _zones.register(input);
+		}
+	};
+	function at(point) {
+		if (!IN_BROWSER) return null;
+		let element = document.elementFromPoint(point.x, point.y);
+		while (element) {
+			const id = nodes.get(element);
+			if (!/* @__PURE__ */ isUndefined(id)) {
+				const zone = _zones.get(id);
+				if (zone && !toValue(zone.disabled)) return id;
+			}
+			element = element.parentElement;
+		}
+		return null;
+	}
+	function position(zoneId, drag) {
+		const zone = _zones.get(zoneId);
+		const out = { pointer: drag.current };
+		if (zone?.orientation) {
+			const resolved = zone.indicator?.value ?? null;
+			if (resolved) {
+				out.index = resolved.index;
+				out.indicator = resolved;
+			} else out.index = 0;
+		}
+		return out;
+	}
+	function bail(drag, reason = "cancel") {
+		active.value = null;
+		if (!/* @__PURE__ */ isNull(drag.over)) next(_zones.get(drag.over)?.onLeave, drag);
+		next(_draggables.get(drag.id)?.onCancel, drag, reason);
+		next(options.onCancel, drag, reason);
+	}
+	function onStart(source, origin, via) {
+		if (toValue(_draggables.get(source.id)?.disabled)) return;
+		const draft = {
+			id: source.id,
+			type: source.type,
+			value: source.value,
+			origin,
+			current: origin,
+			delta: {
+				x: 0,
+				y: 0
+			},
+			over: null,
+			willAccept: false,
+			via
+		};
+		try {
+			if (_draggables.get(source.id)?.onBeforeStart?.(draft) === false) return;
+		} catch (error) {
+			logger.error("useDragDrop onBeforeStart threw; treating as veto", error);
+			return;
+		}
+		try {
+			if (options.onBeforeStart?.(draft) === false) return;
+		} catch (error) {
+			logger.error("useDragDrop onBeforeStart threw; treating as veto", error);
+			return;
+		}
+		active.value = draft;
+	}
+	function onMove(point) {
+		if (!active.value) return;
+		const over = at(point);
+		const draft = {
+			...active.value,
+			current: point,
+			delta: {
+				x: point.x - active.value.origin.x,
+				y: point.y - active.value.origin.y
+			},
+			over,
+			willAccept: false
+		};
+		draft.willAccept = !/* @__PURE__ */ isNull(over) && safeAccept(_zones.get(over)?.accept, draft);
+		const previous = active.value.over;
+		active.value = draft;
+		if (previous !== over) {
+			if (!/* @__PURE__ */ isNull(previous)) next(_zones.get(previous)?.onLeave, draft);
+			if (!/* @__PURE__ */ isNull(over)) next(_zones.get(over)?.onEnter, draft);
+		}
+		next(_draggables.get(draft.id)?.onMove, draft);
+		next(options.onMove, draft);
+	}
+	function onDrop() {
+		if (!active.value) return;
+		const drag = active.value;
+		const zoneId = drag.over;
+		if (/* @__PURE__ */ isNull(zoneId)) {
+			bail(drag);
+			return;
+		}
+		const dropAt = position(zoneId, drag);
+		const zone = _zones.get(zoneId);
+		function vetoed(fn, label) {
+			if (!fn) return false;
+			try {
+				return fn(drag, dropAt) === false;
+			} catch (error) {
+				logger.error(`useDragDrop ${label} threw; treating as veto`, error);
+				return true;
+			}
+		}
+		if (vetoed(zone?.onBeforeDrop, "zone onBeforeDrop") || vetoed(options.onBeforeDrop, "options onBeforeDrop")) {
+			bail(drag, "reject");
+			return;
+		}
+		active.value = null;
+		next(zone?.onDrop, drag, dropAt);
+		next(options.onDrop, drag, dropAt);
+	}
+	function cancel() {
+		if (!active.value) return;
+		bail(active.value);
+	}
+	const context = {
+		draggables,
+		zones,
+		active: shallowReadonly(active),
+		isDragging,
+		cancel
+	};
+	const disposers = [];
+	const adapters = options.adapters ?? [new PointerAdapter(), new KeyboardAdapter()];
+	const emit = {
+		start: (source, origin, via) => onStart(source, origin, via),
+		move: (point) => onMove(point),
+		drop: () => onDrop(),
+		cancel: () => cancel()
+	};
+	const adapterContext = {
+		...context,
+		emit
+	};
+	for (const adapter of adapters) try {
+		adapter.setup(adapterContext);
+		disposers.push(() => adapter.dispose());
+	} catch (error) {
+		logger.error("useDragDrop adapter setup threw; skipping adapter", error);
+		try {
+			adapter.dispose();
+		} catch (disposeError) {
+			logger.error("useDragDrop adapter dispose threw after setup failure", disposeError);
+		}
+	}
+	for (const plugin of plugins) try {
+		const dispose = plugin(context);
+		if (/* @__PURE__ */ isFunction(dispose)) disposers.push(dispose);
+	} catch (error) {
+		logger.error("useDragDrop plugin install threw; skipping plugin", error);
+	}
+	_draggables.on("unregister:ticket", (ticket) => {
+		if (active.value?.id === ticket.id) cancel();
+	});
+	_zones.on("unregister:ticket", (ticket) => {
+		const scope = scopes.get(ticket.id);
+		if (scope) {
+			scope.stop();
+			scopes.delete(ticket.id);
+		}
+		if (active.value?.over === ticket.id) {
+			next(ticket.onLeave, active.value);
+			active.value = {
+				...active.value,
+				over: null,
+				willAccept: false
+			};
+		}
+	});
+	onScopeDispose(() => {
+		if (!/* @__PURE__ */ isNull(active.value)) cancel();
+		for (const dispose of disposers.toReversed()) try {
+			dispose();
+		} catch (error) {
+			logger.error("useDragDrop disposer threw", error);
+		}
+		for (const scope of scopes.values()) try {
+			scope.stop();
+		} catch (error) {
+			logger.error("useDragDrop zone scope dispose threw", error);
+		}
+		scopes.clear();
+		nodes.clear();
+		try {
+			_draggables.dispose();
+		} catch (error) {
+			logger.error("useDragDrop draggables dispose threw", error);
+		}
+		try {
+			_zones.dispose();
+		} catch (error) {
+			logger.error("useDragDrop zones dispose threw", error);
+		}
+	}, true);
+	return context;
+}
+//#endregion
+//#region src/composables/useHotkey/aliases.ts
+/**
+* Key alias mapping for consistent key normalization across the hotkey system.
+*
+* Maps user-friendly aliases to canonical key names that match
+* KeyboardEvent.key values (in lowercase) where possible.
+*/
+const keyAliasMap = {
+	control: "ctrl",
+	command: "cmd",
+	option: "alt",
+	up: "arrowup",
+	down: "arrowdown",
+	left: "arrowleft",
+	right: "arrowright",
+	esc: "escape",
+	spacebar: " ",
+	space: " ",
+	return: "enter",
+	del: "delete",
+	plus: "+",
+	slash: "/",
+	underscore: "_",
+	minus: "-",
+	hyphen: "-"
+};
+/* @__NO_SIDE_EFFECTS__ */
+function normalizeKey(key) {
+	const lowerKey = key.toLowerCase();
+	return keyAliasMap[lowerKey] ?? lowerKey;
+}
+//#endregion
+//#region src/composables/useHotkey/parsing.ts
+const logger = /* @__PURE__ */ useLogger();
+const MODIFIERS = [
+	"ctrl",
+	"shift",
+	"alt",
+	"meta",
+	"cmd"
+];
+/**
+* Splits a single combination string into individual key parts.
+*
+* A combination is a set of keys that must be pressed simultaneously.
+* e.g. `ctrl+k`, `shift+-`
+*
+* @param combination - The combination string to parse
+* @param isInternal - Whether this is an internal call (suppresses warnings)
+* @returns Object with keys array and separators array
+*/
+function splitKeyCombination(combination, isInternal = false) {
+	const emptyResult = {
+		keys: [],
+		separators: []
+	};
+	if (!combination) {
+		if (!isInternal) logger.warn("Invalid hotkey combination: empty string provided");
+		return emptyResult;
+	}
+	if (combination.length > 1 && [
+		"+",
+		"/",
+		"_"
 	].some((v) => combination.startsWith(v)) && ![
 		"++",
 		"//",
@@ -4875,9 +5982,11 @@ function useHotkey(keys, callback, options = {}, _platform) {
 	let isSequence = false;
 	let groupIndex = 0;
 	function isInputFocused() {
+		/* v8 ignore next -- IN_BROWSER always true in happy-dom test env */
 		if (!IN_BROWSER) return false;
 		if (toValue(inputs)) return false;
 		const activeElement = document.activeElement;
+		/* v8 ignore next -- defensive: document.activeElement is always set in happy-dom */
 		if (!activeElement) return false;
 		const role = activeElement.getAttribute("role");
 		if (role === "textbox" || role === "searchbox" || role === "combobox" || role === "spinbutton") return true;
@@ -4931,6 +6040,7 @@ function useHotkey(keys, callback, options = {}, _platform) {
 		const currentKeys = toValue(keys);
 		if (!currentKeys) return;
 		const groups = splitKeySequence(currentKeys.toLowerCase());
+		/* v8 ignore next -- defensive: splitKeySequence rejects empty strings earlier */
 		if (groups.length === 0) return;
 		isSequence = groups.length > 1;
 		keyGroups = groups;
@@ -4983,6 +6093,7 @@ function isModifier(key) {
 function parseKeyGroup(group) {
 	const { keys: parts } = splitKeyCombination(group.toLowerCase());
 	const modifiers = Object.fromEntries(MODIFIERS.map((m) => [m, false]));
+	/* v8 ignore next 3 -- defensive: parseKeyGroup is not invoked with empty parts */
 	if (parts.length === 0) return {
 		modifiers,
 		actualKey: void 0
@@ -5208,11 +6319,13 @@ function useIntersectionObserver(target, callback, options = {}) {
 			observe: (obs, el) => obs.observe(el),
 			onEntry: (entries) => {
 				const latest = entries.at(-1);
+				/* v8 ignore next -- defensive: IntersectionObserver always emits at least one entry */
 				if (latest) isIntersecting.value = latest.isIntersecting;
 			},
 			onPause: () => {
 				isIntersecting.value = false;
 			},
+			/* v8 ignore next -- defensive nullish coalesce: entries always populated when shouldStop fires */
 			shouldStop: (entries) => entries.at(-1)?.isIntersecting ?? false,
 			immediate: options.immediate ? (el) => {
 				return [{
@@ -5262,6 +6375,7 @@ function useElementIntersection(target, options = {}) {
 	const intersectionRatio = shallowRef(0);
 	const { pause: _pause, resume, stop, isActive, isPaused } = useIntersectionObserver(target, (entries) => {
 		const entry = entries.at(-1);
+		/* v8 ignore next 4 -- defensive: IntersectionObserver always emits at least one entry */
 		if (entry) {
 			isIntersecting.value = entry.isIntersecting;
 			intersectionRatio.value = entry.intersectionRatio;
@@ -5511,131 +6625,6 @@ function usePrefersContrast() {
 	return useMediaQuery("(prefers-contrast: more)");
 }
 //#endregion
-//#region src/composables/useMutationObserver/index.ts
-/**
-* @module useMutationObserver
-*
-* @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
-*
-* @remarks
-* MutationObserver composable with lifecycle management.
-*
-* Key features:
-* - MutationObserver API wrapper
-* - `isActive` reactive flag
-* - `once` option for single-fire observation
-* - Pause/resume/stop functionality
-* - Automatic cleanup on unmount
-* - SSR-safe (checks SUPPORTS_MUTATION_OBSERVER)
-* - Hydration-aware
-* - Configurable observation options (childList, attributes, characterData, etc.)
-*
-* Perfect for detecting DOM changes and responding to mutations.
-*
-* @example
-* ```ts
-* import { useTemplateRef } from 'vue'
-* import { useMutationObserver } from '@vuetify/v0'
-*
-* const target = useTemplateRef('target')
-* useMutationObserver(target, records => {
-*   console.log(records)
-* }, { childList: true })
-* ```
-*/
-/**
-* A composable that uses the Mutation Observer API to detect changes in the DOM.
-*
-* @param target The element to observe.
-* @param callback The callback to execute when a mutation is observed.
-* @param options The options for the Mutation Observer.
-* @returns An object with methods to control the observer.
-*
-* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
-* @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
-*
-* @example
-* ```ts
-* import { ref } from 'vue'
-* import { useMutationObserver } from '@vuetify/v0'
-*
-* const container = ref<HTMLElement>()
-*
-* const { pause, resume, isPaused } = useMutationObserver(
-*   container,
-*   (mutations) => {
-*     mutations.forEach((mutation) => {
-*       if (mutation.type === 'childList') {
-*         console.log('Children changed:', mutation.addedNodes, mutation.removedNodes)
-*       } else if (mutation.type === 'attributes') {
-*         console.log('Attribute changed:', mutation.attributeName)
-*       }
-*     })
-*   },
-*   {
-*     childList: true,
-*     attributes: true,
-*     subtree: true
-*   }
-* )
-*
-* // Pause observation
-* pause()
-*
-* // Resume observation
-* resume()
-* ```
-*/
-function useMutationObserver(target, callback, options = {}) {
-	const observerOptions = {
-		childList: options.childList ?? true,
-		attributes: options.attributes ?? false,
-		characterData: options.characterData ?? false,
-		subtree: options.subtree ?? false,
-		attributeOldValue: options.attributeOldValue ?? false,
-		characterDataOldValue: options.characterDataOldValue ?? false,
-		attributeFilter: options.attributeFilter
-	};
-	return createObserver(target, callback, {
-		supports: SUPPORTS_MUTATION_OBSERVER,
-		once: options.once,
-		create: (cb) => new MutationObserver((mutations) => {
-			cb(mutations.map((m) => ({
-				type: m.type,
-				target: m.target,
-				addedNodes: m.addedNodes,
-				removedNodes: m.removedNodes,
-				previousSibling: m.previousSibling,
-				nextSibling: m.nextSibling,
-				attributeName: m.attributeName,
-				attributeNamespace: m.attributeNamespace,
-				oldValue: m.oldValue
-			})));
-		}),
-		observe: (obs, el) => obs.observe(el, observerOptions),
-		immediate: options.immediate ? (el) => {
-			const emptyNodeList = {
-				length: 0,
-				item: () => null,
-				forEach: () => {},
-				*[Symbol.iterator]() {}
-			};
-			return [{
-				type: "childList",
-				target: el,
-				addedNodes: emptyNodeList,
-				removedNodes: emptyNodeList,
-				previousSibling: null,
-				nextSibling: null,
-				attributeName: null,
-				attributeNamespace: null,
-				oldValue: null
-			}];
-		} : void 0,
-		onceIncludesImmediate: true
-	});
-}
-//#endregion
 //#region src/composables/usePresence/index.ts
 /**
 * @module usePresence
@@ -6019,8 +7008,11 @@ function useRovingFocus(items, options = {}) {
 	};
 }
 //#endregion
+//#region src/composables/useRtl/adapters/adapter.ts
+var RtlAdapter = class {};
+//#endregion
 //#region src/composables/useRtl/adapters/v0.ts
-var Vuetify0RtlAdapter = class {
+var V0RtlAdapter = class extends RtlAdapter {
 	setup(app, context, target) {
 		if (IN_BROWSER) {
 			if (/* @__PURE__ */ isNull(target)) return;
@@ -6088,7 +7080,7 @@ function createRtlFallback() {
 }
 const [createRtlContext, createRtlPlugin, useRtl] = createPluginContext("v0:rtl", (options) => createRtl(options), {
 	fallback: () => createRtlFallback(),
-	setup: (context, app, { adapter = new Vuetify0RtlAdapter(), target }) => {
+	setup: (context, app, { adapter = new V0RtlAdapter(), target }) => {
 		adapter.setup(app, context, target);
 	},
 	persist: (ctx) => ctx.isRtl.value,
@@ -6380,7 +7372,7 @@ function useStack(namespace = "v0:stack") {
 * ```
 */
 function createStorage(options = {}) {
-	const { adapter = IN_BROWSER ? window.localStorage : new MemoryAdapter(), prefix = "v0:", serializer = {
+	const { adapter = IN_BROWSER ? window.localStorage : new MemoryStorageAdapter(), prefix = "v0:", serializer = {
 		read: JSON.parse,
 		write: JSON.stringify
 	}, ttl } = options;
@@ -6395,9 +7387,9 @@ function createStorage(options = {}) {
 		if (/* @__PURE__ */ isNullOrUndefined(raw)) return void 0;
 		try {
 			const parsed = serializer.read(raw);
-			if (ttl && /* @__PURE__ */ isObject(parsed) && "__v0" in parsed && "__v" in parsed) {
+			if (/* @__PURE__ */ isObject(parsed) && "__v0" in parsed && "__v" in parsed) {
 				const envelope = parsed;
-				if (Date.now() - envelope.__t > ttl) {
+				if (ttl && Date.now() - envelope.__t > ttl) {
 					adapter?.removeItem(prefixedKey);
 					return;
 				}
@@ -6477,7 +7469,7 @@ function createStorage(options = {}) {
 	};
 }
 function createStorageFallback() {
-	return createStorage({ adapter: new MemoryAdapter() });
+	return createStorage({ adapter: new MemoryStorageAdapter() });
 }
 const [createStorageContext, createStoragePlugin, useStorage] = createPluginContext("v0:storage", (options) => createStorage(options), { fallback: () => createStorageFallback() });
 //#endregion
@@ -6824,6 +7816,7 @@ function useClickOutside(target, handler, options = {}) {
 	* Check if an element matches resolved ignore targets.
 	*/
 	function isIgnored(el, selectors, elements) {
+		/* v8 ignore next -- defensive guard, callers always pass an Element */
 		if (!el) return false;
 		for (const selector of selectors) try {
 			if (el.matches(selector) || !/* @__PURE__ */ isNull(el.closest(selector))) return true;
@@ -6850,6 +7843,7 @@ function useClickOutside(target, handler, options = {}) {
 		const targets = getTargets();
 		if (targets.length === 0) return false;
 		return targets.every((el) => {
+			/* v8 ignore next -- defensive: getTargets filters to Element-typed values */
 			if (/* @__PURE__ */ isNullOrUndefined(el) || !/* @__PURE__ */ isFunction(el.contains)) return false;
 			return el !== eventTarget && !el.contains(eventTarget);
 		});
@@ -6859,6 +7853,7 @@ function useClickOutside(target, handler, options = {}) {
 	*/
 	function isOutsideBounds(x, y) {
 		const targets = getTargets();
+		/* v8 ignore next -- edge case: bounds check only invoked when targets exist */
 		if (targets.length === 0) return false;
 		return targets.every((el) => {
 			const { left, right, top, bottom } = el.getBoundingClientRect();
@@ -6869,6 +7864,7 @@ function useClickOutside(target, handler, options = {}) {
 	* Validate that the target is still in the DOM.
 	*/
 	function isValidTarget(eventTarget) {
+		/* v8 ignore next -- type guard for non-Element targets (e.g., document, window) */
 		if (!/* @__PURE__ */ isElement(eventTarget)) return false;
 		if (!eventTarget.isConnected) return false;
 		return true;
@@ -6961,4 +7957,4 @@ function useClickOutside(target, handler, options = {}) {
 	};
 }
 //#endregion
-export { createSlider as $, useElementIntersection as A, ServerAdapter as At, createBreakpointsContext as B, usePresence as C, createValidation as Ct, usePrefersDark as D, createCombobox as Dt, usePrefersContrast as E, useForm as Et, createDate as F, createBreadcrumbsContext as Ft, createVirtualContext as G, useBreakpoints as H, createDateContext as I, useBreadcrumbs as It, createTimelineContext as J, useVirtual as K, createDatePlugin as L, useImage as M, useVirtualFocus as Mt, useHotkey as N, usePopover as Nt, usePrefersReducedMotion as O, createComboboxContext as Ot, useDelay as P, createBreadcrumbs as Pt, useStep as Q, useDate as R, useProxyModel as S, createInput as St, useMediaQuery as T, createFormContext as Tt, toReactive as U, createBreakpointsPlugin as V, createVirtual as W, createStep as X, useTimeline as Y, createStepContext as Z, createRtlPlugin as _, createNumberField as _t, useToggleScope as a, useProgress as at, useRovingFocus as b, createNestedContext as bt, createStoragePlugin as c, useOverflow as ct, createStackContext as d, toElement as dt, createRating as et, createStackPlugin as f, createFallbackHydration as ft, createRtlFallback as g, useHydration as gt, createRtlContext as h, createHydrationPlugin as ht, useWindowEventListener as i, createProgressContext as it, useIntersectionObserver as j, ClientAdapter as jt, useLazy as k, useCombobox as kt, useStorage as l, useElementSize as lt, createRtl as m, createHydrationContext as mt, useDocumentEventListener as n, useRating as nt, createStorage as o, createOverflow as ot, useStack as p, createHydration as pt, createTimeline as q, useEventListener as r, createProgress as rt, createStorageContext as s, createOverflowContext as st, useClickOutside as t, createRatingContext as tt, createStack as u, useResizeObserver as ut, useRtl as v, createNumeric as vt, useMutationObserver as w, createForm as wt, useRaf as x, useNested as xt, Vuetify0RtlAdapter as y, createNested as yt, createBreakpoints as z };
+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 };