@proyecto-viviana/solid-stately 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { createComputed, createContext, createEffect, createMemo, createSignal, createUniqueId, on, onCleanup, untrack, useContext } from "solid-js";
 import { isServer as isServer$1 } from "solid-js/web";
-import { CalendarDate as CalendarDateClass, CalendarDateTime as CalendarDateTimeClass, DateFormatter, DateFormatter as DateFormatter$1, GregorianCalendar, GregorianCalendar as GregorianCalendar$1, Time, Time as TimeClass, ZonedDateTime as ZonedDateTimeClass, createCalendar, createCalendar as createCalendar$1, endOfMonth, endOfMonth as endOfMonth$1, endOfWeek, endOfYear, getDayOfWeek, getLocalTimeZone, getLocalTimeZone as getLocalTimeZone$1, getWeeksInMonth, getWeeksInMonth as getWeeksInMonth$1, isEqualCalendar, isSameDay, isSameDay as isSameDay$1, isSameMonth, isSameMonth as isSameMonth$1, isSameYear, isToday, isWeekend, maxDate, minDate, now, parseAbsolute, parseAbsoluteToLocal, parseDate, parseDateTime, parseTime, parseZonedDateTime, startOfMonth, startOfMonth as startOfMonth$1, startOfWeek, startOfWeek as startOfWeek$1, startOfYear, toCalendar, toCalendar as toCalendar$1, toCalendarDate, toCalendarDate as toCalendarDate$1, toCalendarDateTime, toCalendarDateTime as toCalendarDateTime$1, toTime, toZoned, toZoned as toZoned$1, today, today as today$1 } from "@internationalized/date";
+import { CalendarDate, CalendarDate as CalendarDateClass, CalendarDateTime as CalendarDateTimeClass, DateFormatter, DateFormatter as DateFormatter$1, GregorianCalendar, GregorianCalendar as GregorianCalendar$1, Time, Time as TimeClass, ZonedDateTime as ZonedDateTimeClass, createCalendar, createCalendar as createCalendar$1, endOfMonth, endOfMonth as endOfMonth$1, endOfWeek, endOfYear, getDayOfWeek, getLocalTimeZone, getLocalTimeZone as getLocalTimeZone$1, getWeeksInMonth, getWeeksInMonth as getWeeksInMonth$1, isEqualCalendar, isSameDay, isSameDay as isSameDay$1, isSameMonth, isSameMonth as isSameMonth$1, isSameYear, isToday, isWeekend, maxDate, maxDate as maxDate$1, minDate, minDate as minDate$1, now, parseAbsolute, parseAbsoluteToLocal, parseDate, parseDateTime, parseTime, parseZonedDateTime, startOfMonth, startOfMonth as startOfMonth$1, startOfWeek, startOfWeek as startOfWeek$1, startOfYear, toCalendar, toCalendar as toCalendar$1, toCalendarDate, toCalendarDate as toCalendarDate$1, toCalendarDateTime, toCalendarDateTime as toCalendarDateTime$1, toTime, toZoned, toZoned as toZoned$1, today, today as today$1 } from "@internationalized/date";
 //#region src/utils/reactivity.ts
 /**
 * Unwraps a MaybeAccessor to get the underlying value.
@@ -863,21 +863,11 @@ function createSelectionState(props = {}) {
 		const rangeKeys = keys.slice(start, end + 1).filter((k) => !isDisabled(k));
 		updateSelection(new Set(rangeKeys));
 	};
-	const select = (key, e, collection) => {
-		if (isDisabled(key)) return;
+	const select = (key, e) => {
 		if (selectionMode() === "none") return;
-		const mode = selectionMode();
-		const behavior = selectionBehavior();
-		if (mode === "single") {
-			if (behavior === "replace" || !isSelected(key)) replaceSelection(key);
-			else if (!disallowEmptySelection()) clearSelection();
-			return;
-		}
-		if (e?.shiftKey && collection) {
-			extendSelection(key, collection);
-			return;
-		}
-		if (e?.ctrlKey || e?.metaKey || behavior === "toggle") toggleSelection(key);
+		if (selectionMode() === "single") if (isSelected(key) && !disallowEmptySelection()) toggleSelection(key);
+		else replaceSelection(key);
+		else if (selectionBehavior() === "toggle" || e != null && (e.pointerType === "touch" || e.pointerType === "virtual")) toggleSelection(key);
 		else replaceSelection(key);
 	};
 	const setSelectionBehavior = (behavior) => {
@@ -914,6 +904,477 @@ function normalizeSelection$2(keys) {
 	return new Set(keys);
 }
 //#endregion
+//#region src/selection/Selection.ts
+/**
+* A Selection is a special Set containing Keys, which also has an anchor
+* and current selected key for use when range selecting.
+*/
+var Selection = class Selection extends Set {
+	anchorKey;
+	currentKey;
+	constructor(keys, anchorKey, currentKey) {
+		super(keys);
+		if (keys instanceof Selection) {
+			this.anchorKey = anchorKey ?? keys.anchorKey;
+			this.currentKey = currentKey ?? keys.currentKey;
+		} else {
+			this.anchorKey = anchorKey ?? null;
+			this.currentKey = currentKey ?? null;
+		}
+	}
+};
+//#endregion
+//#region src/selection/createMultipleSelectionState.ts
+/**
+* Raw multiple-selection + focus state for a collection.
+*
+* The lower of the two selection layers ported from upstream
+* (`@react-stately/selection`'s `useMultipleSelectionState`): it owns the
+* selected keys, focus, selection behavior, and disabled keys, but is NOT
+* collection-aware. The collection-aware operations (toggle, extend, select
+* all, range, etc.) live in {@link SelectionManager}, which is built on top of
+* this state.
+*
+* Based on @react-stately/selection.
+*/
+function equalSets(setA, setB) {
+	if (setA.size !== setB.size) return false;
+	for (const item of setA) if (!setB.has(item)) return false;
+	return true;
+}
+function convertSelection(selection, defaultValue) {
+	if (!selection) return defaultValue;
+	return selection === "all" ? "all" : new Selection(selection);
+}
+/**
+* Manages raw state for multiple selection and focus in a collection.
+*/
+function createMultipleSelectionState(props = {}) {
+	const getProps = () => access(props);
+	const [isFocused, setIsFocused] = createSignal(false);
+	const [focusedKey, setFocusedKeySignal] = createSignal(null);
+	const [childFocusStrategy, setChildFocusStrategy] = createSignal(null);
+	const [uncontrolledSelectedKeys, setUncontrolledSelectedKeys] = createSignal(convertSelection(getProps().defaultSelectedKeys, new Selection()));
+	const selectedKeys = createMemo(() => {
+		const p = getProps();
+		if (p.selectedKeys !== void 0) return convertSelection(p.selectedKeys, new Selection());
+		return uncontrolledSelectedKeys();
+	});
+	const selectionBehaviorProp = () => getProps().selectionBehavior ?? "toggle";
+	const [selectionBehavior, setSelectionBehaviorState] = createSignal(selectionBehaviorProp());
+	createComputed(() => {
+		const keys = selectedKeys();
+		if (selectionBehaviorProp() === "replace" && untrack(selectionBehavior) === "toggle" && typeof keys === "object" && keys.size === 0) setSelectionBehaviorState("replace");
+	});
+	let lastSelectionBehavior = selectionBehaviorProp();
+	createComputed(() => {
+		const prop = selectionBehaviorProp();
+		if (prop !== lastSelectionBehavior) {
+			setSelectionBehaviorState(prop);
+			lastSelectionBehavior = prop;
+		}
+	});
+	const disabledKeys = createMemo(() => {
+		const keys = getProps().disabledKeys;
+		return keys ? new Set(keys) : /* @__PURE__ */ new Set();
+	});
+	let lastSelectionEvent = null;
+	const emitSelectionEvent = (keys) => {
+		lastSelectionEvent = keys;
+		getProps().onSelectionChange?.(keys);
+	};
+	const setSelectedKeys = (keys) => {
+		const p = getProps();
+		const current = selectedKeys();
+		if (!(p.allowDuplicateSelectionEvents || keys === "all" || current === "all" || !equalSets(keys, current))) return;
+		if (p.selectedKeys === void 0) setUncontrolledSelectedKeys(keys);
+		emitSelectionEvent(keys);
+	};
+	const emitDuplicateSelectionEvent = (keys) => {
+		const eventKeys = keys ?? lastSelectionEvent;
+		if (eventKeys == null) return;
+		emitSelectionEvent(eventKeys);
+	};
+	return {
+		get selectionMode() {
+			return getProps().selectionMode ?? "none";
+		},
+		get selectionBehavior() {
+			return selectionBehavior();
+		},
+		setSelectionBehavior(behavior) {
+			setSelectionBehaviorState(behavior);
+		},
+		get disallowEmptySelection() {
+			return getProps().disallowEmptySelection ?? false;
+		},
+		get isFocused() {
+			return isFocused();
+		},
+		setFocused(f) {
+			setIsFocused(f);
+		},
+		get focusedKey() {
+			return focusedKey();
+		},
+		get childFocusStrategy() {
+			return childFocusStrategy();
+		},
+		setFocusedKey(key, strategy = "first") {
+			setFocusedKeySignal(key);
+			setChildFocusStrategy(strategy);
+		},
+		get selectedKeys() {
+			return selectedKeys();
+		},
+		get lastSelectionEvent() {
+			return lastSelectionEvent;
+		},
+		setSelectedKeys,
+		emitDuplicateSelectionEvent,
+		get disabledKeys() {
+			return disabledKeys();
+		},
+		get disabledBehavior() {
+			return getProps().disabledBehavior ?? "all";
+		}
+	};
+}
+//#endregion
+//#region src/collections/getChildNodes.ts
+function getChildNodes(node, collection) {
+	if (typeof collection.getChildren === "function") return collection.getChildren(node.key);
+	return node.childNodes;
+}
+function getFirstItem(iterable) {
+	return getNthItem(iterable, 0);
+}
+function getNthItem(iterable, index) {
+	if (index < 0) return;
+	let i = 0;
+	for (const item of iterable) {
+		if (i === index) return item;
+		i++;
+	}
+}
+function compareNodeOrder(collection, a, b) {
+	if (a.parentKey === b.parentKey) return a.index - b.index;
+	const aAncestors = [...getAncestors(collection, a), a];
+	const bAncestors = [...getAncestors(collection, b), b];
+	const firstNonMatchingAncestor = aAncestors.slice(0, bAncestors.length).findIndex((a, i) => a !== bAncestors[i]);
+	if (firstNonMatchingAncestor !== -1) {
+		a = aAncestors[firstNonMatchingAncestor];
+		b = bAncestors[firstNonMatchingAncestor];
+		return a.index - b.index;
+	}
+	if (aAncestors.findIndex((node) => node === b) >= 0) return 1;
+	else if (bAncestors.findIndex((node) => node === a) >= 0) return -1;
+	return -1;
+}
+function getAncestors(collection, node) {
+	const parents = [];
+	let currNode = node;
+	while (currNode?.parentKey != null) {
+		currNode = collection.getItem(currNode.parentKey);
+		if (currNode) parents.unshift(currNode);
+	}
+	return parents;
+}
+//#endregion
+//#region src/selection/SelectionManager.ts
+/**
+* An interface for reading and updating multiple selection state.
+*
+* The upper of the two selection layers ported from upstream
+* (`@react-stately/selection`'s `SelectionManager`): the collection-aware
+* operations built on top of the raw {@link MultipleSelectionState}.
+*
+* React → Solid adaptations, all faithful to upstream's observable contract:
+*  - Upstream re-instantiates `SelectionManager` every render to capture a
+*    fresh `collection`. Here the manager is long-lived, so it captures a
+*    reactive `collection` accessor and reads it live via `get collection()`.
+*  - Upstream caches `_isSelectAll` for the lifetime of one render. A
+*    long-lived manager would let that cache go stale, so it is dropped and
+*    `isSelectAll` recomputes (it is consulted rarely — only by select-all UI).
+*  - Our `CollectionNode` has no `'cell'` type (grids/trees use a separate
+*    state engine), so the cell-selection branches are omitted.
+*
+* Based on @react-stately/selection.
+*/
+/**
+* An interface for reading and updating multiple selection state.
+*/
+var SelectionManager = class SelectionManager {
+	collectionAccessor;
+	state;
+	layoutDelegate;
+	fullCollection;
+	constructor(collection, state, options) {
+		this.collectionAccessor = collection;
+		this.state = state;
+		this.layoutDelegate = options?.layoutDelegate ?? null;
+		this.fullCollection = options?.fullCollection ?? null;
+	}
+	/** The collection the manager operates over (read live so it stays reactive). */
+	get collection() {
+		return this.collectionAccessor();
+	}
+	/** The type of selection that is allowed in the collection. */
+	get selectionMode() {
+		return this.state.selectionMode;
+	}
+	/** Whether the collection allows empty selection. */
+	get disallowEmptySelection() {
+		return this.state.disallowEmptySelection;
+	}
+	/** The selection behavior for the collection. */
+	get selectionBehavior() {
+		return this.state.selectionBehavior;
+	}
+	/** Sets the selection behavior for the collection. */
+	setSelectionBehavior(selectionBehavior) {
+		this.state.setSelectionBehavior(selectionBehavior);
+	}
+	/** Whether the collection is currently focused. */
+	get isFocused() {
+		return this.state.isFocused;
+	}
+	/** Sets whether the collection is focused. */
+	setFocused(isFocused) {
+		this.state.setFocused(isFocused);
+	}
+	/** The current focused key in the collection. */
+	get focusedKey() {
+		return this.state.focusedKey;
+	}
+	/** Whether the first or last child of the focused key should receive focus. */
+	get childFocusStrategy() {
+		return this.state.childFocusStrategy;
+	}
+	/** Sets the focused key. */
+	setFocusedKey(key, childFocusStrategy) {
+		if (key == null || this.collection.getItem(key)) this.state.setFocusedKey(key, childFocusStrategy);
+	}
+	/** The currently selected keys in the collection (materialized — 'all' is expanded). */
+	get selectedKeys() {
+		const keys = this.state.selectedKeys;
+		return keys === "all" ? new Set(this.getSelectAllKeys()) : keys;
+	}
+	/** The raw selection value for the collection. Either 'all' for select all, or a set of keys. */
+	get rawSelection() {
+		return this.state.selectedKeys;
+	}
+	/** Last selection payload emitted through onSelectionChange. @internal */
+	get lastSelectionEvent() {
+		return this.state.lastSelectionEvent;
+	}
+	/** Re-emits a selection payload without recomputing selection. @internal */
+	emitDuplicateSelectionEvent(keys = this.state.lastSelectionEvent) {
+		if (keys == null || this.selectionMode === "none") return;
+		this.state.emitDuplicateSelectionEvent(keys);
+	}
+	/** Returns whether a key is selected. */
+	isSelected(key) {
+		if (this.state.selectionMode === "none") return false;
+		const mappedKey = this.getKey(key);
+		if (mappedKey == null) return false;
+		const selectedKeys = this.state.selectedKeys;
+		return selectedKeys === "all" ? this.canSelectItem(mappedKey) : selectedKeys.has(mappedKey);
+	}
+	/** Whether the selection is empty. */
+	get isEmpty() {
+		return this.state.selectedKeys !== "all" && this.state.selectedKeys.size === 0;
+	}
+	/** Whether all items in the collection are selected. */
+	get isSelectAll() {
+		if (this.isEmpty) return false;
+		const selectedKeys = this.state.selectedKeys;
+		if (selectedKeys === "all") return true;
+		return this.getSelectAllKeys().every((k) => selectedKeys.has(k));
+	}
+	get firstSelectedKey() {
+		let first = null;
+		for (const key of this.state.selectedKeys) {
+			const item = this.collection.getItem(key);
+			if (!first || item && compareNodeOrder(this.collection, item, first) < 0) first = item;
+		}
+		return first?.key ?? null;
+	}
+	get lastSelectedKey() {
+		let last = null;
+		for (const key of this.state.selectedKeys) {
+			const item = this.collection.getItem(key);
+			if (!last || item && compareNodeOrder(this.collection, item, last) > 0) last = item;
+		}
+		return last?.key ?? null;
+	}
+	get disabledKeys() {
+		return this.state.disabledKeys;
+	}
+	get disabledBehavior() {
+		return this.state.disabledBehavior;
+	}
+	/** Extends the selection to the given key. */
+	extendSelection(toKey) {
+		if (this.selectionMode === "none") return;
+		if (this.selectionMode === "single") {
+			this.replaceSelection(toKey);
+			return;
+		}
+		const mappedToKey = this.getKey(toKey);
+		if (mappedToKey == null) return;
+		let selection;
+		const currentSelection = this.state.selectedKeys;
+		if (currentSelection === "all") selection = new Selection([mappedToKey], mappedToKey, mappedToKey);
+		else {
+			const selectedKeys = currentSelection;
+			const anchorKey = selectedKeys.anchorKey ?? mappedToKey;
+			selection = new Selection(selectedKeys, anchorKey, mappedToKey);
+			for (const key of this.getKeyRange(anchorKey, selectedKeys.currentKey ?? mappedToKey)) selection.delete(key);
+			for (const key of this.getKeyRange(mappedToKey, anchorKey)) if (this.canSelectItem(key)) selection.add(key);
+		}
+		this.state.setSelectedKeys(selection);
+	}
+	getKeyRange(from, to) {
+		const fromItem = this.collection.getItem(from);
+		const toItem = this.collection.getItem(to);
+		if (fromItem && toItem) {
+			if (compareNodeOrder(this.collection, fromItem, toItem) <= 0) return this.getKeyRangeInternal(from, to);
+			return this.getKeyRangeInternal(to, from);
+		}
+		return [];
+	}
+	getKeyRangeInternal(from, to) {
+		if (this.layoutDelegate?.getKeyRange) return this.layoutDelegate.getKeyRange(from, to);
+		const keys = [];
+		let key = from;
+		while (key != null) {
+			const item = this.collection.getItem(key);
+			if (item && item.type === "item") keys.push(key);
+			if (key === to) return keys;
+			key = this.collection.getKeyAfter(key);
+		}
+		return [];
+	}
+	getKey(key) {
+		let item = this.collection.getItem(key);
+		if (!item) return key;
+		while (item && item.type !== "item" && item.parentKey != null) item = this.collection.getItem(item.parentKey);
+		if (!item || item.type !== "item") return null;
+		return item.key;
+	}
+	/** Toggles whether the given key is selected. */
+	toggleSelection(key) {
+		if (this.selectionMode === "none") return;
+		if (this.selectionMode === "single" && !this.isSelected(key)) {
+			this.replaceSelection(key);
+			return;
+		}
+		const mappedKey = this.getKey(key);
+		if (mappedKey == null) return;
+		const keys = new Selection(this.state.selectedKeys === "all" ? this.getSelectAllKeys() : this.state.selectedKeys);
+		if (keys.has(mappedKey)) keys.delete(mappedKey);
+		else if (this.canSelectItem(mappedKey)) {
+			keys.add(mappedKey);
+			keys.anchorKey = mappedKey;
+			keys.currentKey = mappedKey;
+		}
+		if (this.disallowEmptySelection && keys.size === 0) return;
+		this.state.setSelectedKeys(keys);
+	}
+	/** Replaces the selection with only the given key. */
+	replaceSelection(key) {
+		if (this.selectionMode === "none") return;
+		const mappedKey = this.getKey(key);
+		if (mappedKey == null) return;
+		const selection = this.canSelectItem(mappedKey) ? new Selection([mappedKey], mappedKey, mappedKey) : new Selection();
+		this.state.setSelectedKeys(selection);
+	}
+	/** Replaces the selection with the given keys. */
+	setSelectedKeys(keys) {
+		if (this.selectionMode === "none") return;
+		const selection = new Selection();
+		for (const key of keys) {
+			const mappedKey = this.getKey(key);
+			if (mappedKey != null) {
+				selection.add(mappedKey);
+				if (this.selectionMode === "single") break;
+			}
+		}
+		this.state.setSelectedKeys(selection);
+	}
+	getSelectAllKeys() {
+		const collection = this.fullCollection ?? this.collection;
+		const keys = [];
+		const addKeys = (key) => {
+			while (key != null) {
+				if (this.canSelectItemIn(key, collection)) {
+					const item = collection.getItem(key);
+					if (item?.type === "item") keys.push(key);
+					if (item?.hasChildNodes && item.type !== "item") addKeys(getFirstItem(getChildNodes(item, collection))?.key ?? null);
+				}
+				key = collection.getKeyAfter(key);
+			}
+		};
+		addKeys(collection.getFirstKey());
+		return keys;
+	}
+	/** Selects all items in the collection. */
+	selectAll() {
+		if (!this.isSelectAll && this.selectionMode === "multiple") this.state.setSelectedKeys("all");
+	}
+	/** Removes all keys from the selection. */
+	clearSelection() {
+		if (!this.disallowEmptySelection && (this.state.selectedKeys === "all" || this.state.selectedKeys.size > 0)) this.state.setSelectedKeys(new Selection());
+	}
+	/** Toggles between select all and an empty selection. */
+	toggleSelectAll() {
+		if (this.isSelectAll) this.clearSelection();
+		else this.selectAll();
+	}
+	select(key, e) {
+		if (this.selectionMode === "none") return;
+		if (this.selectionMode === "single") if (this.isSelected(key) && !this.disallowEmptySelection) this.toggleSelection(key);
+		else this.replaceSelection(key);
+		else if (this.selectionBehavior === "toggle" || e && (e.pointerType === "touch" || e.pointerType === "virtual")) this.toggleSelection(key);
+		else this.replaceSelection(key);
+	}
+	/** Returns whether the current selection is equal to the given selection. */
+	isSelectionEqual(selection) {
+		if (selection === this.state.selectedKeys) return true;
+		const selectedKeys = this.selectedKeys;
+		if (selection.size !== selectedKeys.size) return false;
+		for (const key of selection) if (!selectedKeys.has(key)) return false;
+		for (const key of selectedKeys) if (!selection.has(key)) return false;
+		return true;
+	}
+	canSelectItem(key) {
+		return this.canSelectItemIn(key, this.collection);
+	}
+	canSelectItemIn(key, collection) {
+		if (this.state.selectionMode === "none" || this.state.disabledKeys.has(key)) return false;
+		const item = collection.getItem(key);
+		if (!item || item.isDisabled || item.props?.isDisabled) return false;
+		return true;
+	}
+	isDisabled(key) {
+		const item = this.collection.getItem(key);
+		return this.state.disabledBehavior === "all" && (this.state.disabledKeys.has(key) || !!item?.props?.isDisabled) && item?.props?.disabledBehavior !== "selection";
+	}
+	isLink(key) {
+		return !!this.collection.getItem(key)?.props?.href;
+	}
+	getItemProps(key) {
+		return this.collection.getItem(key)?.props;
+	}
+	withCollection(collection) {
+		return new SelectionManager(() => collection, this.state, {
+			layoutDelegate: this.layoutDelegate ?? void 0,
+			fullCollection: this.fullCollection ?? this.collection
+		});
+	}
+};
+//#endregion
 //#region src/collections/createListState.ts
 /**
 * State management for list-like components.
@@ -952,7 +1413,7 @@ function createListState(props) {
 		for (const node of coll) if (node.isDisabled) itemDisabled.push(node.key);
 		return [...new Set([...propsDisabled, ...itemDisabled])];
 	});
-	const selectionState = createSelectionState({
+	const state = createMultipleSelectionState({
 		get selectionMode() {
 			return getProps().selectionMode;
 		},
@@ -981,21 +1442,34 @@ function createListState(props) {
 			return getProps().allowDuplicateSelectionEvents;
 		}
 	});
-	const [isFocused, setIsFocused] = createSignal(false);
-	const [focusedKey, setFocusedKeyInternal] = createSignal(null);
-	const [childFocusStrategy, setChildFocusStrategy] = createSignal(null);
-	const setFocusedKey = (key, childStrategy) => {
-		setFocusedKeyInternal(key);
-		setChildFocusStrategy(childStrategy ?? null);
-	};
+	const selectionManager = new SelectionManager(() => collection(), state);
 	return {
 		collection,
-		isFocused,
-		setFocused: setIsFocused,
-		focusedKey,
-		setFocusedKey,
-		childFocusStrategy,
-		...selectionState
+		selectionManager,
+		isFocused: () => state.isFocused,
+		setFocused: (isFocused) => state.setFocused(isFocused),
+		focusedKey: () => state.focusedKey,
+		setFocusedKey: (key, childStrategy) => selectionManager.setFocusedKey(key, childStrategy),
+		childFocusStrategy: () => state.childFocusStrategy,
+		selectionMode: () => selectionManager.selectionMode,
+		selectionBehavior: () => selectionManager.selectionBehavior,
+		disallowEmptySelection: () => selectionManager.disallowEmptySelection,
+		selectedKeys: () => state.selectedKeys,
+		disabledKeys: () => selectionManager.disabledKeys,
+		disabledBehavior: () => selectionManager.disabledBehavior,
+		isEmpty: () => selectionManager.isEmpty,
+		isSelectAll: () => selectionManager.isSelectAll,
+		isSelected: (key) => selectionManager.isSelected(key),
+		isDisabled: (key) => selectionManager.isDisabled(key),
+		setSelectionBehavior: (behavior) => selectionManager.setSelectionBehavior(behavior),
+		toggleSelection: (key) => selectionManager.toggleSelection(key),
+		replaceSelection: (key) => selectionManager.replaceSelection(key),
+		setSelectedKeys: (keys) => selectionManager.setSelectedKeys(keys),
+		selectAll: () => selectionManager.selectAll(),
+		clearSelection: () => selectionManager.clearSelection(),
+		toggleSelectAll: () => selectionManager.toggleSelectAll(),
+		extendSelection: (toKey, _collection) => selectionManager.extendSelection(toKey),
+		select: (key, e) => selectionManager.select(key, e)
 	};
 }
 /**
@@ -1111,6 +1585,9 @@ function createMenuState(props) {
 		},
 		get selectionBehavior() {
 			return getProps().selectionBehavior;
+		},
+		get allowDuplicateSelectionEvents() {
+			return getProps().allowDuplicateSelectionEvents;
 		}
 	});
 	const close = () => {
@@ -1144,6 +1621,9 @@ const dayOfWeekNames$1 = [
 function createCalendarState(props = {}) {
 	const timeZone = getLocalTimeZone$1();
 	const locale = createMemo(() => access(props.locale) ?? "en-US");
+	const minValueState = createMemo(() => access(props.minValue) ?? null);
+	const maxValueState = createMemo(() => access(props.maxValue) ?? null);
+	const selectionMode = createMemo(() => access(props.selectionMode) ?? "single");
 	const resolvedOptions = createMemo(() => new DateFormatter$1(locale()).resolvedOptions());
 	const calendar = createMemo(() => (props.createCalendar ?? createCalendar$1)(resolvedOptions().calendar));
 	const visibleMonths = props.visibleMonths ?? 1;
@@ -1151,13 +1631,13 @@ function createCalendarState(props = {}) {
 	const toDisplayCalendarDate = (date) => toCalendar$1(toCalendarDate$3(date), calendar());
 	const selectionAlignmentOffset = () => {
 		switch (props.selectionAlignment) {
+			case "start": return 0;
 			case "end": return Math.max(visibleMonths - 1, 0);
-			case "center": {
+			default: {
 				let halfDuration = Math.floor(visibleMonths / 2);
 				if (halfDuration > 0 && visibleMonths % 2 === 0) halfDuration--;
 				return halfDuration;
 			}
-			default: return 0;
 		}
 	};
 	const alignVisibleRangeStart = (date) => {
@@ -1182,8 +1662,10 @@ function createCalendarState(props = {}) {
 		if (controlledFocused) return toDisplayCalendarDate(controlledFocused);
 		if (props.defaultFocusedValue) return toDisplayCalendarDate(props.defaultFocusedValue);
 		const controlledValue = access(props.value);
-		if (controlledValue) return toDisplayCalendarDate(controlledValue);
-		if (props.defaultValue) return toDisplayCalendarDate(props.defaultValue);
+		const controlledFirst = Array.isArray(controlledValue) ? controlledValue[0] : controlledValue;
+		if (controlledFirst) return toDisplayCalendarDate(controlledFirst);
+		const defaultFirst = Array.isArray(props.defaultValue) ? props.defaultValue[0] : props.defaultValue;
+		if (defaultFirst) return toDisplayCalendarDate(defaultFirst);
 		return toCalendar$1(today$1(timeZone), calendar());
 	};
 	const initialFocusedDate = constrainDate(getInitialFocusedDate());
@@ -1198,6 +1680,7 @@ function createCalendarState(props = {}) {
 	});
 	const value = createMemo(() => {
 		const currentValue = sourceValue();
+		if (Array.isArray(currentValue)) return currentValue.map((v) => toDisplayCalendarDate(v));
 		return currentValue ? toDisplayCalendarDate(currentValue) : null;
 	});
 	const isDisabled = createMemo(() => access(props.isDisabled) ?? false);
@@ -1263,7 +1746,11 @@ function createCalendarState(props = {}) {
 	const setValue = (newValue) => {
 		if (isDisabled() || isReadOnly()) return;
 		const oldValue = sourceValue();
-		const nextValue = newValue ? convertValue$1(constrainDate(toDisplayCalendarDate(newValue)), oldValue) : null;
+		const referenceValue = Array.isArray(oldValue) ? oldValue[0] ?? null : oldValue;
+		let nextValue;
+		if (newValue == null) nextValue = selectionMode() === "multiple" ? [] : null;
+		else if (Array.isArray(newValue)) nextValue = newValue.map((v) => convertValue$1(constrainDate(toDisplayCalendarDate(v)), referenceValue));
+		else nextValue = convertValue$1(constrainDate(toDisplayCalendarDate(newValue)), referenceValue);
 		if (access(props.value) === void 0) setInternalValue(() => nextValue);
 		if (!Object.is(oldValue, nextValue) && props.onChange) props.onChange(nextValue);
 	};
@@ -1276,8 +1763,10 @@ function createCalendarState(props = {}) {
 	};
 	const isSelected = (date) => {
 		const v = value();
-		if (!v) return false;
-		return isSameDay$1(toDisplayCalendarDate(date), toDisplayCalendarDate(v));
+		if (v == null) return false;
+		const target = toDisplayCalendarDate(date);
+		if (Array.isArray(v)) return v.some((d) => isSameDay$1(target, toDisplayCalendarDate(d)));
+		return isSameDay$1(target, toDisplayCalendarDate(v));
 	};
 	const isCellFocused = (date) => {
 		return isSameDay$1(toDisplayCalendarDate(date), focusedDate());
@@ -1348,14 +1837,19 @@ function createCalendarState(props = {}) {
 	const selectFocusedDate = () => {
 		if (isReadOnly() || isDisabled()) return;
 		const date = focusedDate();
-		if (!isCellDisabled(date) && !isCellUnavailable(date)) setValue(date);
+		if (!isCellUnavailable(date)) selectDate(date);
 	};
 	const selectDate = (date) => {
 		if (isReadOnly() || isDisabled()) return;
-		if (!isCellDisabled(date) && !isCellUnavailable(date)) {
-			setValue(date);
-			setFocusedDate(date);
-		}
+		if (isCellDisabled(date) || isCellUnavailable(date)) return;
+		if (selectionMode() === "multiple") {
+			const current = value();
+			const base = Array.isArray(current) ? current.map((v) => toDisplayCalendarDate(v)) : current != null ? [toDisplayCalendarDate(current)] : [];
+			const target = toDisplayCalendarDate(date);
+			const index = base.findIndex((d) => isSameDay$1(d, target));
+			setValue(index >= 0 ? [...base.slice(0, index), ...base.slice(index + 1)] : [...base, target]);
+		} else setValue(date);
+		setFocusedDate(date);
 	};
 	const getDatesInWeek = (weekIndex, monthStartDate) => {
 		const startDate = monthStartDate ?? visibleRange().start;
@@ -1373,6 +1867,7 @@ function createCalendarState(props = {}) {
 		return getWeeksInMonth$1(date ?? focusedDate(), locale(), firstDayOfWeekName());
 	};
 	return {
+		selectionMode,
 		value,
 		setValue,
 		focusedDate,
@@ -1382,6 +1877,8 @@ function createCalendarState(props = {}) {
 		visibleRange,
 		timeZone,
 		locale,
+		minValue: minValueState,
+		maxValue: maxValueState,
 		firstDayOfWeek: firstDayOfWeekName,
 		validationState,
 		isValueInvalid,
@@ -1447,17 +1944,39 @@ const dayOfWeekNames = [
 function createRangeCalendarState(props = {}) {
 	const timeZone = getLocalTimeZone$1();
 	const locale = createMemo(() => access(props.locale) ?? "en-US");
+	const minValueState = createMemo(() => access(props.minValue) ?? null);
+	const maxValueState = createMemo(() => access(props.maxValue) ?? null);
 	const resolvedOptions = createMemo(() => new DateFormatter$1(locale()).resolvedOptions());
 	const calendar = createMemo(() => (props.createCalendar ?? createCalendar$1)(resolvedOptions().calendar));
 	const visibleMonths = Math.max(1, Number(access(props.visibleMonths) ?? 1));
 	const firstDayOfWeekName = () => props.firstDayOfWeek == null ? void 0 : dayOfWeekNames[props.firstDayOfWeek];
 	const toDisplayCalendarDate = (date) => toCalendar$1(toCalendarDate$2(date), calendar());
+	const [anchorDate, setAnchorDate] = createSignal(null);
+	const getAvailableRange = (anchor) => {
+		if (anchor && props.isDateUnavailable && !props.allowsNonContiguousRanges) {
+			const predicate = (date) => props.isDateUnavailable(date, anchor);
+			return {
+				start: nextUnavailableDate(anchor, predicate, visibleMonths, -1),
+				end: nextUnavailableDate(anchor, predicate, visibleMonths, 1)
+			};
+		}
+		return null;
+	};
+	const availableRange = createMemo(() => getAvailableRange(anchorDate()));
+	const effectiveMinValue = createMemo(() => {
+		const min = access(props.minValue);
+		return maxDate$1(min != null ? toDisplayCalendarDate(min) : void 0, availableRange()?.start) ?? null;
+	});
+	const effectiveMaxValue = createMemo(() => {
+		const max = access(props.maxValue);
+		return minDate$1(max != null ? toDisplayCalendarDate(max) : void 0, availableRange()?.end) ?? null;
+	});
 	const constrainDate = (date) => {
-		const minValue = access(props.minValue);
-		const maxValue = access(props.maxValue);
+		const min = effectiveMinValue();
+		const max = effectiveMaxValue();
 		let constrained = date;
-		if (minValue && constrained.compare(toDisplayCalendarDate(minValue)) < 0) constrained = toDisplayCalendarDate(minValue);
-		if (maxValue && constrained.compare(toDisplayCalendarDate(maxValue)) > 0) constrained = toDisplayCalendarDate(maxValue);
+		if (min && constrained.compare(min) < 0) constrained = min;
+		if (max && constrained.compare(max) > 0) constrained = max;
 		return constrained;
 	};
 	const visibleRangeEndFromStart = (start) => {
@@ -1514,7 +2033,6 @@ function createRangeCalendarState(props = {}) {
 	const initialFocusedDate = constrainDate(getInitialFocusedDate());
 	const [focusedDate, setFocusedDateInternal] = createSignal(initialFocusedDate);
 	const [visibleRangeStart, setVisibleRangeStart] = createSignal(alignVisibleRangeStart(initialFocusedDate));
-	const [anchorDate, setAnchorDate] = createSignal(null);
 	const [isFocused, setFocused] = createSignal(false);
 	const [isDragging, setDragging] = createSignal(false);
 	const sourceValue = createMemo(() => {
@@ -1532,7 +2050,17 @@ function createRangeCalendarState(props = {}) {
 	const isDisabled = createMemo(() => access(props.isDisabled) ?? false);
 	const isReadOnly = createMemo(() => access(props.isReadOnly) ?? false);
 	const validationState = createMemo(() => access(props.validationState));
-	const isValueInvalid = createMemo(() => validationState() === "invalid");
+	const isInvalidSelection = createMemo(() => {
+		const v = sourceValue();
+		if (!v || anchorDate()) return false;
+		if (props.isDateUnavailable?.(v.start, null) || props.isDateUnavailable?.(v.end, null)) return true;
+		const min = access(props.minValue);
+		const max = access(props.maxValue);
+		const minCal = min != null ? toDisplayCalendarDate(min) : null;
+		const maxCal = max != null ? toDisplayCalendarDate(max) : null;
+		return isDateOutsideRange(toDisplayCalendarDate(v.start), minCal, maxCal) || isDateOutsideRange(toDisplayCalendarDate(v.end), minCal, maxCal);
+	});
+	const isValueInvalid = createMemo(() => validationState() === "invalid" || isInvalidSelection());
 	const highlightedRange = createMemo(() => {
 		const anchor = anchorDate();
 		if (!anchor) {
@@ -1643,24 +2171,24 @@ function createRangeCalendarState(props = {}) {
 		return isSameDay$1(toDisplayCalendarDate(date), focusedDate());
 	};
 	const isCellUnavailable = (date) => {
-		return props.isDateUnavailable?.(date) ?? false;
+		return props.isDateUnavailable?.(date, anchorDate()) ?? false;
 	};
 	const isCellDisabled = (date) => {
 		if (isDisabled()) return true;
 		if (props.isDateDisabled?.(date)) return true;
-		const minValue = access(props.minValue);
-		const maxValue = access(props.maxValue);
+		const min = effectiveMinValue();
+		const max = effectiveMaxValue();
 		const calDate = toDisplayCalendarDate(date);
-		if (minValue && calDate.compare(toDisplayCalendarDate(minValue)) < 0) return true;
-		if (maxValue && calDate.compare(toDisplayCalendarDate(maxValue)) > 0) return true;
+		if (min && calDate.compare(min) < 0) return true;
+		if (max && calDate.compare(max) > 0) return true;
 		return false;
 	};
 	const isDateOutsideAllowedRange = (date) => {
-		const minValue = access(props.minValue);
-		const maxValue = access(props.maxValue);
+		const min = effectiveMinValue();
+		const max = effectiveMaxValue();
 		const calDate = toDisplayCalendarDate(date);
-		if (minValue && calDate.compare(toDisplayCalendarDate(minValue)) < 0) return true;
-		if (maxValue && calDate.compare(toDisplayCalendarDate(maxValue)) > 0) return true;
+		if (min && calDate.compare(min) < 0) return true;
+		if (max && calDate.compare(max) > 0) return true;
 		return false;
 	};
 	const isOutsideVisibleRange = (date) => {
@@ -1769,6 +2297,8 @@ function createRangeCalendarState(props = {}) {
 		visibleRange,
 		timeZone,
 		locale,
+		minValue: minValueState,
+		maxValue: maxValueState,
 		firstDayOfWeek: firstDayOfWeekName,
 		validationState,
 		isValueInvalid,
@@ -1816,6 +2346,331 @@ function convertValue(newValue, oldValue) {
 	if (oldValue && "hour" in oldValue) return oldValue.set(localValue);
 	return localValue;
 }
+/** Whether a date falls outside the closed [minValue, maxValue] interval. */
+function isDateOutsideRange(date, minValue, maxValue) {
+	return minValue != null && date.compare(minValue) < 0 || maxValue != null && date.compare(maxValue) > 0;
+}
+/**
+* Walks outward from the anchor one day at a time in `dir` until it reaches an
+* unavailable date, then returns the last available date before it — or
+* undefined when no unavailable date is found within `visibleMonths` of the
+* anchor (no narrowing needed on that side). Mirrors @react-stately/calendar
+* nextUnavailableDate.
+*/
+function nextUnavailableDate(anchorDate, isDateUnavailable, visibleMonths, dir) {
+	let nextDate = anchorDate.add({ days: dir });
+	const minBound = anchorDate.subtract({ months: visibleMonths });
+	const maxBound = anchorDate.add({ months: visibleMonths });
+	while ((dir < 0 ? nextDate.compare(minBound) >= 0 : nextDate.compare(maxBound) <= 0) && !isDateUnavailable(nextDate)) nextDate = nextDate.add({ days: dir });
+	if (isDateUnavailable(nextDate)) return nextDate.add({ days: -dir });
+}
+//#endregion
+//#region src/calendar/IncompleteDate.ts
+/**
+* IncompleteDate for Solid-Stately
+*
+* Represents a date that is incomplete or otherwise invalid as a result of user
+* editing (for example February 31st, if the day is edited before the month).
+* This lets a date field hold an invalid intermediate value while typing and
+* only constrain it on blur, matching upstream behavior.
+*
+* Based on @react-stately/datepicker IncompleteDate
+*/
+/**
+* This class represents a date that is incomplete or otherwise invalid as a result of user editing.
+* For example, it can represent temporary dates such as February 31st if the user edits the day
+* before the month. Times are represented according to an hour cycle rather than always in 24 hour
+* time. This enables the user to adjust the day period (e.g. am/pm) independently from the hour.
+*/
+var IncompleteDate = class IncompleteDate {
+	calendar;
+	era;
+	year;
+	month;
+	day;
+	hour;
+	hourCycle;
+	dayPeriod;
+	minute;
+	second;
+	millisecond;
+	offset;
+	constructor(calendar, hourCycle, dateValue) {
+		this.era = dateValue?.era ?? null;
+		this.calendar = calendar;
+		this.year = dateValue?.year ?? null;
+		this.month = dateValue?.month ?? null;
+		this.day = dateValue?.day ?? null;
+		this.hour = dateValue?.hour ?? null;
+		this.hourCycle = hourCycle;
+		this.dayPeriod = null;
+		this.minute = dateValue?.minute ?? null;
+		this.second = dateValue?.second ?? null;
+		this.millisecond = dateValue?.millisecond ?? null;
+		this.offset = "offset" in (dateValue ?? {}) ? dateValue.offset : null;
+		if (this.hour != null) {
+			const [dayPeriod, hour] = toHourCycle(this.hour, hourCycle);
+			this.dayPeriod = dayPeriod;
+			this.hour = hour;
+		}
+	}
+	copy() {
+		const res = new IncompleteDate(this.calendar, this.hourCycle);
+		res.era = this.era;
+		res.year = this.year;
+		res.month = this.month;
+		res.day = this.day;
+		res.hour = this.hour;
+		res.dayPeriod = this.dayPeriod;
+		res.minute = this.minute;
+		res.second = this.second;
+		res.millisecond = this.millisecond;
+		res.offset = this.offset;
+		return res;
+	}
+	/** Checks whether all the specified segments have a value. */
+	isComplete(segments) {
+		return segments.every((segment) => this[segment] != null);
+	}
+	/** Checks whether the given date value matches this value for the specified segments. */
+	validate(dt, segments) {
+		return segments.every((segment) => {
+			if ((segment === "hour" || segment === "dayPeriod") && "hour" in dt) {
+				const [dayPeriod, hour] = toHourCycle(dt.hour, this.hourCycle);
+				return this.dayPeriod === dayPeriod && this.hour === hour;
+			}
+			return this[segment] === dt[segment];
+		});
+	}
+	/** Checks if the date is empty (i.e. all specified segments are null). */
+	isCleared(segments) {
+		return segments.every((segment) => this[segment] === null);
+	}
+	/** Sets the given field. */
+	set(field, value, placeholder) {
+		const result = this.copy();
+		result[field] = value;
+		if (field === "hour" && result.dayPeriod == null && "hour" in placeholder) result.dayPeriod = toHourCycle(placeholder.hour, this.hourCycle)[0];
+		if (field === "year" && result.era == null) result.era = placeholder.era;
+		if (field !== "second" && field !== "literal" && field !== "timeZoneName") result.offset = null;
+		return result;
+	}
+	/** Sets the given field to null. */
+	clear(field) {
+		const result = this.copy();
+		result[field] = null;
+		if (field === "year") result.era = null;
+		result.offset = null;
+		return result;
+	}
+	/**
+	* Increments or decrements the given field. If it is null, then it is set to the placeholder
+	* value.
+	*/
+	cycle(field, amount, placeholder, displaySegments) {
+		const res = this.copy();
+		if (res[field] == null && field !== "dayPeriod" && field !== "era") {
+			if (field === "hour" && "hour" in placeholder) {
+				const [dayPeriod, hour] = toHourCycle(placeholder.hour, this.hourCycle);
+				res.dayPeriod = dayPeriod;
+				res.hour = hour;
+			} else res[field] = placeholder[field];
+			if (field === "year" && res.era == null) res.era = placeholder.era;
+			return res;
+		}
+		switch (field) {
+			case "era": {
+				const eras = this.calendar.getEras();
+				let index = eras.indexOf(res.era);
+				index = cycleValue(index, amount, 0, eras.length - 1);
+				res.era = eras[index];
+				break;
+			}
+			case "year": {
+				let date = new CalendarDate(this.calendar, this.era ?? placeholder.era, this.year ?? placeholder.year, this.month ?? 1, this.day ?? 1);
+				date = date.cycle(field, amount, { round: field === "year" });
+				res.era = date.era;
+				res.year = date.year;
+				break;
+			}
+			case "month":
+				res.month = cycleValue(res.month ?? 1, amount, 1, this.calendar.getMaximumMonthsInYear());
+				break;
+			case "day":
+				res.day = cycleValue(res.day ?? 1, amount, 1, this.calendar.getMaximumDaysInMonth());
+				break;
+			case "hour": {
+				const hasDateSegements = displaySegments.some((s) => [
+					"year",
+					"month",
+					"day"
+				].includes(s));
+				if ("timeZone" in placeholder && (!hasDateSegements || res.year != null && res.month != null && res.day != null)) {
+					let date = this.toValue(placeholder);
+					date = date.cycle("hour", amount, {
+						hourCycle: this.hourCycle === "h12" ? 12 : 24,
+						round: false
+					});
+					const [dayPeriod, adjustedHour] = toHourCycle(date.hour, this.hourCycle);
+					res.hour = adjustedHour;
+					res.dayPeriod = dayPeriod;
+					res.offset = date.offset;
+				} else {
+					const hours = res.hour ?? 0;
+					const limits = this.getSegmentLimits("hour");
+					res.hour = cycleValue(hours, amount, limits.minValue, limits.maxValue);
+					if (res.dayPeriod == null && "hour" in placeholder) res.dayPeriod = toHourCycle(placeholder.hour, this.hourCycle)[0];
+				}
+				break;
+			}
+			case "dayPeriod":
+				res.dayPeriod = cycleValue(res.dayPeriod ?? 0, amount, 0, 1);
+				break;
+			case "minute":
+				res.minute = cycleValue(res.minute ?? 0, amount, 0, 59, true);
+				break;
+			case "second":
+				res.second = cycleValue(res.second ?? 0, amount, 0, 59, true);
+				break;
+		}
+		return res;
+	}
+	/**
+	* Converts the incomplete date to a full date value, using the provided value for any unset
+	* fields.
+	*/
+	toValue(value) {
+		if ("hour" in value) {
+			let hour = this.hour;
+			if (hour != null) hour = fromHourCycle(hour, this.dayPeriod ?? 0, this.hourCycle);
+			else if (this.hourCycle === "h12" || this.hourCycle === "h11") hour = this.dayPeriod === 1 ? 12 : 0;
+			let res = value.set({
+				era: this.era ?? value.era,
+				year: this.year ?? value.year,
+				month: this.month ?? value.month,
+				day: this.day ?? value.day,
+				hour: hour ?? value.hour,
+				minute: this.minute ?? value.minute,
+				second: this.second ?? value.second,
+				millisecond: this.millisecond ?? value.millisecond
+			});
+			if ("offset" in res && this.offset != null && res.offset !== this.offset) res = res.add({ milliseconds: res.offset - this.offset });
+			return res;
+		} else return value.set({
+			era: this.era ?? value.era,
+			year: this.year ?? value.year,
+			month: this.month ?? value.month,
+			day: this.day ?? value.day
+		});
+	}
+	getSegmentLimits(type) {
+		switch (type) {
+			case "era": {
+				const eras = this.calendar.getEras();
+				return {
+					value: this.era != null ? eras.indexOf(this.era) : eras.length - 1,
+					minValue: 0,
+					maxValue: eras.length - 1
+				};
+			}
+			case "year": return {
+				value: this.year,
+				minValue: 1,
+				maxValue: 9999
+			};
+			case "month": return {
+				value: this.month,
+				minValue: 1,
+				maxValue: this.calendar.getMaximumMonthsInYear()
+			};
+			case "day": return {
+				value: this.day,
+				minValue: 1,
+				maxValue: this.calendar.getMaximumDaysInMonth()
+			};
+			case "dayPeriod": return {
+				value: this.dayPeriod,
+				minValue: 0,
+				maxValue: 1
+			};
+			case "hour": {
+				let minValue = 0;
+				let maxValue = 23;
+				if (this.hourCycle === "h12") {
+					minValue = 1;
+					maxValue = 12;
+				} else if (this.hourCycle === "h11") {
+					minValue = 0;
+					maxValue = 11;
+				}
+				return {
+					value: this.hour,
+					minValue,
+					maxValue
+				};
+			}
+			case "minute": return {
+				value: this.minute,
+				minValue: 0,
+				maxValue: 59
+			};
+			case "second": return {
+				value: this.second,
+				minValue: 0,
+				maxValue: 59
+			};
+		}
+	}
+};
+function cycleValue(value, amount, min, max, round = false) {
+	if (round) {
+		value += Math.sign(amount);
+		if (value < min) value = max;
+		const div = Math.abs(amount);
+		if (amount > 0) value = Math.ceil(value / div) * div;
+		else value = Math.floor(value / div) * div;
+		if (value > max) value = min;
+	} else {
+		value += amount;
+		if (value < min) value = max - (min - value - 1);
+		else if (value > max) value = min + (value - max - 1);
+	}
+	return value;
+}
+function toHourCycle(hour, hourCycle) {
+	let dayPeriod = hour >= 12 ? 1 : 0;
+	switch (hourCycle) {
+		case "h11":
+			if (hour >= 12) hour -= 12;
+			break;
+		case "h12":
+			if (hour === 0) hour = 12;
+			else if (hour > 12) hour -= 12;
+			break;
+		case "h23":
+			dayPeriod = null;
+			break;
+		case "h24":
+			hour += 1;
+			dayPeriod = null;
+	}
+	return [dayPeriod, hour];
+}
+function fromHourCycle(hour, dayPeriod, hourCycle) {
+	switch (hourCycle) {
+		case "h11":
+			if (dayPeriod === 1) hour += 12;
+			break;
+		case "h12":
+			if (hour === 12) hour = 0;
+			if (dayPeriod === 1) hour += 12;
+			break;
+		case "h24":
+			hour -= 1;
+			break;
+	}
+	return hour;
+}
 //#endregion
 //#region src/calendar/createDateFieldState.ts
 /**
@@ -1823,6 +2678,12 @@ function convertValue(newValue, oldValue) {
 *
 * Provides state management for date field components with segment-based editing.
 * Based on @react-stately/datepicker useDateFieldState
+*
+* Editing is modeled with an {@link IncompleteDate} display value so that invalid
+* intermediate dates (e.g. February 31st, produced by editing the day before the
+* month) are held as-typed while the field is focused and only constrained on blur
+* via `confirmPlaceholder`, matching upstream behavior. Out-of-range values are
+* never snapped to `minValue`/`maxValue`; they are kept and reported as invalid.
 */
 /**
 * Provides state management for a date field component.
@@ -1831,38 +2692,28 @@ function createDateFieldState(props = {}) {
 	const timeZone = getLocalTimeZone$1();
 	const locale = props.locale ?? "en-US";
 	const granularity = props.granularity ?? "day";
+	const calendar = new GregorianCalendar$1();
+	const hourCycle = resolveHourCycle(locale, props.hourCycle);
+	const displaySegments = computeDisplaySegments(granularity, hourCycle);
+	const getPlaceholderValue = () => {
+		const base = props.placeholderValue ?? today$1(timeZone);
+		return granularity === "day" ? toCalendarDate$1(base) : toCalendarDateTime$1(base);
+	};
+	const toSource = (v) => v ?? null;
 	const initialValue = props.defaultValue ?? null;
 	const [internalValue, setInternalValue] = createSignal(initialValue);
-	const [placeholderDate, setPlaceholderDate] = createSignal({});
 	const value = createMemo(() => {
 		const controlled = access(props.value);
 		return controlled !== void 0 ? controlled : internalValue();
 	});
-	const dateValue = createMemo(() => {
+	const [displayValue, setDisplayValue] = createSignal(new IncompleteDate(calendar, hourCycle, toSource(value())));
+	let lastSyncedValue = value();
+	createEffect(() => {
 		const v = value();
-		if (v) return v;
-		const parts = placeholderDate();
-		const placeholder = props.placeholderValue ?? today$1(timeZone);
-		if (Object.keys(parts).length === 0) return null;
-		const year = parts.year ?? placeholder.year;
-		const month = parts.month ?? placeholder.month;
-		const day = parts.day ?? placeholder.day;
-		if (granularity === "day") return toCalendarDate$1(placeholder).set({
-			year,
-			month,
-			day
-		});
-		const hour = parts.hour ?? 0;
-		const minute = parts.minute ?? 0;
-		const second = parts.second ?? 0;
-		return toCalendarDateTime$1(placeholder).set({
-			year,
-			month,
-			day,
-			hour,
-			minute,
-			second
-		});
+		if (v !== lastSyncedValue) {
+			lastSyncedValue = v;
+			setDisplayValue(new IncompleteDate(calendar, hourCycle, toSource(v)));
+		}
 	});
 	const isDisabled = createMemo(() => access(props.isDisabled) ?? false);
 	const isReadOnly = createMemo(() => access(props.isReadOnly) ?? false);
@@ -1918,117 +2769,120 @@ function createDateFieldState(props = {}) {
 	});
 	const isInvalid = createMemo(() => validation.displayValidation().isInvalid);
 	const validationState = createMemo(() => explicitValidationState() ?? (isInvalid() ? "invalid" : void 0));
-	const segments = createMemo(() => {
+	const dateValue = createMemo(() => {
 		const v = value();
-		const placeholder = props.placeholderValue ?? today$1(timeZone);
-		const parts = placeholderDate();
-		const segs = [];
+		if (v) return v;
+		const dv = displayValue();
+		if (dv.isCleared(displaySegments)) return null;
+		return dv.toValue(getPlaceholderValue());
+	});
+	const segments = createMemo(() => {
+		const dv = displayValue();
+		const base = value() ?? getPlaceholderValue();
+		const jsDate = dv.toValue(base).toDate(timeZone);
 		const shouldForceLeadingZeros = props.shouldForceLeadingZeros === true;
-		const formatOptions = {
-			year: "numeric",
-			month: shouldForceLeadingZeros ? "2-digit" : "numeric",
-			day: shouldForceLeadingZeros ? "2-digit" : "numeric"
-		};
-		if (granularity !== "day") {
-			formatOptions.hour = "2-digit";
-			formatOptions.minute = "2-digit";
-			if (granularity === "second") formatOptions.second = "2-digit";
-			if (props.hourCycle) formatOptions.hourCycle = props.hourCycle === 12 ? "h12" : "h23";
-		}
-		const formatter = new DateFormatter$1(locale, formatOptions);
-		const dateToFormat = v ?? placeholder;
-		const formattedParts = formatter.formatToParts(dateToFormat.toDate(timeZone));
-		for (const part of formattedParts) {
+		const formatter = new DateFormatter$1(locale, buildFormatOptions(granularity, shouldForceLeadingZeros, props.hourCycle));
+		const resolvedOptions = formatter.resolvedOptions();
+		const parts = formatter.formatToParts(jsDate);
+		const numberFormatter = new Intl.NumberFormat(locale, { useGrouping: false });
+		const twoDigitFormatter = new Intl.NumberFormat(locale, {
+			useGrouping: false,
+			minimumIntegerDigits: 2
+		});
+		const result = [];
+		for (const part of parts) {
 			const type = mapPartType(part.type);
-			if (type === "literal") segs.push({
-				type: "literal",
-				text: part.value,
-				isEditable: false,
-				isPlaceholder: false,
-				placeholder: part.value
-			});
-			else if (type) {
-				const segValue = getSegmentValue(v, type);
-				const partValue = parts[type];
-				const hasValue = v !== null || partValue !== void 0;
-				segs.push({
-					type,
-					text: hasValue ? part.value : getPlaceholderText(type, locale, granularity, shouldForceLeadingZeros),
-					value: segValue ?? partValue,
-					minValue: getMinValue(type),
-					maxValue: getMaxValue(type, v ?? placeholder),
-					isEditable: !isDisabled() && !isReadOnly(),
-					isPlaceholder: !hasValue,
-					placeholder: getPlaceholderText(type, locale, granularity, shouldForceLeadingZeros)
+			if (type === "literal") {
+				result.push({
+					type: "literal",
+					text: part.value,
+					isEditable: false,
+					isPlaceholder: false,
+					placeholder: part.value
 				});
+				continue;
+			}
+			if (!type) continue;
+			const editable = isEditableSegment(type);
+			const rawValue = rawSegmentValue(dv, type);
+			const isPlaceholder = editable && rawValue == null;
+			const limits = dv.getSegmentLimits(type);
+			const placeholderText = getPlaceholderText(type, locale, granularity, shouldForceLeadingZeros);
+			let text = part.value;
+			if ((type === "year" || type === "month" || type === "day" || type === "hour") && typeof rawValue === "number") {
+				const numeric = rawValue ?? 0;
+				text = resolvedOptions[type] === "2-digit" ? twoDigitFormatter.format(numeric) : numberFormatter.format(numeric);
 			}
+			result.push({
+				type,
+				text: isPlaceholder ? placeholderText : text,
+				value: limits?.value,
+				minValue: limits?.minValue,
+				maxValue: limits?.maxValue,
+				isEditable: editable && !isDisabled() && !isReadOnly(),
+				isPlaceholder,
+				placeholder: placeholderText
+			});
 		}
-		return segs;
+		return result;
 	});
-	const setValue = (newValue) => {
-		if (isDisabled() || isReadOnly()) return;
-		if (access(props.value) === void 0) setInternalValue(() => newValue);
-		if (props.onChange) props.onChange(newValue);
-		setPlaceholderDate({});
+	const commitDate = (newValue) => {
+		if (access(props.value) === void 0) {
+			lastSyncedValue = newValue;
+			setInternalValue(() => newValue);
+		}
+		props.onChange?.(newValue);
 	};
-	const setSegment = (type, newValue) => {
+	const setValue = (newValue) => {
 		if (isDisabled() || isReadOnly()) return;
-		const v = value();
-		if (v) setValue(updateDatePart(v, type, newValue));
-		else setPlaceholderDate((prev) => ({
-			...prev,
-			[type]: newValue
-		}));
+		if (newValue == null || newValue instanceof IncompleteDate && newValue.isCleared(displaySegments)) {
+			commitDate(null);
+			setDisplayValue(new IncompleteDate(calendar, hourCycle, null));
+			return;
+		}
+		if (!(newValue instanceof IncompleteDate)) {
+			commitDate(newValue);
+			setDisplayValue(new IncompleteDate(calendar, hourCycle, toSource(newValue)));
+			return;
+		}
+		if (newValue.isComplete(displaySegments)) {
+			const resolved = newValue.toValue(value() ?? getPlaceholderValue());
+			if (newValue.validate(resolved, displaySegments)) {
+				const committed = value();
+				if (!committed || resolved.compare(committed) !== 0) {
+					setDisplayValue(new IncompleteDate(calendar, hourCycle, toSource(resolved)));
+					commitDate(resolved);
+					return;
+				}
+			}
+		}
+		setDisplayValue(newValue);
 	};
-	const incrementSegment = (type) => {
+	const adjustSegment = (type, amount) => {
 		if (isDisabled() || isReadOnly()) return;
-		const v = value();
-		const current = v ? getSegmentValue(v, type) : placeholderDate()[type];
-		const max = getMaxValue(type, v ?? props.placeholderValue ?? today$1(timeZone));
-		const min = getMinValue(type);
-		const newValue = current !== void 0 ? current + 1 : min;
-		setSegment(type, newValue > max ? min : newValue);
+		setValue(displayValue().cycle(type, amount, getPlaceholderValue(), displaySegments));
 	};
-	const decrementSegment = (type) => {
+	const setSegment = (type, newValue) => {
 		if (isDisabled() || isReadOnly()) return;
-		const v = value();
-		const current = v ? getSegmentValue(v, type) : placeholderDate()[type];
-		const max = getMaxValue(type, v ?? props.placeholderValue ?? today$1(timeZone));
-		const min = getMinValue(type);
-		const newValue = current !== void 0 ? current - 1 : max;
-		setSegment(type, newValue < min ? max : newValue);
+		setValue(displayValue().set(type, newValue, getPlaceholderValue()));
 	};
+	const incrementSegment = (type) => adjustSegment(type, 1);
+	const decrementSegment = (type) => adjustSegment(type, -1);
 	const clearSegment = (type) => {
 		if (isDisabled() || isReadOnly()) return;
-		if (type === "literal") return;
-		const v = value();
-		if (v) setValue(updateDatePart(v, type, getMinValue(type)));
-		else setPlaceholderDate((prev) => {
-			const next = { ...prev };
-			delete next[type];
-			return next;
-		});
+		let dv = displayValue();
+		if (type !== "timeZoneName" && type !== "literal") dv = dv.clear(type);
+		setValue(dv);
 	};
 	const confirmPlaceholder = () => {
 		if (isDisabled() || isReadOnly()) return;
-		const minValue = access(props.minValue);
-		const maxValue = access(props.maxValue);
-		const constrain = (candidate) => {
-			if (minValue && candidate.compare(minValue) < 0) return minValue;
-			if (maxValue && candidate.compare(maxValue) > 0) return maxValue;
-			return candidate;
-		};
-		const parts = placeholderDate();
-		if (Object.keys(parts).length > 0) {
-			const dv = dateValue();
-			if (dv) setValue(constrain(dv));
-			return;
-		}
-		const current = value();
-		if (current) {
-			const constrained = constrain(current);
-			if (constrained.compare(current) !== 0) setValue(constrained);
-		}
+		const dv = displayValue();
+		if (!dv.isComplete(displaySegments)) return;
+		const resolved = dv.toValue(value() ?? getPlaceholderValue());
+		const committed = value();
+		const needsCommit = !committed || resolved.compare(committed) !== 0;
+		if (needsCommit) commitDate(resolved);
+		if (needsCommit || !dv.validate(resolved, displaySegments)) setDisplayValue(new IncompleteDate(calendar, hourCycle, toSource(value() ?? resolved)));
 	};
 	const formatValue = (fieldOptions) => {
 		const v = value();
@@ -2072,6 +2926,68 @@ function createDateFieldState(props = {}) {
 		timeZone
 	};
 }
+const EDITABLE_SEGMENTS = {
+	year: true,
+	month: true,
+	day: true,
+	hour: true,
+	minute: true,
+	second: true,
+	dayPeriod: true,
+	era: true
+};
+function isEditableSegment(type) {
+	return EDITABLE_SEGMENTS[type] === true;
+}
+function rawSegmentValue(dv, type) {
+	switch (type) {
+		case "era": return dv.era;
+		case "year": return dv.year;
+		case "month": return dv.month;
+		case "day": return dv.day;
+		case "hour": return dv.hour;
+		case "minute": return dv.minute;
+		case "second": return dv.second;
+		case "dayPeriod": return dv.dayPeriod;
+		default: return null;
+	}
+}
+function resolveHourCycle(locale, hourCycle) {
+	return new DateFormatter$1(locale, {
+		hour: "numeric",
+		hour12: hourCycle != null ? hourCycle === 12 : void 0
+	}).resolvedOptions().hourCycle ?? "h23";
+}
+function computeDisplaySegments(granularity, hourCycle) {
+	const is12HourClock = hourCycle === "h11" || hourCycle === "h12";
+	const segments = [
+		"era",
+		"year",
+		"month",
+		"day",
+		"hour",
+		...is12HourClock ? ["dayPeriod"] : [],
+		"minute",
+		"second"
+	];
+	const minIndex = segments.indexOf("era");
+	const maxIndex = segments.indexOf(granularity === "hour" && is12HourClock ? "dayPeriod" : granularity);
+	return segments.slice(minIndex, maxIndex + 1);
+}
+function buildFormatOptions(granularity, shouldForceLeadingZeros, hourCycle) {
+	const formatOptions = {
+		year: "numeric",
+		month: shouldForceLeadingZeros ? "2-digit" : "numeric",
+		day: shouldForceLeadingZeros ? "2-digit" : "numeric"
+	};
+	if (granularity !== "day") {
+		formatOptions.hour = "2-digit";
+		formatOptions.minute = "2-digit";
+		if (granularity === "second") formatOptions.second = "2-digit";
+		if (hourCycle) formatOptions.hourCycle = hourCycle === 12 ? "h12" : "h23";
+	}
+	return formatOptions;
+}
 function mapPartType(type) {
 	switch (type) {
 		case "year": return "year";
@@ -2087,40 +3003,6 @@ function mapPartType(type) {
 		default: return null;
 	}
 }
-function getSegmentValue(date, type) {
-	if (!date) return void 0;
-	switch (type) {
-		case "year": return date.year;
-		case "month": return date.month;
-		case "day": return date.day;
-		case "hour": return "hour" in date ? date.hour : void 0;
-		case "minute": return "minute" in date ? date.minute : void 0;
-		case "second": return "second" in date ? date.second : void 0;
-		default: return;
-	}
-}
-function getMinValue(type) {
-	switch (type) {
-		case "year": return 1;
-		case "month": return 1;
-		case "day": return 1;
-		case "hour": return 0;
-		case "minute": return 0;
-		case "second": return 0;
-		default: return 0;
-	}
-}
-function getMaxValue(type, date) {
-	switch (type) {
-		case "year": return 9999;
-		case "month": return 12;
-		case "day": return endOfMonth$1(date).day;
-		case "hour": return 23;
-		case "minute": return 59;
-		case "second": return 59;
-		default: return 0;
-	}
-}
 function getPlaceholderText(type, locale, granularity, shouldForceLeadingZeros = false) {
 	if (type === "literal") return "";
 	if (type === "dayPeriod") return "AM";
@@ -2137,7 +3019,7 @@ function getPlaceholderText(type, locale, granularity, shouldForceLeadingZeros =
 	const formatter = new DateFormatter$1(locale, formatOptions);
 	const refDate = new Date(2222, 10, 22, 22, 22, 22);
 	const parts = formatter.formatToParts(refDate);
-	for (const part of parts) if (mapPartType(part.type) === type) return part.value.replace(/\d/g, (d) => {
+	for (const part of parts) if (mapPartType(part.type) === type) return part.value.replace(/\d/g, (_d) => {
 		if (type === "year") return "y";
 		if (type === "month") return "m";
 		if (type === "day") return "d";
@@ -2153,18 +3035,6 @@ function getPlaceholderText(type, locale, granularity, shouldForceLeadingZeros =
 		default: return "";
 	}
 }
-function updateDatePart(date, type, value) {
-	if (typeof date.set !== "function") return date;
-	switch (type) {
-		case "year": return date.set({ year: value });
-		case "month": return date.set({ month: value });
-		case "day": return date.set({ day: value });
-		case "hour": return date.set({ hour: value });
-		case "minute": return date.set({ minute: value });
-		case "second": return date.set({ second: value });
-		default: return date;
-	}
-}
 //#endregion
 //#region src/calendar/createTimeFieldState.ts
 /**
@@ -2720,6 +3590,7 @@ function createSelectState(props) {
 			overlayState.close();
 		}
 	});
+	const [isFocused, setFocused] = createSignal(false);
 	const selectedItem = createMemo(() => {
 		const key = selectedKey();
 		if (key == null) return null;
@@ -2737,10 +3608,11 @@ function createSelectState(props) {
 	});
 	return {
 		collection: listState.collection,
+		selectionManager: listState.selectionManager,
 		focusedKey: listState.focusedKey,
 		setFocusedKey: listState.setFocusedKey,
-		isFocused: listState.isFocused,
-		setFocused: listState.setFocused,
+		isFocused,
+		setFocused,
 		isOpen: overlayState.isOpen,
 		open: overlayState.open,
 		close: overlayState.close,
@@ -3057,6 +3929,7 @@ function createComboBoxState(props) {
 		inputValue,
 		defaultInputValue: getProps().defaultInputValue ?? "",
 		setInputValue,
+		selectionManager: listState.selectionManager,
 		focusedKey: listState.focusedKey,
 		setFocusedKey: listState.setFocusedKey,
 		isFocused,
@@ -3250,8 +4123,13 @@ function createTabListState(props) {
 	const setFocusedKey = (key, childStrategy) => {
 		setFocusedKeyInternal(key);
 		setChildFocusStrategy(childStrategy ?? null);
-		if (keyboardActivation() === "automatic" && key !== null && key !== selectedKey() && !isKeyDisabled(key)) setSelectedKey(key);
 	};
+	let lastSelectedKey = selectedKey();
+	createComputed(() => {
+		const sel = selectedKey();
+		if (sel !== null && focusedKey() === null || !isFocused() && sel !== lastSelectedKey) setFocusedKey(sel);
+		lastSelectedKey = sel;
+	});
 	createComputed(() => {
 		const p = getProps();
 		if (p.selectedKey !== void 0) return;
@@ -3843,9 +4721,23 @@ var ToastQueue = class {
 	maxVisibleToasts;
 	hasExitAnimation;
 	keyCounter = 0;
+	wrapUpdate;
 	constructor(options = {}) {
 		this.maxVisibleToasts = options.maxVisibleToasts ?? 5;
 		this.hasExitAnimation = options.hasExitAnimation ?? false;
+		this.wrapUpdate = options.wrapUpdate;
+	}
+	/**
+	* Installs (or clears) the function that wraps visible-toast updates, so the
+	* resulting re-render can be animated. Used to attach `document.startViewTransition`
+	* to a shared queue (e.g. the global queue) after construction.
+	*/
+	setWrapUpdate(wrapUpdate) {
+		this.wrapUpdate = wrapUpdate;
+	}
+	runWithWrapUpdate(fn, action) {
+		if (this.wrapUpdate) this.wrapUpdate(fn, action);
+		else fn();
 	}
 	/**
 	* Subscribe to queue changes.
@@ -3882,7 +4774,7 @@ var ToastQueue = class {
 			toast,
 			...this.queue.slice(low)
 		];
-		this.updateVisibility();
+		this.updateVisibility("add");
 		return key;
 	}
 	/**
@@ -3898,7 +4790,7 @@ var ToastQueue = class {
 				timer: null,
 				animation: "exiting"
 			} : t);
-			this.notify();
+			this.notify("remove");
 		} else this.remove(key);
 	}
 	/**
@@ -3911,7 +4803,7 @@ var ToastQueue = class {
 			toast.timer?.cancel();
 		}
 		this.queue = this.queue.filter((t) => t.key !== key);
-		this.updateVisibility();
+		this.updateVisibility("remove");
 	}
 	/**
 	* Clear all queued and visible toasts.
@@ -3919,7 +4811,7 @@ var ToastQueue = class {
 	clear() {
 		for (const toast of this.queue) toast.timer?.cancel();
 		this.queue = [];
-		this.notify();
+		this.notify("clear");
 	}
 	/**
 	* Pause all toast timers.
@@ -3933,7 +4825,7 @@ var ToastQueue = class {
 	resumeAll() {
 		for (const toast of this.queue) toast.timer?.resume();
 	}
-	updateVisibility() {
+	updateVisibility(action) {
 		const visibleCount = this.queue.filter((t) => t.animation !== "queued" && t.animation !== "exiting").length;
 		let promoted = 0;
 		this.queue = this.queue.map((toast) => {
@@ -3954,11 +4846,13 @@ var ToastQueue = class {
 			};
 			return nextToast;
 		});
-		this.notify();
+		this.notify(action);
 	}
-	notify() {
+	notify(action = "add") {
 		const toasts = [...this.queue];
-		for (const callback of this.subscriptions) callback(toasts);
+		this.runWithWrapUpdate(() => {
+			for (const callback of this.subscriptions) callback(toasts);
+		}, action);
 	}
 };
 /**
@@ -4108,9 +5002,19 @@ function createGridState(options) {
 		return internalSelectedKeys();
 	});
 	const selectionMode = createMemo(() => getOptions().selectionMode ?? "none");
-	const selectionBehavior = createMemo(() => getOptions().selectionBehavior ?? "toggle");
+	const selectionBehaviorProp = () => getOptions().selectionBehavior ?? "toggle";
+	const [selectionBehaviorState, setSelectionBehaviorState] = createSignal(selectionBehaviorProp());
+	const selectionBehavior = createMemo(() => selectionBehaviorState());
 	const disallowEmptySelection = createMemo(() => getOptions().disallowEmptySelection ?? false);
+	const disabledBehavior = createMemo(() => getOptions().disabledBehavior ?? "all");
 	const focusMode = createMemo(() => getOptions().focusMode ?? "row");
+	createEffect(on(selectionBehaviorProp, (behavior) => {
+		setSelectionBehaviorState(behavior);
+	}));
+	createEffect(() => {
+		const keys = selectedKeys();
+		if (selectionBehaviorProp() === "replace" && selectionBehaviorState() === "toggle" && keys !== "all" && keys.size === 0) setSelectionBehaviorState("replace");
+	});
 	const setFocusedKey = (key, strategy = "first") => {
 		const collection = getOptions().collection;
 		if (focusMode() === "cell" && key != null) {
@@ -4201,6 +5105,9 @@ function createGridState(options) {
 		updateSelection(new Set([key]));
 		setAnchorKey(key);
 	};
+	const setSelectedKeys = (keys) => {
+		updateSelection(normalizeSelection$1(keys));
+	};
 	const extendSelection = (toKey) => {
 		if (isDisabled(toKey)) return;
 		if (selectionMode() !== "multiple") {
@@ -4244,6 +5151,9 @@ function createGridState(options) {
 		get disabledKeys() {
 			return disabledKeys();
 		},
+		get disabledBehavior() {
+			return disabledBehavior();
+		},
 		get isKeyboardNavigationDisabled() {
 			return isKeyboardNavigationDisabled();
 		},
@@ -4262,6 +5172,9 @@ function createGridState(options) {
 		get selectionBehavior() {
 			return selectionBehavior();
 		},
+		get disallowEmptySelection() {
+			return disallowEmptySelection();
+		},
 		get selectedKeys() {
 			return selectedKeys();
 		},
@@ -4269,8 +5182,10 @@ function createGridState(options) {
 		isDisabled,
 		setFocusedKey,
 		setFocused: setIsFocused,
+		setSelectionBehavior: setSelectionBehaviorState,
 		toggleSelection,
 		replaceSelection,
+		setSelectedKeys,
 		extendSelection,
 		selectAll,
 		clearSelection,
@@ -4305,6 +5220,7 @@ function createTableState(options) {
 	const gridState = createGridState(() => ({
 		collection: getOptions().collection,
 		disabledKeys: getOptions().disabledKeys,
+		disabledBehavior: getOptions().disabledBehavior,
 		focusMode: getOptions().focusMode,
 		selectionMode: getOptions().selectionMode,
 		selectionBehavior: getOptions().selectionBehavior,
@@ -4338,6 +5254,9 @@ function createTableState(options) {
 		get disabledKeys() {
 			return gridState.disabledKeys;
 		},
+		get disabledBehavior() {
+			return gridState.disabledBehavior;
+		},
 		get isKeyboardNavigationDisabled() {
 			return gridState.isKeyboardNavigationDisabled;
 		},
@@ -4356,6 +5275,9 @@ function createTableState(options) {
 		get selectionBehavior() {
 			return gridState.selectionBehavior;
 		},
+		get disallowEmptySelection() {
+			return gridState.disallowEmptySelection;
+		},
 		get selectedKeys() {
 			return gridState.selectedKeys;
 		},
@@ -4365,6 +5287,8 @@ function createTableState(options) {
 		setFocused: gridState.setFocused,
 		toggleSelection: gridState.toggleSelection,
 		replaceSelection: gridState.replaceSelection,
+		setSelectionBehavior: gridState.setSelectionBehavior,
+		setSelectedKeys: gridState.setSelectedKeys,
 		extendSelection: gridState.extendSelection,
 		selectAll: gridState.selectAll,
 		clearSelection: gridState.clearSelection,
@@ -4376,163 +5300,17 @@ function createTableState(options) {
 		get sortDescriptor() {
 			return sortDescriptor();
 		},
-		sort
-	};
-}
-//#endregion
-//#region src/table/createTableColumnResizeState.ts
-/**
-* Table column resize state management.
-* Based on @react-stately/table/useTableColumnResizeState.
-*
-* Provides column width state management for a table with column resizing.
-* Tracks column widths, the currently resizing column, and handles
-* width distribution and clamping.
-*/
-const DEFAULT_MIN_WIDTH = 75;
-const DEFAULT_MAX_WIDTH = Infinity;
-function parseColumnDef(col, tableWidth) {
-	const minWidth = col.minWidth ?? DEFAULT_MIN_WIDTH;
-	const maxWidth = col.maxWidth ?? DEFAULT_MAX_WIDTH;
-	if (col.width == null) return {
-		key: col.key,
-		fr: 1,
-		fixedPx: 0,
-		minWidth,
-		maxWidth
-	};
-	if (typeof col.width === "number") return {
-		key: col.key,
-		fr: 0,
-		fixedPx: col.width,
-		minWidth,
-		maxWidth
-	};
-	const str = col.width.trim();
-	if (str.endsWith("fr")) {
-		const val = parseFloat(str);
-		return {
-			key: col.key,
-			fr: isNaN(val) ? 1 : val,
-			fixedPx: 0,
-			minWidth,
-			maxWidth
-		};
-	}
-	if (str.endsWith("%")) {
-		const pct = parseFloat(str);
-		const px = isNaN(pct) ? 0 : pct / 100 * tableWidth;
-		return {
-			key: col.key,
-			fr: 0,
-			fixedPx: px,
-			minWidth,
-			maxWidth
-		};
-	}
-	const px = parseFloat(str);
-	return {
-		key: col.key,
-		fr: 0,
-		fixedPx: isNaN(px) ? 0 : px,
-		minWidth,
-		maxWidth
-	};
-}
-/**
-* Distribute `tableWidth` among columns:
-*  1. Fixed-width columns get their declared width (clamped to min/max).
-*  2. Remaining space is distributed among fractional columns proportionally.
-*/
-function distributeWidths(columns, tableWidth) {
-	const parsed = columns.map((c) => parseColumnDef(c, tableWidth));
-	let usedSpace = 0;
-	let totalFr = 0;
-	for (const p of parsed) if (p.fr > 0) totalFr += p.fr;
-	else {
-		const w = Math.max(p.minWidth, Math.min(p.maxWidth, p.fixedPx));
-		usedSpace += w;
-	}
-	const remainingSpace = Math.max(0, tableWidth - usedSpace);
-	const perFr = totalFr > 0 ? remainingSpace / totalFr : 0;
-	const widths = /* @__PURE__ */ new Map();
-	for (const p of parsed) {
-		let w;
-		if (p.fr > 0) w = p.fr * perFr;
-		else w = p.fixedPx;
-		w = Math.max(p.minWidth, Math.min(p.maxWidth, w));
-		widths.set(p.key, Math.round(w));
-	}
-	return widths;
-}
-/**
-* Creates column resize state for a table component.
-*
-* Builds an initial column width map from column definitions + table width,
-* then tracks resize operations that clamp to min/max and redistribute
-* remaining space among flex columns.
-*/
-function createTableColumnResizeState(props) {
-	const getProps = () => props();
-	const initialWidths = createMemo(() => distributeWidths(getProps().columns, getProps().tableWidth));
-	const [overrides, setOverrides] = createSignal(/* @__PURE__ */ new Map());
-	const [resizingColumn, setResizingColumn] = createSignal(null);
-	const columnWidths = createMemo(() => {
-		const base = initialWidths();
-		const over = overrides();
-		if (over.size === 0) return base;
-		const merged = new Map(base);
-		for (const [key, width] of over) if (merged.has(key)) merged.set(key, width);
-		return merged;
-	});
-	const minWidthMap = createMemo(() => {
-		const map = /* @__PURE__ */ new Map();
-		for (const col of getProps().columns) map.set(col.key, col.minWidth ?? DEFAULT_MIN_WIDTH);
-		return map;
-	});
-	const maxWidthMap = createMemo(() => {
-		const map = /* @__PURE__ */ new Map();
-		for (const col of getProps().columns) map.set(col.key, col.maxWidth ?? DEFAULT_MAX_WIDTH);
-		return map;
-	});
-	const getColumnWidth = (key) => {
-		return columnWidths().get(key) ?? 0;
-	};
-	const getColumnMinWidth = (key) => {
-		return minWidthMap().get(key) ?? DEFAULT_MIN_WIDTH;
-	};
-	const getColumnMaxWidth = (key) => {
-		return maxWidthMap().get(key) ?? DEFAULT_MAX_WIDTH;
-	};
-	const startResize = (key) => {
-		setResizingColumn(key);
-	};
-	const endResize = () => {
-		setResizingColumn(null);
-	};
-	const updateResizedColumns = (key, width) => {
-		const minW = getColumnMinWidth(key);
-		const maxW = getColumnMaxWidth(key);
-		const clampedWidth = Math.round(Math.max(minW, Math.min(maxW, width)));
-		const newOverrides = new Map(overrides());
-		newOverrides.set(key, clampedWidth);
-		setOverrides(newOverrides);
-		const base = initialWidths();
-		const merged = new Map(base);
-		for (const [k, w] of newOverrides) if (merged.has(k)) merged.set(k, w);
-		return merged;
-	};
-	return {
-		resizingColumn,
-		columnWidths,
-		startResize,
-		endResize,
-		updateResizedColumns,
-		getColumnWidth,
-		getColumnMinWidth,
-		getColumnMaxWidth
+		sort,
+		get expandedKeys() {
+			return EMPTY_EXPANDED_KEYS;
+		},
+		get treeColumn() {
+			return getOptions().collection.treeColumn ?? null;
+		},
+		toggleKey: () => {}
 	};
 }
+const EMPTY_EXPANDED_KEYS = /* @__PURE__ */ new Set();
 //#endregion
 //#region src/table/TableCollection.ts
 /**
@@ -4547,8 +5325,13 @@ var TableCollection = class {
 	_keyMap = /* @__PURE__ */ new Map();
 	_rowHeaderColumnKeys;
 	_size = 0;
+	/** Visible rows in DFS order. Drives size, navigation, iteration and the `rows` list. */
+	_flattenedRows = [];
+	_treeColumn = null;
+	_userColumnCount = 0;
 	constructor(options) {
-		const { columns, rows, getKey, getTextValue, showSelectionCheckboxes = false, rowHeaderColumnKeys } = options;
+		const { columns, rows, getKey, getTextValue, showSelectionCheckboxes = false, rowHeaderColumnKeys, expandedKeys } = options;
+		const isTreeGrid = expandedKeys !== void 0;
 		this._columns = this.buildColumns(columns, showSelectionCheckboxes);
 		this._rowHeaderColumnKeys = rowHeaderColumnKeys ?? this.getDefaultRowHeaderColumnKeys();
 		this._headerRows = this.buildHeaderRows();
@@ -4565,20 +5348,33 @@ var TableCollection = class {
 			};
 			this._keyMap.set("header", this._head);
 		}
-		const bodyRows = this.buildRows(rows, getKey, getTextValue);
-		this._size = bodyRows.length;
+		let bodyChildren;
+		if (isTreeGrid) {
+			const built = this.buildTreeRows(rows, expandedKeys, getKey, getTextValue);
+			bodyChildren = built.topLevelRows;
+			this._flattenedRows = built.flattenedRows;
+			this._userColumnCount = this.countLeafColumns();
+			this._treeColumn = options.treeColumn !== void 0 ? options.treeColumn : this._rowHeaderColumnKeys.values().next().value ?? null;
+		} else {
+			const bodyRows = this.buildRows(rows, getKey, getTextValue);
+			bodyChildren = bodyRows;
+			this._flattenedRows = bodyRows;
+			this._userColumnCount = this.countLeafColumns();
+			this._treeColumn = null;
+		}
+		this._size = this._flattenedRows.length;
 		this._body = {
 			type: "item",
 			key: "body",
 			index: this._headerRows.length,
 			level: 0,
 			hasChildNodes: true,
-			childNodes: bodyRows,
+			childNodes: bodyChildren,
 			value: null,
 			textValue: ""
 		};
 		this._keyMap.set("body", this._body);
-		this._rows = [...this._headerRows, ...bodyRows];
+		this._rows = [...this._headerRows, ...this._flattenedRows];
 	}
 	buildColumns(columns, showSelectionCheckboxes) {
 		const result = [];
@@ -4644,6 +5440,17 @@ var TableCollection = class {
 		for (const col of this._columns) if (col.key !== "__selection__") return new Set([col.key]);
 		return /* @__PURE__ */ new Set();
 	}
+	/** Counts the leaf columns supplied by the user (excludes the selection column). */
+	countLeafColumns() {
+		let count = 0;
+		const visit = (col) => {
+			if (col.key === "__selection__") return;
+			if (col.childNodes.length > 0) col.childNodes.forEach(visit);
+			else count++;
+		};
+		this._columns.forEach(visit);
+		return count;
+	}
 	buildHeaderRows() {
 		if (this._columns.length === 0) return [];
 		const headerCells = this._columns.map((col, index) => ({
@@ -4673,6 +5480,29 @@ var TableCollection = class {
 		headerCells.forEach((cell) => this._keyMap.set(cell.key, cell));
 		return [headerRow];
 	}
+	/**
+	* Builds the cell nodes for one row. Does not register the cells in the key map;
+	* the caller registers cells once the owning row is known to be present.
+	*/
+	buildCells(rowKey, value, rowLevel, getTextValue) {
+		return this._columns.map((col, colIndex) => {
+			const cellKey = `${rowKey}-${col.key}`;
+			const columnDefinition = col.props?.columnDefinition ?? { key: col.key };
+			const cellTextValue = col.key === "__selection__" ? "Selection" : getTextValue ? getTextValue(value, columnDefinition) : String(value?.[String(col.key)] ?? "");
+			return {
+				type: this._rowHeaderColumnKeys.has(col.key) ? "rowheader" : "cell",
+				key: cellKey,
+				index: colIndex,
+				column: colIndex,
+				level: rowLevel + 1,
+				hasChildNodes: false,
+				childNodes: [],
+				value,
+				textValue: cellTextValue,
+				parentKey: rowKey
+			};
+		});
+	}
 	buildRows(rows, getKey, getTextValue) {
 		const result = [];
 		const rowIndexOffset = this._headerRows.length;
@@ -4682,25 +5512,8 @@ var TableCollection = class {
 			const key = isRowDef ? row.key : getKey?.(row) ?? i;
 			const value = isRowDef ? row.value : row;
 			const textValue = isRowDef ? row.textValue : typeof row?.textValue === "string" ? row.textValue : void 0;
-			const cells = this._columns.map((col, colIndex) => {
-				const cellKey = `${key}-${col.key}`;
-				const columnDefinition = col.props?.columnDefinition ?? { key: col.key };
-				const cellTextValue = col.key === "__selection__" ? "Selection" : getTextValue ? getTextValue(value, columnDefinition) : String(value?.[String(col.key)] ?? "");
-				const cell = {
-					type: this._rowHeaderColumnKeys.has(col.key) ? "rowheader" : "cell",
-					key: cellKey,
-					index: colIndex,
-					column: colIndex,
-					level: 1,
-					hasChildNodes: false,
-					childNodes: [],
-					value,
-					textValue: cellTextValue,
-					parentKey: key
-				};
-				this._keyMap.set(cellKey, cell);
-				return cell;
-			});
+			const cells = this.buildCells(key, value, 0, getTextValue);
+			cells.forEach((cell) => this._keyMap.set(cell.key, cell));
 			const rowNode = {
 				type: "item",
 				key,
@@ -4717,6 +5530,58 @@ var TableCollection = class {
 		}
 		return result;
 	}
+	/**
+	* Builds the tree-grid rows: every row keeps its full structure (cells then all child
+	* rows, expanded or not) while only the rows whose ancestors are all expanded are
+	* registered in the key map and pushed into the flattened body. Mirrors
+	* `generateTreeGridCollection` upstream.
+	*/
+	buildTreeRows(rows, expandedKeys, getKey, getTextValue) {
+		const isExpanded = (key) => expandedKeys === "all" || expandedKeys.has(key);
+		const buildRowNode = (row, level, parentKey, indexAmongSiblings) => {
+			const isRowDef = this.isRowDefinition(row);
+			const key = isRowDef ? row.key : getKey?.(row) ?? indexAmongSiblings;
+			const value = isRowDef ? row.value : row;
+			const textValue = isRowDef ? row.textValue : typeof row?.textValue === "string" ? row.textValue : void 0;
+			const cells = this.buildCells(key, value, level, getTextValue);
+			const childRowDefs = isRowDef ? row.childRows ?? [] : [];
+			const hasChildRows = childRowDefs.length > 0 || isRowDef && !!row.hasChildRows;
+			const childRowNodes = childRowDefs.map((child, childIdx) => buildRowNode(child, level + 1, key, childIdx));
+			const childNodes = [...cells, ...childRowNodes];
+			return {
+				type: "item",
+				key,
+				index: indexAmongSiblings,
+				level,
+				parentKey,
+				hasChildNodes: true,
+				childNodes,
+				value,
+				textValue: textValue ?? cells.map((c) => c.textValue).join(" "),
+				isExpandable: hasChildRows,
+				isExpanded: hasChildRows && isExpanded(key),
+				firstChildKey: childNodes[0]?.key ?? null,
+				lastChildKey: childNodes[childNodes.length - 1]?.key ?? null
+			};
+		};
+		const topLevelRows = rows.map((row, i) => buildRowNode(row, 0, "body", i));
+		const flattenedRows = [];
+		const rowIndexOffset = this._headerRows.length;
+		const visit = (node) => {
+			node.rowIndex = rowIndexOffset + flattenedRows.length;
+			flattenedRows.push(node);
+			this._keyMap.set(node.key, node);
+			for (const child of node.childNodes) if (child.type !== "item") this._keyMap.set(child.key, child);
+			if (isExpanded(node.key)) {
+				for (const child of node.childNodes) if (child.type === "item") visit(child);
+			}
+		};
+		for (const node of topLevelRows) visit(node);
+		return {
+			topLevelRows,
+			flattenedRows
+		};
+	}
 	isRowDefinition(row) {
 		return typeof row === "object" && row !== null && "key" in row && "value" in row;
 	}
@@ -4747,6 +5612,18 @@ var TableCollection = class {
 	get rowHeaderColumnKeys() {
 		return this._rowHeaderColumnKeys;
 	}
+	/** The key of the column that renders the tree-grid affordance, or `null` for a flat table. */
+	get treeColumn() {
+		return this._treeColumn;
+	}
+	/** The number of leaf columns provided by the user (excludes the selection column). */
+	get userColumnCount() {
+		return this._userColumnCount;
+	}
+	/** The key map of all present nodes (visible rows, their cells, columns and the body). */
+	get keyMap() {
+		return this._keyMap;
+	}
 	getKeys() {
 		return this._keyMap.keys();
 	}
@@ -4754,9 +5631,8 @@ var TableCollection = class {
 		return this._keyMap.get(key) ?? null;
 	}
 	at(index) {
-		const bodyRows = this._body.childNodes;
-		if (index < 0 || index >= bodyRows.length) return null;
-		return bodyRows[index];
+		if (index < 0 || index >= this._flattenedRows.length) return null;
+		return this._flattenedRows[index];
 	}
 	getChildren(key) {
 		return this._keyMap.get(key)?.childNodes ?? [];
@@ -4769,29 +5645,29 @@ var TableCollection = class {
 		return this._keyMap.get(cellKey) ?? null;
 	}
 	getFirstKey() {
-		const bodyRows = this._body.childNodes;
+		const bodyRows = this._flattenedRows;
 		return bodyRows.length > 0 ? bodyRows[0].key : null;
 	}
 	getLastKey() {
-		const bodyRows = this._body.childNodes;
+		const bodyRows = this._flattenedRows;
 		return bodyRows.length > 0 ? bodyRows[bodyRows.length - 1].key : null;
 	}
 	getKeyBefore(key) {
 		if (!this._keyMap.get(key)) return null;
-		const bodyRows = this._body.childNodes;
+		const bodyRows = this._flattenedRows;
 		const index = bodyRows.findIndex((r) => r.key === key);
 		if (index > 0) return bodyRows[index - 1].key;
 		return null;
 	}
 	getKeyAfter(key) {
 		if (!this._keyMap.get(key)) return null;
-		const bodyRows = this._body.childNodes;
+		const bodyRows = this._flattenedRows;
 		const index = bodyRows.findIndex((r) => r.key === key);
 		if (index >= 0 && index < bodyRows.length - 1) return bodyRows[index + 1].key;
 		return null;
 	}
 	*[Symbol.iterator]() {
-		for (const row of this._body.childNodes) yield row;
+		for (const row of this._flattenedRows) yield row;
 	}
 };
 /**
@@ -4801,6 +5677,257 @@ function createTableCollection(options) {
 	return new TableCollection(options);
 }
 //#endregion
+//#region src/table/createTreeGridState.ts
+/**
+* Tree grid state management for expandable Table rows.
+* Based on @react-stately/table/useTreeGridState (the `UNSTABLE_` tree-grid feature).
+*
+* Owns the expanded-keys signal (controlled or uncontrolled), rebuilds the table
+* collection from it, and layers the expansion API on top of {@link createTableState}.
+*/
+/**
+* Creates state management for a tree grid (a table with expandable rows). Handles the
+* expanded rows in addition to the selection, sort and focus handled by the table state.
+*/
+function createTreeGridState(options) {
+	const getOptions = () => options();
+	const [internalExpandedKeys, setInternalExpandedKeys] = createSignal(getInitialExpanded(getOptions().UNSTABLE_defaultExpandedKeys));
+	const expandedKeys = createMemo(() => {
+		const controlled = getOptions().UNSTABLE_expandedKeys;
+		if (controlled !== void 0) return convertExpanded(controlled);
+		return internalExpandedKeys();
+	});
+	const collection = createMemo(() => createTableCollection({
+		columns: getOptions().columns,
+		rows: getOptions().rows,
+		getKey: getOptions().getKey,
+		getTextValue: getOptions().getTextValue,
+		showSelectionCheckboxes: getOptions().showSelectionCheckboxes ?? false,
+		rowHeaderColumnKeys: getOptions().rowHeaderColumnKeys,
+		expandedKeys: expandedKeys()
+	}));
+	const tableState = createTableState(() => ({
+		collection: collection(),
+		disabledKeys: getOptions().disabledKeys,
+		focusMode: getOptions().focusMode,
+		selectionMode: getOptions().selectionMode,
+		selectionBehavior: getOptions().selectionBehavior,
+		disallowEmptySelection: getOptions().disallowEmptySelection,
+		selectedKeys: getOptions().selectedKeys,
+		defaultSelectedKeys: getOptions().defaultSelectedKeys,
+		onSelectionChange: getOptions().onSelectionChange,
+		sortDescriptor: getOptions().sortDescriptor,
+		onSortChange: getOptions().onSortChange,
+		showSelectionCheckboxes: getOptions().showSelectionCheckboxes
+	}));
+	const toggleKey = (key) => {
+		const updated = toggleExpandedKey(expandedKeys(), key, collection());
+		if (getOptions().UNSTABLE_expandedKeys === void 0) setInternalExpandedKeys(updated);
+		getOptions().UNSTABLE_onExpandedChange?.(updated);
+	};
+	const treeGridState = tableState;
+	Object.defineProperty(treeGridState, "expandedKeys", {
+		get: () => expandedKeys(),
+		configurable: true,
+		enumerable: true
+	});
+	Object.defineProperty(treeGridState, "treeColumn", {
+		get: () => collection().treeColumn ?? null,
+		configurable: true,
+		enumerable: true
+	});
+	Object.defineProperty(treeGridState, "keyMap", {
+		get: () => collection().keyMap,
+		configurable: true,
+		enumerable: true
+	});
+	Object.defineProperty(treeGridState, "userColumnCount", {
+		get: () => collection().userColumnCount,
+		configurable: true,
+		enumerable: true
+	});
+	treeGridState.toggleKey = toggleKey;
+	return treeGridState;
+}
+/**
+* Computes the next expanded-key set when a row is toggled. Mirrors the upstream
+* `toggleKey`: collapsing from `'all'` materialises every expandable row first.
+*/
+function toggleExpandedKey(current, key, collection) {
+	let updated;
+	if (current === "all") {
+		updated = new Set(collection.rows.filter((row) => row.type === "item" && row.isExpandable).map((row) => row.key));
+		updated.delete(key);
+	} else {
+		updated = new Set(current);
+		if (updated.has(key)) updated.delete(key);
+		else updated.add(key);
+	}
+	return updated;
+}
+function getInitialExpanded(defaultExpanded) {
+	if (defaultExpanded === void 0) return /* @__PURE__ */ new Set();
+	return convertExpanded(defaultExpanded);
+}
+function convertExpanded(expanded) {
+	if (!expanded) return /* @__PURE__ */ new Set();
+	return expanded === "all" ? "all" : new Set(expanded);
+}
+//#endregion
+//#region src/table/createTableColumnResizeState.ts
+/**
+* Table column resize state management.
+* Based on @react-stately/table/useTableColumnResizeState.
+*
+* Provides column width state management for a table with column resizing.
+* Tracks column widths, the currently resizing column, and handles
+* width distribution and clamping.
+*/
+const DEFAULT_MIN_WIDTH = 75;
+const DEFAULT_MAX_WIDTH = Infinity;
+function parseColumnDef(col, tableWidth) {
+	const minWidth = col.minWidth ?? DEFAULT_MIN_WIDTH;
+	const maxWidth = col.maxWidth ?? DEFAULT_MAX_WIDTH;
+	if (col.width == null) return {
+		key: col.key,
+		fr: 1,
+		fixedPx: 0,
+		minWidth,
+		maxWidth
+	};
+	if (typeof col.width === "number") return {
+		key: col.key,
+		fr: 0,
+		fixedPx: col.width,
+		minWidth,
+		maxWidth
+	};
+	const str = col.width.trim();
+	if (str.endsWith("fr")) {
+		const val = parseFloat(str);
+		return {
+			key: col.key,
+			fr: isNaN(val) ? 1 : val,
+			fixedPx: 0,
+			minWidth,
+			maxWidth
+		};
+	}
+	if (str.endsWith("%")) {
+		const pct = parseFloat(str);
+		const px = isNaN(pct) ? 0 : pct / 100 * tableWidth;
+		return {
+			key: col.key,
+			fr: 0,
+			fixedPx: px,
+			minWidth,
+			maxWidth
+		};
+	}
+	const px = parseFloat(str);
+	return {
+		key: col.key,
+		fr: 0,
+		fixedPx: isNaN(px) ? 0 : px,
+		minWidth,
+		maxWidth
+	};
+}
+/**
+* Distribute `tableWidth` among columns:
+*  1. Fixed-width columns get their declared width (clamped to min/max).
+*  2. Remaining space is distributed among fractional columns proportionally.
+*/
+function distributeWidths(columns, tableWidth) {
+	const parsed = columns.map((c) => parseColumnDef(c, tableWidth));
+	let usedSpace = 0;
+	let totalFr = 0;
+	for (const p of parsed) if (p.fr > 0) totalFr += p.fr;
+	else {
+		const w = Math.max(p.minWidth, Math.min(p.maxWidth, p.fixedPx));
+		usedSpace += w;
+	}
+	const remainingSpace = Math.max(0, tableWidth - usedSpace);
+	const perFr = totalFr > 0 ? remainingSpace / totalFr : 0;
+	const widths = /* @__PURE__ */ new Map();
+	for (const p of parsed) {
+		let w;
+		if (p.fr > 0) w = p.fr * perFr;
+		else w = p.fixedPx;
+		w = Math.max(p.minWidth, Math.min(p.maxWidth, w));
+		widths.set(p.key, Math.round(w));
+	}
+	return widths;
+}
+/**
+* Creates column resize state for a table component.
+*
+* Builds an initial column width map from column definitions + table width,
+* then tracks resize operations that clamp to min/max and redistribute
+* remaining space among flex columns.
+*/
+function createTableColumnResizeState(props) {
+	const getProps = () => props();
+	const initialWidths = createMemo(() => distributeWidths(getProps().columns, getProps().tableWidth));
+	const [overrides, setOverrides] = createSignal(/* @__PURE__ */ new Map());
+	const [resizingColumn, setResizingColumn] = createSignal(null);
+	const columnWidths = createMemo(() => {
+		const base = initialWidths();
+		const over = overrides();
+		if (over.size === 0) return base;
+		const merged = new Map(base);
+		for (const [key, width] of over) if (merged.has(key)) merged.set(key, width);
+		return merged;
+	});
+	const minWidthMap = createMemo(() => {
+		const map = /* @__PURE__ */ new Map();
+		for (const col of getProps().columns) map.set(col.key, col.minWidth ?? DEFAULT_MIN_WIDTH);
+		return map;
+	});
+	const maxWidthMap = createMemo(() => {
+		const map = /* @__PURE__ */ new Map();
+		for (const col of getProps().columns) map.set(col.key, col.maxWidth ?? DEFAULT_MAX_WIDTH);
+		return map;
+	});
+	const getColumnWidth = (key) => {
+		return columnWidths().get(key) ?? 0;
+	};
+	const getColumnMinWidth = (key) => {
+		return minWidthMap().get(key) ?? DEFAULT_MIN_WIDTH;
+	};
+	const getColumnMaxWidth = (key) => {
+		return maxWidthMap().get(key) ?? DEFAULT_MAX_WIDTH;
+	};
+	const startResize = (key) => {
+		setResizingColumn(key);
+	};
+	const endResize = () => {
+		setResizingColumn(null);
+	};
+	const updateResizedColumns = (key, width) => {
+		const minW = getColumnMinWidth(key);
+		const maxW = getColumnMaxWidth(key);
+		const clampedWidth = Math.round(Math.max(minW, Math.min(maxW, width)));
+		const newOverrides = new Map(overrides());
+		newOverrides.set(key, clampedWidth);
+		setOverrides(newOverrides);
+		const base = initialWidths();
+		const merged = new Map(base);
+		for (const [k, w] of newOverrides) if (merged.has(k)) merged.set(k, w);
+		return merged;
+	};
+	return {
+		resizingColumn,
+		columnWidths,
+		startResize,
+		endResize,
+		updateResizedColumns,
+		getColumnWidth,
+		getColumnMinWidth,
+		getColumnMaxWidth
+	};
+}
+//#endregion
 //#region src/tree/createTreeState.ts
 /**
 * Tree state management for Tree components.
@@ -4839,9 +5966,16 @@ function createTreeState(options) {
 		return internalSelectedKeys();
 	});
 	const selectionMode = createMemo(() => getOptions().selectionMode ?? "none");
-	const selectionBehavior = createMemo(() => getOptions().selectionBehavior ?? "toggle");
+	const selectionBehaviorProp = () => getOptions().selectionBehavior ?? "toggle";
+	const [selectionBehaviorState, setSelectionBehaviorState] = createSignal(selectionBehaviorProp());
+	const selectionBehavior = createMemo(() => selectionBehaviorState());
 	const disallowEmptySelection = createMemo(() => getOptions().disallowEmptySelection ?? false);
 	const disabledBehavior = createMemo(() => getOptions().disabledBehavior ?? "all");
+	createEffect(on(selectionBehaviorProp, (behavior) => setSelectionBehaviorState(behavior)));
+	createEffect(() => {
+		const keys = selectedKeys();
+		if (selectionBehaviorProp() === "replace" && selectionBehaviorState() === "toggle" && keys !== "all" && keys.size === 0) setSelectionBehaviorState("replace");
+	});
 	const setFocusedKey = (key, strategy = "first") => {
 		setFocusedKeyInternal(key);
 		setChildFocusStrategy(strategy);
@@ -4905,7 +6039,7 @@ function createTreeState(options) {
 		}
 	};
 	const toggleSelection = (key) => {
-		if (isDisabled(key) && disabledBehavior() === "all") return;
+		if (isDisabled(key)) return;
 		if (selectionMode() === "none") return;
 		const current = selectedKeys();
 		if (selectionMode() === "single") {
@@ -4922,13 +6056,16 @@ function createTreeState(options) {
 		setAnchorKey(key);
 	};
 	const replaceSelection = (key) => {
-		if (isDisabled(key) && disabledBehavior() === "all") return;
+		if (isDisabled(key)) return;
 		if (selectionMode() === "none") return;
 		updateSelection(new Set([key]));
 		setAnchorKey(key);
 	};
+	const setSelectedKeys = (keys) => {
+		updateSelection(normalizeSelection(keys));
+	};
 	const extendSelection = (toKey) => {
-		if (isDisabled(toKey) && disabledBehavior() === "all") return;
+		if (isDisabled(toKey)) return;
 		if (selectionMode() !== "multiple") {
 			replaceSelection(toKey);
 			return;
@@ -5012,6 +6149,9 @@ function createTreeState(options) {
 		get disabledKeys() {
 			return disabledKeys();
 		},
+		get disabledBehavior() {
+			return disabledBehavior();
+		},
 		get expandedKeys() {
 			return expandedKeys();
 		},
@@ -5033,6 +6173,9 @@ function createTreeState(options) {
 		get selectionBehavior() {
 			return selectionBehavior();
 		},
+		get disallowEmptySelection() {
+			return disallowEmptySelection();
+		},
 		get selectedKeys() {
 			return selectedKeys();
 		},
@@ -5043,6 +6186,8 @@ function createTreeState(options) {
 		setFocused: setIsFocused,
 		toggleSelection,
 		replaceSelection,
+		setSelectedKeys,
+		setSelectionBehavior: setSelectionBehaviorState,
 		extendSelection,
 		selectAll,
 		clearSelection,
@@ -6615,7 +7760,7 @@ function createColorFieldState(options) {
 	};
 	const decrementToMin = () => {
 		if (!channel()) {
-			incrementHex(-HEX_COLOR_MAX);
+			incrementHex(-16777215);
 			return;
 		}
 		updateChannel("min");
@@ -8129,6 +9274,6 @@ function createStepListState(props) {
 	};
 }
 //#endregion
-export { CalendarDateClass, CalendarDateTimeClass, DEFAULT_VALIDATION_RESULT, DIRECTORY_DRAG_TYPE, DateFormatter, FormValidationContext, GregorianCalendar, ListCollection, TableCollection, TimeClass, Timer, ToastQueue, TreeCollection, VALID_VALIDITY_STATE, ZonedDateTimeClass, access, canUseDOM, createAsyncList, createAutocompleteState, createCalendar, createCalendarState, createCheckboxGroupState, createColorAreaState, createColorFieldState, createColorSliderState, createColorWheelState, createComboBoxState, createDateFieldState, createDateFieldState as useDateFieldState, createDatePickerState, createDatePickerState as useDatePickerState, createDisclosureGroupState, createDisclosureState, createDragState, createDraggableCollectionState, createDropState, createDroppableCollectionState, createFormValidationState, createGridState, createHSBColor, createHSLColor, createId, createIsSSR, createListCollection, createListData, createListState, createMenuState, createOverlayTriggerState as createMenuTriggerState, createOverlayTriggerState, createOverlayTriggerState as useMenuTriggerState, createNumberFieldState, createRGBColor, createRadioGroupState, createRangeCalendarState, createRangeCalendarState as useDateRangePickerState, createSearchFieldState, createSelectState, createSelectionState, createSelectionState as useMultipleSelectionState, createSingleSelectListState, createSliderState, createStepListState, createTabListState, createTableCollection, createTableColumnResizeState, createTableState, createTextFieldState, createTimeFieldState, createTimeFieldState as useTimeFieldState, createToastQueue, createToastState, createToggleGroupState, createToggleState, createTooltipTriggerState, createTreeCollection, createTreeData, createTreeState, defaultContainsFilter, endOfMonth, endOfWeek, endOfYear, getColorChannels, getDayOfWeek, getLocalTimeZone, getWeeksInMonth, isAccessor, isSameDay, isSameMonth, isSameYear, isServer, isToday, isWeekend, maxDate, mergeValidation, minDate, normalizeColor, now, parseAbsolute, parseAbsoluteToLocal, parseColor, parseDate, parseDateTime, parseTime, parseZonedDateTime, privateValidationStateProp, radioGroupSyncVersion, resetTooltipState, startOfMonth, startOfWeek, startOfYear, toCalendar, toCalendarDate, toCalendarDateTime, toTime, toZoned, today };
+export { CalendarDateClass, CalendarDateTimeClass, DEFAULT_VALIDATION_RESULT, DIRECTORY_DRAG_TYPE, DateFormatter, FormValidationContext, GregorianCalendar, ListCollection, SelectionManager, TableCollection, TimeClass, Timer, ToastQueue, TreeCollection, VALID_VALIDITY_STATE, ZonedDateTimeClass, access, canUseDOM, createAsyncList, createAutocompleteState, createCalendar, createCalendarState, createCheckboxGroupState, createColorAreaState, createColorFieldState, createColorSliderState, createColorWheelState, createComboBoxState, createDateFieldState, createDateFieldState as useDateFieldState, createDatePickerState, createDatePickerState as useDatePickerState, createDisclosureGroupState, createDisclosureState, createDragState, createDraggableCollectionState, createDropState, createDroppableCollectionState, createFormValidationState, createGridState, createHSBColor, createHSLColor, createId, createIsSSR, createListCollection, createListData, createListState, createMenuState, createOverlayTriggerState as createMenuTriggerState, createOverlayTriggerState, createOverlayTriggerState as useMenuTriggerState, createNumberFieldState, createRGBColor, createRadioGroupState, createRangeCalendarState, createRangeCalendarState as useDateRangePickerState, createSearchFieldState, createSelectState, createSelectionState, createSelectionState as useMultipleSelectionState, createSingleSelectListState, createSliderState, createStepListState, createTabListState, createTableCollection, createTableColumnResizeState, createTableState, createTextFieldState, createTimeFieldState, createTimeFieldState as useTimeFieldState, createToastQueue, createToastState, createToggleGroupState, createToggleState, createTooltipTriggerState, createTreeCollection, createTreeData, createTreeGridState, createTreeState, defaultContainsFilter, endOfMonth, endOfWeek, endOfYear, getColorChannels, getDayOfWeek, getLocalTimeZone, getWeeksInMonth, isAccessor, isSameDay, isSameMonth, isSameYear, isServer, isToday, isWeekend, maxDate, mergeValidation, minDate, normalizeColor, now, parseAbsolute, parseAbsoluteToLocal, parseColor, parseDate, parseDateTime, parseTime, parseZonedDateTime, privateValidationStateProp, radioGroupSyncVersion, resetTooltipState, startOfMonth, startOfWeek, startOfYear, toCalendar, toCalendarDate, toCalendarDateTime, toTime, toZoned, today };
 
 //# sourceMappingURL=index.js.map