@botiverse/raft-ui 0.10.7 → 0.11.0

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { cn } from "./cn.mjs";
 import { A as buttonVariants, C as DialogNav, D as DialogTitle, E as DialogSurface, F as resolveThemeScopeProps, I as useThemeScopeProps, L as useTheme, M as defaultNativeButton, N as useParentOverlayKind, O as DialogTrigger, P as withOverlayLayer, R as ThemeStateContext, S as DialogHeader, T as DialogPortal, _ as DialogBody, a as DrawerContent, b as DialogDescription, c as DrawerHeader, d as DrawerTitle, f as DrawerTrigger, g as Dialog, h as panelHeader, i as DrawerClose, j as Spinner, k as Button, l as DrawerOverlay, m as panelHeadEdges, n as DrawerActions, o as DrawerDescription, p as panelHeadActions, r as DrawerBody, s as DrawerFooter, t as Drawer, u as DrawerPortal, v as DialogClose, w as DialogOverlay, x as DialogFooter, y as DialogContent, z as tv } from "./drawer-yZD16Ybl.mjs";
 import { Dialog as Dialog$1 } from "@base-ui/react/dialog";
 import { AlertTriangle, Bell, Check, CheckCircle2, ChevronDown, ChevronLeft, ChevronRight, Copy, FileText, Image, Info, Minus, Upload, X, Zap } from "lucide-react";
-import { Children, Fragment, cloneElement, createContext, isValidElement, use, useCallback, useContext, useEffect, useId, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { Children, Fragment, cloneElement, createContext, createElement, isValidElement, use, useCallback, useContext, useEffect, useId, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { Button as Button$1 } from "@base-ui/react/button";
 import { mergeProps } from "@base-ui/react/merge-props";
@@ -34,6 +34,7 @@ import { Toast } from "@base-ui/react/toast";
 import { Tabs as Tabs$1 } from "@base-ui/react/tabs";
 import { Separator as Separator$1 } from "@base-ui/react/separator";
 import { Group, Panel as Panel$1, Separator as Separator$2 } from "react-resizable-panels";
+import { flushSync } from "react-dom";
 //#region src/components/alert-dialog/alert-dialog.tsx
 const alertDialog = tv({
 	slots: {
@@ -14872,6 +14873,2144 @@ function TaskSectionEmpty({ className, render, ...props }) {
 	});
 }
 //#endregion
+//#region src/components/virtual-list/utils/constants.ts
+/**
+* Written on the root element of every measured item: maps the DOM to item keys (kept selections,
+* and what other code uses to find an item).
+*/
+const ITEM_KEY_ATTR = "data-virtual-list-item-key";
+/** The default of the `columns` and `items` props, and the empty kept-item lists. */
+const EMPTY_ARRAY = [];
+/**
+* The visible-items element lays the rows out in normal block flow, so their margins collapse as the
+* consumer's CSS says (between adjacent rows, and a row's children's through the row). It is a block
+* formatting context (`flow-root`), so the first row's top margin and the last row's bottom margin stay
+* inside it instead of collapsing through it (into the spacer, or with the footer), and it is the rows'
+* offsetParent (`position: relative`): the list measures where each row starts from layout
+* (`measureRowSpans`).
+*/
+const VIRTUAL_VISIBLE_ITEMS_STYLE = {
+	position: "relative",
+	display: "flow-root"
+};
+/**
+* With virtualization off, the visible-items element still carries the CSS variables, so sticky
+* children that use `calc(var(--virtual-list-transform-y))` keep working.
+*/
+const NON_VIRTUAL_VISIBLE_ITEMS_STYLE = {
+	"--virtual-list-transform-y": "0px",
+	"--virtual-list-ios-compensation-y": "0px",
+	transform: "translateY(0px)",
+	position: "relative",
+	display: "flow-root"
+};
+/** ... within this window (ms). */
+const RENDER_THRASHING_WINDOW_MS = 1e3;
+//#endregion
+//#region src/components/virtual-list/utils/fenwick-tree.ts
+/**
+* Sizes of `l` items, each `estimated` plus a delta stored in the tree: `sum(i)` (the offset of item
+* `i`) is `i * estimated` plus the prefix sum of the deltas, in O(log n); `getBound(offset)` maps an
+* offset to an item index by a binary search over `sum()` (O(log² n)).
+*/
+var FenwickTree = class {
+	l;
+	estimated;
+	ft;
+	constructor(length, estimated) {
+		this.l = length;
+		this.estimated = estimated;
+		const ft = Array(length + 1);
+		for (let i = 0; i < length + 1; ++i) ft[i] = 0;
+		this.ft = ft;
+	}
+	/** Adds `delta` to the size of item `index`. */
+	add(index, delta) {
+		if (delta === 0) return;
+		const { l, ft } = this;
+		index += 1;
+		while (index <= l) {
+			ft[index] += delta;
+			index += index & -index;
+		}
+	}
+	/** The size of item `index`. */
+	get(index) {
+		return this.sum(index + 1) - this.sum(index);
+	}
+	/** The total size of the first `count` items (all of them by default). */
+	sum(count = this.l) {
+		if (count <= 0) return 0;
+		const { ft, estimated, l } = this;
+		if (count > l) throw new Error("[FenwickTree.sum]: `i` is larger than length.");
+		let sum = count * estimated;
+		while (count > 0) {
+			sum += ft[count];
+			count -= count & -count;
+		}
+		return sum;
+	}
+	/** The largest count `c` with `sum(c) <= threshold`: the index of the item that contains `threshold`. */
+	getBound(threshold) {
+		let lo = 0;
+		let hi = this.l;
+		while (hi > lo) {
+			const mid = Math.floor((lo + hi) / 2);
+			const midSum = this.sum(mid);
+			if (midSum > threshold) {
+				hi = mid;
+				continue;
+			}
+			if (!(midSum < threshold)) return mid;
+			if (lo === mid) {
+				if (this.sum(lo + 1) <= threshold) return lo + 1;
+				return mid;
+			}
+			lo = mid;
+		}
+		return lo;
+	}
+};
+//#endregion
+//#region src/components/virtual-list/utils/items-anchor.ts
+/**
+* Finds the row at `top` (the view's top, in item coordinates: `scrollTop + compensation - paddingTop`)
+* in the previous items and returns it with where it is now. If that row is gone, the first row after
+* it that is still there is kept instead, at the distance from the view's top it had; `null` when no row
+* from the one at the top onwards is left (or there is nothing to anchor to). Rows `canAnchor` rejects are
+* passed over the same way (edge rows such as a list's leading boundary, which new rows go below).
+*/
+function findItemsAnchor({ prevItems, prevTree, prevPrependIndexes, nextItems, getKey, canAnchor, top }) {
+	if (prevItems.length === 0 || nextItems.length === 0) return null;
+	const nextIndexOfKey = /* @__PURE__ */ new Map();
+	nextItems.forEach((item, index) => {
+		nextIndexOfKey.set(getKey(item), index);
+	});
+	const topIndex = Math.min(Math.max(prevTree.getBound(top), 0), prevItems.length - 1);
+	for (let index = topIndex; index < prevItems.length; ++index) {
+		const item = prevItems[index];
+		if (canAnchor !== void 0 && !canAnchor(item)) continue;
+		const key = getKey(item);
+		const nextIndex = nextIndexOfKey.get(key);
+		if (nextIndex === void 0) continue;
+		const prependIndexes = [];
+		for (const prevIndex of prevPrependIndexes) {
+			const item = prevItems[prevIndex];
+			const moved = item === void 0 ? void 0 : nextIndexOfKey.get(getKey(item));
+			if (moved !== void 0) prependIndexes.push(moved);
+		}
+		return {
+			key,
+			delta: top - prevTree.sum(index),
+			index: nextIndex,
+			prependIndexes
+		};
+	}
+	return null;
+}
+/**
+* The range to render with the new items: from the anchor row, as many rows as `start..end` held (none if
+* it was empty), clamped to `itemCount` items. It starts at the anchor row, not at the new index of the old
+* start: the rows above the anchor are not mounted in this render. When the view's top is above the anchor
+* row (the row at the top was removed), the range update that follows mounts the rows above as rows
+* entering above the range, so their first measurement is compensated like when scrolling up.
+*/
+function getAnchoredRange(start, end, anchorIndex, itemCount) {
+	if (end < start) return [anchorIndex, anchorIndex - 1];
+	return [anchorIndex, Math.min(anchorIndex + (end - start), itemCount - 1)];
+}
+//#endregion
+//#region src/components/virtual-list/hooks/use-event-callback.ts
+/** A stable function that calls the `fn` of the latest render. */
+function useEventCallback(fn) {
+	const fnRef = useRef(fn);
+	fnRef.current = fn;
+	return useCallback((...args) => fnRef.current(...args), []);
+}
+//#endregion
+//#region src/components/virtual-list/hooks/use-latest-ref.ts
+/** A ref whose `current` is the value of the latest render. */
+function useLatestRef(value) {
+	const ref = useRef(value);
+	ref.current = value;
+	return ref;
+}
+//#endregion
+//#region src/components/virtual-list/hooks/use-layout-effect-with-previous.ts
+/**
+* `useLayoutEffect(() => fn(previousDeps), deps)`: the layout-effect form of useMemoWithPrevious;
+* `fn` may return a cleanup.
+*/
+function useLayoutEffectWithPrevious(fn, deps) {
+	const previousRef = useRef(void 0);
+	useLayoutEffect(() => {
+		const cleanup = fn(previousRef.current);
+		previousRef.current = deps;
+		return cleanup;
+	}, deps);
+}
+//#endregion
+//#region src/components/virtual-list/hooks/use-memo-with-previous.ts
+/**
+* `useMemo(() => fn(previousDeps), deps)`: runs `fn` while rendering whenever `deps` change, with the
+* deps of the last committed render (`undefined` before the first commit).
+*
+* The previous deps are recorded at commit, not inside the memo: React may call a memo's function
+* more than once for one render (StrictMode does on purpose) or throw a render away, and either
+* would otherwise pass this render's own deps as `previous`.
+*/
+function useMemoWithPrevious(fn, deps) {
+	const previousRef = useRef(void 0);
+	const previous = previousRef.current;
+	useMemo(() => {
+		fn(previous);
+	}, deps);
+	useLayoutEffect(() => {
+		previousRef.current = deps;
+	});
+}
+//#endregion
+//#region src/components/virtual-list/hooks/use-merged-ref.ts
+/**
+* Merges refs into one setter. Returns `[setRef, getRef]`: `setRef(el)` stores `el` and passes it to
+* every ref; `getRef()` reads the stored element. When a ref changes between renders (checked while
+* rendering), the old one is cleared and the new one gets the stored element at once. The setter
+* calls ref callbacks itself, so what they return is ignored.
+*/
+function useMergedRef(...refs) {
+	const entries = useMemo(() => [], []);
+	const elementRef = useRef(null);
+	const getRef = useCallback(() => elementRef.current, []);
+	const clearEntry = useCallback((entry) => {
+		if (entry != null) {
+			if (entry.type === "RefCallback") entry.ref(null);
+			else entry.ref.current = null;
+		}
+	}, []);
+	const applyStoredElement = useCallback((ref) => {
+		if (typeof ref == "function") ref(getRef());
+		else ref.current = getRef();
+	}, [getRef]);
+	const setRef = useCallback((el) => {
+		elementRef.current = el;
+		for (const entry of entries) if (entry == null) continue;
+		else if (entry.type === "RefObject") entry.ref.current = el;
+		else entry.ref(el);
+	}, [entries]);
+	for (let i = 0; i < refs.length; i++) {
+		const ref = refs[i];
+		const entry = entries[i];
+		if (ref == null) {
+			clearEntry(entry);
+			entries[i] = null;
+		} else {
+			if (entry && entry.ref === ref) continue;
+			if (typeof ref == "function") {
+				if (entry != null) clearEntry(entry);
+				entries[i] = {
+					type: "RefCallback",
+					ref
+				};
+			} else {
+				if (entry != null) clearEntry(entry);
+				entries[i] = {
+					type: "RefObject",
+					ref
+				};
+			}
+			applyStoredElement(ref);
+		}
+	}
+	for (let i = refs.length; i < entries.length; i++) {
+		clearEntry(entries[i]);
+		entries[i] = null;
+	}
+	return [setRef, getRef];
+}
+//#endregion
+//#region src/components/virtual-list/hooks/use-non-passive-wheel.ts
+/**
+* Adds a non-passive `wheel` listener (so it may call `preventDefault`) to the element `getTarget`
+* returns, in a layout effect, only while `enabled` (a non-passive listener can hold up scrolling, so
+* none is added when it would not be used).
+*/
+function useNonPassiveWheel(getTarget, listener, enabled) {
+	useLayoutEffect(() => {
+		if (!enabled) return;
+		const target = getTarget();
+		if (target != null) target.addEventListener("wheel", listener, { passive: false });
+		return () => {
+			if (target != null) target.removeEventListener("wheel", listener);
+		};
+	}, [
+		getTarget,
+		listener,
+		enabled
+	]);
+}
+//#endregion
+//#region src/components/virtual-list/ItemColumns.tsx
+const ColumnsContext = createContext(null);
+/**
+* Renders the item's columns in the current column range: `renderItemWithCols` once, else
+* `renderCol` for each column.
+*/
+function ItemColumns(props) {
+	const { index, item } = props;
+	const context = useContext(ColumnsContext);
+	if (!context) return null;
+	const { startIndex, endIndex, columns, renderCol, renderItemWithCols, getLeft } = context;
+	if (renderItemWithCols != null) return renderItemWithCols({
+		itemIndex: index,
+		startColIndex: startIndex,
+		endColIndex: endIndex,
+		allColumns: columns,
+		item,
+		getLeft
+	});
+	if (renderCol != null) {
+		const cols = [];
+		for (let i = startIndex; i <= endIndex; ++i) {
+			const column = columns[i];
+			cols.push(renderCol({
+				column,
+				left: getLeft(i),
+				item,
+				key: i
+			}));
+		}
+		return cols;
+	}
+	return null;
+}
+/**
+* An iPhone, iPad or iPod, or an iPad that reports itself as a Mac with touch points
+* (`navigator.platform` is deprecated, but it still tells iPadOS from macOS here).
+*/
+const isIOS = !!(typeof document !== "undefined" && typeof window !== "undefined") && (/iPad|iPhone|iPod/.test(navigator.platform) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) && !window.MSStream;
+let coarsePointerCache;
+let devicePixelRatioCache;
+/** Whether the primary pointer is coarse (a touch screen); read once. */
+function isCoarsePointer() {
+	if (coarsePointerCache === void 0) coarsePointerCache = "matchMedia" in window && window.matchMedia("(pointer:coarse)").matches;
+	return coarsePointerCache;
+}
+/**
+* What wheel deltas are divided by: `devicePixelRatio` in Chromium (`"chrome" in window`), else 1;
+* read once.
+*/
+function getWheelDeltaScale() {
+	if (typeof document === "undefined") return 1;
+	if (devicePixelRatioCache === void 0) devicePixelRatioCache = "chrome" in window ? window.devicePixelRatio : 1;
+	return devicePixelRatioCache;
+}
+/**
+* Makes a runner that runs a callback in the next animation frame. Each runner requests one frame at
+* a time: a callback given before it fires replaces the previous one. One per list, so lists never
+* replace each other's callbacks.
+*/
+function createLatestInNextFrame() {
+	let nextFrameCallback;
+	let nextFrameHandle;
+	return (callback) => {
+		nextFrameCallback = callback;
+		if (nextFrameHandle === void 0) nextFrameHandle = requestAnimationFrame(() => {
+			nextFrameHandle = void 0;
+			nextFrameCallback?.();
+		});
+	};
+}
+//#endregion
+//#region src/components/virtual-list/utils/align.ts
+/**
+* The `scrollTop` that puts an item (its top `itemTop` in the list's content, its height `itemSize`) at
+* `align` in a view `viewportHeight` high, inside the margins: its top `scrollMarginTop` below the view's
+* top (`"start"`), its bottom `scrollMarginBottom` above the view's bottom (`"end"`), or its middle in the
+* middle of the area between them (`"center"`). Clamped to `0 .. maxScrollTop`.
+*/
+function getAlignedScrollTop({ itemTop, itemSize, viewportHeight, align, scrollMarginTop, scrollMarginBottom, maxScrollTop }) {
+	let top;
+	if (align === "start") top = itemTop - scrollMarginTop;
+	else if (align === "end") top = itemTop + itemSize - viewportHeight + scrollMarginBottom;
+	else {
+		const area = viewportHeight - scrollMarginTop - scrollMarginBottom;
+		top = itemTop + itemSize / 2 - scrollMarginTop - area / 2;
+	}
+	return Math.max(0, Math.min(top, Math.max(0, maxScrollTop)));
+}
+//#endregion
+//#region src/components/virtual-list/utils/measure.ts
+/**
+* Where each in-flow row starts in the visible-items element `container`, and where the rows end: in one
+* pass of reads, no writes, so the browser lays out at most once.
+*
+* `starts[i]` is the top of the border box of `rows[i]` (in document order), relative to the container's
+* padding edge; `end` is the container's inner height. The container is a block formatting context
+* (`display: flow-root`, see `constants.ts`) and `position: relative`, so it is the rows' offsetParent, the
+* first row's top margin and the last row's bottom margin stay inside it, and between two rows sits their
+* collapsed margin, whatever the consumer's CSS (a child's margins collapsing through a row included).
+*
+* Read from the boxes' rects (sub-pixel, so a span does not change with the rounding of its position), but
+* checked against the layout's own `offsetTop` / `clientHeight` (whole pixels, and blind to transforms):
+* where they disagree by more than a pixel, a transform is at work (the row's own, say an entrance
+* animation, or a scale on an ancestor, say a dialog zooming in) and the layout's value is used, since
+* the rows are laid out, and measured again on resize, without it.
+*
+* A row that is not laid out (`display: none`, so no offsetParent) takes no space: it starts where the
+* next one does.
+*/
+function measureRowStarts(container, rows) {
+	const frame = readFrame(container);
+	const starts = rows.map((row) => readRowStart(frame, row));
+	let next = frame.end;
+	for (let i = starts.length - 1; i >= 0; --i) next = starts[i] ??= next;
+	return {
+		starts,
+		end: frame.end
+	};
+}
+/** Where `row` starts in `container` (see `measureRowStarts`); 0 when it is not laid out. */
+function measureRowStart(container, row) {
+	return readRowStart(readFrame(container), row) ?? 0;
+}
+function readFrame(container) {
+	const rect = container.getBoundingClientRect();
+	const layoutHeight = container.offsetHeight;
+	const scaled = Math.abs(rect.height - layoutHeight) > 1;
+	const borderY = layoutHeight - container.clientHeight;
+	return {
+		container,
+		scaled,
+		innerTop: rect.top + container.clientTop,
+		end: scaled ? container.clientHeight : toLayoutUnit(rect.height - borderY)
+	};
+}
+function readRowStart({ container, scaled, innerTop }, row) {
+	if (row.offsetParent !== container) return null;
+	const layoutTop = row.offsetTop;
+	if (scaled) return layoutTop;
+	const rectTop = toLayoutUnit(row.getBoundingClientRect().top - innerTop);
+	return Math.abs(rectTop - layoutTop) > 1 ? layoutTop : rectTop;
+}
+/**
+* The space each of `rows` takes: from where it starts to where the next one starts, the last one to the
+* end of the rows (see `measureRowStarts`). So the collapsed margin between two rows belongs to the upper
+* one, and the spans add up to the rows' laid-out height from the first row's border box on. `firstStart`
+* is where the first row starts (its top margin, plus the margins of its first children that collapse
+* through it): space before the rows that no span holds (the list keeps it apart, see VirtualList's
+* `leadingMarginRef` and `applyLayoutStyles`).
+*/
+function measureRowSpans(container, rows) {
+	const { starts, end } = measureRowStarts(container, rows);
+	return {
+		spans: starts.map((start, i) => (i + 1 < starts.length ? starts[i + 1] : end) - start),
+		firstStart: starts[0] ?? 0
+	};
+}
+/**
+* Rounded to 1/64px, the unit browsers lay out in: rect differences carry floating-point noise (with page
+* zoom), and a size that differs from the cached one by noise alone would count as a resize.
+*/
+function toLayoutUnit(value) {
+	return Math.round(value * 64) / 64;
+}
+//#endregion
+//#region src/components/virtual-list/utils/range.ts
+/**
+* The items to render: from the item at `scrollTop - paddingTop` through as many items as fit in
+* `listHeight` at their minimum size, plus one (no overscan). Empty (`0..-1`) before the list has been
+* measured or when there are no items.
+*/
+function getVerticalRange({ fenwickTree, scrollTop, listHeight, itemMinSize, itemCount, paddingTop }) {
+	if (listHeight === void 0 || itemCount === 0) return {
+		startIndex: 0,
+		endIndex: -1
+	};
+	const startIndex = Math.max(fenwickTree.getBound(scrollTop - paddingTop), 0);
+	return {
+		startIndex,
+		endIndex: Math.min(startIndex + Math.ceil(listHeight / itemMinSize + 1), itemCount - 1)
+	};
+}
+/** The columns to render: the ones in `scrollLeft .. scrollLeft + listWidth`, plus one on each side. */
+function getHorizontalRange({ xFenwickTree, scrollLeft, listWidth, columnCount }) {
+	if (xFenwickTree === null || columnCount === 0) return {
+		startIndex: 0,
+		endIndex: 0
+	};
+	else return {
+		startIndex: Math.max(xFenwickTree.getBound(scrollLeft) - 1, 0),
+		endIndex: Math.min(xFenwickTree.getBound(scrollLeft + listWidth) + 1, columnCount - 1)
+	};
+}
+/** Whether `a` and `b` have the same length and every key of `a` is in `b`. */
+function haveSameKeys(a, b) {
+	if (a.length !== b.length) return false;
+	for (const key of a) if (!b.includes(key)) return false;
+	return true;
+}
+/** Whether `el` or one of its ancestors is hidden with an inline `display: none`. */
+function isHiddenByDisplayNone(el) {
+	let current = el;
+	while (current !== null) {
+		if (current.style.display === "none") return true;
+		current = current.parentElement;
+	}
+	return false;
+}
+function px(value) {
+	if (value !== void 0) return `${value}px`;
+}
+//#endregion
+//#region src/components/virtual-list/resize-observer/resize-observer-delegate.ts
+/**
+* Observes elements with one ResizeObserver, created on the first `observe()`, and calls each
+* element's own callback. Entries whose target is detached (no `parentElement`) are ignored.
+* `runAfterEntries(fn)` (from an element's callback) runs `fn` once after every entry of the current
+* notification has been delivered: VirtualList measures all of a list's rows once per notification,
+* not once per row.
+*/
+var ResizeObserverDelegate = class {
+	observer = void 0;
+	callbacksMap = /* @__PURE__ */ new Map();
+	observedDomSet = /* @__PURE__ */ new WeakSet();
+	afterEntries = /* @__PURE__ */ new Set();
+	/** The shared observer, created on first use; `null` without a native ResizeObserver. */
+	ensureObserver() {
+		if (this.observer === void 0) this.observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(this.callback.bind(this));
+		return this.observer;
+	}
+	callback(entries) {
+		for (const entry of entries) {
+			if (!entry.target.parentElement) continue;
+			const callback = this.callbacksMap.get(entry.target);
+			if (callback) callback(entry);
+		}
+		const afterEntries = [...this.afterEntries];
+		this.afterEntries.clear();
+		for (const fn of afterEntries) fn();
+	}
+	runAfterEntries(fn) {
+		this.afterEntries.add(fn);
+	}
+	observe(el, callback) {
+		this.callbacksMap.set(el, callback);
+		if (!this.observedDomSet.has(el)) {
+			this.ensureObserver()?.observe(el);
+			this.observedDomSet.add(el);
+		}
+	}
+	unobserve(el) {
+		this.callbacksMap.delete(el);
+		if (this.observedDomSet.has(el)) {
+			this.ensureObserver()?.unobserve(el);
+			this.observedDomSet.delete(el);
+		}
+	}
+};
+let resizeObserverDelegate;
+/** The shared delegate, created on first use. */
+function getResizeObserverDelegate() {
+	resizeObserverDelegate ||= new ResizeObserverDelegate();
+	return resizeObserverDelegate;
+}
+//#endregion
+//#region src/components/virtual-list/resize-observer/ResizeObserverWrapper.tsx
+/**
+* Calls `children({ ref })` and observes the element `ref` receives. `onRefUpdate` runs synchronously
+* whenever the ref is set (VirtualList measures a new item there, before paint), and again in a
+* layout effect when `simulateRefUpdateTrigger` differs from its first value; `onResize` runs from the
+* ResizeObserver, with `isFirst` for its first call (again after re-enabling). `disabled` stops
+* observing; `onUnmounted` runs in a layout-effect cleanup.
+*/
+function ResizeObserverWrapper(props) {
+	const { disabled, onResize, children, onRefUpdate, forwardedRef, simulateRefUpdateTrigger, onUnmounted } = props;
+	const [setRef, getRef] = useMergedRef(forwardedRef);
+	const isFirstResizeRef = useRef(true);
+	const prevSimulateTriggerRef = useRef(simulateRefUpdateTrigger);
+	const emitRefUpdate = useEventCallback(() => {
+		onRefUpdate?.(getRef());
+	});
+	useLayoutEffect(() => {
+		if (prevSimulateTriggerRef.current !== simulateRefUpdateTrigger) emitRefUpdate();
+	}, [simulateRefUpdateTrigger, emitRefUpdate]);
+	const handleResize = useEventCallback((entry) => {
+		if (!disabled) onResize({
+			entry,
+			isFirst: isFirstResizeRef.current
+		});
+		isFirstResizeRef.current = false;
+	});
+	useLayoutEffect(() => {
+		const el = getRef();
+		if (el != null) {
+			if (disabled) {
+				getResizeObserverDelegate().unobserve(el);
+				isFirstResizeRef.current = true;
+			} else {
+				getResizeObserverDelegate().observe(el, handleResize);
+				return () => {
+					getResizeObserverDelegate().unobserve(el);
+				};
+			}
+		}
+	}, [
+		disabled,
+		getRef,
+		handleResize
+	]);
+	const emitUnmounted = useEventCallback(() => {
+		onUnmounted?.();
+	});
+	useLayoutEffect(() => () => {
+		emitUnmounted();
+	}, [emitUnmounted]);
+	return children({ ref: useEventCallback((el) => {
+		const previous = getRef();
+		setRef(el);
+		onRefUpdate?.(el);
+		if (disabled) {
+			if (previous != null) getResizeObserverDelegate().unobserve(previous);
+		} else if (el === null) {
+			if (previous !== null) getResizeObserverDelegate().unobserve(previous);
+		} else {
+			if (previous !== null && previous !== el) getResizeObserverDelegate().unobserve(previous);
+			getResizeObserverDelegate().observe(el, handleResize);
+		}
+	}) });
+}
+//#endregion
+//#region src/components/virtual-list/hooks/use-ios-momentum-compensation.ts
+/**
+* On iOS, writing `scrollTop` during momentum scrolling stops the fling. So while a touch scroll is
+* active, size changes above the view are accumulated and applied as `translateY(-compensation)` on
+* the items element; they are written to `scrollTop` (flushed) one second after the finger lifted, at
+* the top or bottom edge, or on the next touchstart.
+*/
+function useIosMomentumCompensation({ enabled, listElRef, itemsElRef, syncViewport, compensationYRef: iosCompYRef }) {
+	const touchSessionActiveRef = useRef(false);
+	const idleTimerRef = useRef(null);
+	const scrollSuppressTimerRef = useRef(null);
+	const forcedScrollTopRef = useRef(null);
+	const touchEndedRef = useRef(true);
+	const applyCompensationTransform = useEventCallback(() => {
+		const itemsEl = itemsElRef.current;
+		if (itemsEl) {
+			const compensation = iosCompYRef.current;
+			if (compensation === 0) itemsEl.style.transform = "";
+			else itemsEl.style.transform = `translateY(${-compensation}px)`;
+		}
+	});
+	const clearIdleTimer = useEventCallback(() => {
+		if (idleTimerRef.current !== null) {
+			clearTimeout(idleTimerRef.current);
+			idleTimerRef.current = null;
+		}
+	});
+	const startScrollSuppression = useEventCallback(() => {
+		if (scrollSuppressTimerRef.current !== null) clearTimeout(scrollSuppressTimerRef.current);
+		scrollSuppressTimerRef.current = setTimeout(() => {
+			scrollSuppressTimerRef.current = null;
+			forcedScrollTopRef.current = null;
+			syncViewport();
+		}, 200);
+	});
+	const flushCompensation = useEventCallback((reason) => {
+		clearIdleTimer();
+		const compensation = iosCompYRef.current;
+		iosCompYRef.current = 0;
+		touchSessionActiveRef.current = false;
+		applyCompensationTransform();
+		const listEl = listElRef.current;
+		if (listEl && compensation !== 0) {
+			const scrollTop = listEl.scrollTop + compensation;
+			listEl.scrollTop = scrollTop;
+			if (reason == "touchStart") {
+				forcedScrollTopRef.current = scrollTop;
+				startScrollSuppression();
+			}
+		}
+	});
+	const scheduleIdleFlush = useEventCallback(() => {
+		clearIdleTimer();
+		idleTimerRef.current = setTimeout(() => {
+			idleTimerRef.current = null;
+			if (touchEndedRef.current) flushCompensation("idleTimer");
+			else scheduleIdleFlush();
+		}, 1e3);
+	});
+	const handleTouchStart = useEventCallback(() => {
+		touchEndedRef.current = false;
+		if (touchSessionActiveRef.current) flushCompensation("touchStart");
+		touchSessionActiveRef.current = true;
+		scheduleIdleFlush();
+	});
+	const handleTouchEnd = useEventCallback(() => {
+		touchEndedRef.current = true;
+	});
+	const handleScrollDuringTouch = useEventCallback(() => {
+		if (touchSessionActiveRef.current) scheduleIdleFlush();
+	});
+	const clampCompensation = useEventCallback(() => {
+		const listEl = listElRef.current;
+		if (!listEl) return;
+		const maxScrollTop = listEl.scrollHeight - listEl.clientHeight;
+		iosCompYRef.current = Math.max(-listEl.scrollTop, Math.min(maxScrollTop - listEl.scrollTop, iosCompYRef.current));
+	});
+	const addCompensation = useEventCallback((deltaY) => {
+		if (!enabled || !touchSessionActiveRef.current) return false;
+		iosCompYRef.current += deltaY;
+		clampCompensation();
+		const listEl = listElRef.current;
+		if (listEl) {
+			if (listEl.scrollTop <= 0) {
+				if (touchEndedRef.current) flushCompensation("scrollToTop");
+				return true;
+			}
+			if (iosCompYRef.current > 0) {
+				const maxScrollTop = listEl.scrollHeight - listEl.clientHeight;
+				if (listEl.scrollTop + iosCompYRef.current >= maxScrollTop) {
+					flushCompensation("overBottom");
+					return true;
+				}
+			}
+		}
+		applyCompensationTransform();
+		return true;
+	});
+	useLayoutEffect(() => {
+		if (!enabled) return;
+		const listEl = listElRef.current;
+		if (!listEl) return;
+		const itemsEl = itemsElRef.current;
+		listEl.addEventListener("touchstart", handleTouchStart, { passive: true });
+		listEl.addEventListener("touchend", handleTouchEnd, { passive: true });
+		listEl.addEventListener("touchcancel", handleTouchEnd, { passive: true });
+		listEl.addEventListener("scroll", handleScrollDuringTouch, { passive: true });
+		return () => {
+			listEl.removeEventListener("touchstart", handleTouchStart);
+			listEl.removeEventListener("touchend", handleTouchEnd);
+			listEl.removeEventListener("touchcancel", handleTouchEnd);
+			listEl.removeEventListener("scroll", handleScrollDuringTouch);
+			clearIdleTimer();
+			if (scrollSuppressTimerRef.current !== null) {
+				clearTimeout(scrollSuppressTimerRef.current);
+				scrollSuppressTimerRef.current = null;
+				forcedScrollTopRef.current = null;
+			}
+			if (iosCompYRef.current !== 0) {
+				if (itemsEl) itemsEl.style.transform = "";
+				listEl.scrollTop += iosCompYRef.current;
+				iosCompYRef.current = 0;
+			}
+			touchSessionActiveRef.current = false;
+		};
+	}, [
+		enabled,
+		listElRef,
+		itemsElRef,
+		handleTouchStart,
+		handleTouchEnd,
+		handleScrollDuringTouch,
+		clearIdleTimer,
+		iosCompYRef
+	]);
+	return {
+		addCompensation,
+		isScrollSuppressedWithForceRestore: useEventCallback((scrollTop) => {
+			const suppressed = scrollSuppressTimerRef.current !== null;
+			if (suppressed && listElRef.current && forcedScrollTopRef.current !== null && scrollTop === 0) listElRef.current.scrollTop = forcedScrollTopRef.current;
+			return suppressed;
+		})
+	};
+}
+//#endregion
+//#region src/components/virtual-list/hooks/use-keyboard-scroll.ts
+/**
+* PageUp / PageDown / Space (Shift+Space up) scroll by the list's height minus `pageBottomOcclusion`
+* (what covers the bottom of the list, e.g. an input box) minus 32 px; Home / End and Cmd+Up / Cmd+Down
+* call `scrollTo({ position: "top" | "bottom" })`. Only keys pressed on the list itself (the scroll
+* container has focus) scroll it: a key pressed in a row (a button, a checkbox, a text field, a segmented
+* control) is left to that control, and so is a key a handler has already taken (`defaultPrevented`).
+*/
+function useKeyboardScroll(scrollTo, { pageBottomOcclusion = 0 } = {}) {
+	const occlusionRef = useRef(0);
+	occlusionRef.current = pageBottomOcclusion;
+	return { onKeyDown: useCallback((event) => {
+		if (event.defaultPrevented || event.target !== event.currentTarget) return;
+		if (event.key === "PageDown" || event.key === "PageUp" || event.key === " " || event.key === "Spacebar") {
+			const page = Math.max(event.currentTarget.clientHeight - occlusionRef.current - 32, 0);
+			if (page <= 0) return;
+			event.preventDefault();
+			event.currentTarget.scrollTop += event.key === "PageUp" || (event.key === " " || event.key === "Spacebar") && event.shiftKey ? -page : page;
+			return;
+		}
+		let position = null;
+		switch (event.key) {
+			case "Home":
+				position = "top";
+				break;
+			case "ArrowUp":
+				if (event.metaKey) position = "top";
+				break;
+			case "End":
+				position = "bottom";
+				break;
+			case "ArrowDown": if (event.metaKey) position = "bottom";
+		}
+		if (position) {
+			event.preventDefault();
+			scrollTo({ position });
+		}
+	}, [scrollTo]) };
+}
+//#endregion
+//#region src/components/virtual-list/hooks/use-non-virtual-content-resize.ts
+/**
+* While `nonVirtual`, observes the items element and calls `onContentResize` when it resizes (with
+* virtualization on, the list calls it from its own measurements).
+*/
+function useNonVirtualContentResize(itemsElRef, onContentResize, nonVirtual) {
+	const notifyContentResize = useEventCallback(() => {
+		onContentResize?.();
+	});
+	useLayoutEffect(() => {
+		const itemsEl = itemsElRef.current;
+		if (itemsEl && nonVirtual) {
+			getResizeObserverDelegate().observe(itemsEl, notifyContentResize);
+			return () => {
+				getResizeObserverDelegate().unobserve(itemsEl);
+			};
+		}
+	}, [
+		itemsElRef,
+		notifyContentResize,
+		nonVirtual
+	]);
+}
+//#endregion
+//#region src/components/virtual-list/hooks/use-scroll-anchor.ts
+/**
+* Finds the first child of `container` whose box crosses the top of `scroller` (a binary search over
+* `getBoundingClientRect()`) and saves it with its top in `anchorRef`, or null when there is none.
+*/
+function snapshotAnchorElementStateAndSaveToRef(anchorRef, scroller, container) {
+	const children = Array.from(container.children);
+	const scrollerTop = scroller.getBoundingClientRect().top;
+	let lo = 0;
+	let hi = children.length - 1;
+	let found = -1;
+	let foundTop = 0;
+	while (lo <= hi) {
+		const mid = Math.floor((lo + hi) / 2);
+		const rect = children[mid].getBoundingClientRect();
+		if (rect.top <= scrollerTop && rect.bottom > scrollerTop) {
+			found = mid;
+			hi = mid - 1;
+			foundTop = rect.top;
+		} else lo = mid + 1;
+	}
+	if (found < 0) anchorRef.current = null;
+	else {
+		const element = children[found];
+		if (element) anchorRef.current = {
+			element,
+			top: foundTop
+		};
+		else anchorRef.current = null;
+	}
+}
+/**
+* `snapshotAnchorElementStateAndSaveToRef()` remembers the item at the top of the list;
+* `restoreScrollStateFromAnchor()` scrolls by how far it moved since; `clearAnchor()` forgets it.
+*/
+function useScrollAnchor(listElRef, getVisibleItemsEl) {
+	const anchorRef = useRef(null);
+	return {
+		snapshotAnchorElementStateAndSaveToRef: useCallback(() => {
+			const visibleItemsEl = getVisibleItemsEl();
+			if (listElRef.current && visibleItemsEl) snapshotAnchorElementStateAndSaveToRef(anchorRef, listElRef.current, visibleItemsEl);
+		}, [listElRef, getVisibleItemsEl]),
+		restoreScrollStateFromAnchor: useCallback(() => {
+			if (!anchorRef.current) return;
+			const moved = anchorRef.current.element.getBoundingClientRect().top - anchorRef.current.top;
+			listElRef.current?.scrollBy(0, moved);
+		}, [listElRef]),
+		clearAnchor: useCallback(() => {
+			anchorRef.current = null;
+		}, [])
+	};
+}
+//#endregion
+//#region src/components/virtual-list/VirtualListContext.ts
+const VirtualListContext = createContext(null);
+//#endregion
+//#region src/components/virtual-list/VirtualList.tsx
+/**
+* The most range updates one aligned jump goes through before it stops (each one mounts and measures the
+* rows the previous position brought into view; it is usually stable after 2-3).
+*/
+const MAX_ALIGN_STEPS = 10;
+function VirtualList(props) {
+	const { virtual = true, sessionId, showScrollbar = false, columns = EMPTY_ARRAY, renderCol, renderItemWithCols, items = EMPTY_ARRAY, itemMinSize, itemEstimatedSize, itemResizable = false, itemsStyle, visibleItemsTag = "div", visibleItemsProps, ignoreItemResize = false, onScroll, onWheel, onResize, defaultScrollKey, defaultScrollIndex, getKey, paddingTop = 0, paddingBottom = 0, children: renderItemChild, ItemComponent, empty, emptyAlign = "start", className, style, itemsClassName, footer, footerAfterBottomPadding, header, domRef, ref: _ref, onContentResize, onTransformChange, componentRef, printable, catchWheel = false, onRenderAnomaly, keyboardPageBottomOcclusion = 0, focusable = true, keepAnchorOnItemsChange = false, canAnchorItem, onKeyDown: onNativeKeyDown, ...nativeProps } = props;
+	const listElRef = useRef(null);
+	const [mergedListRefSetter] = useMergedRef(domRef, listElRef);
+	const itemsElRef = useRef(null);
+	const getVisibleItemsEl = useCallback(() => itemsElRef.current?.children[0] || null, []);
+	const [[renderReason, renderCallback, renderVersion], setRenderState] = useState([
+		null,
+		null,
+		0
+	]);
+	const viewportRef = useRef({
+		listHeight: void 0,
+		scrollTop: 0,
+		scrollLeft: 0,
+		listWidth: 0
+	});
+	const rangeRef = useRef({
+		prependIndexes: [],
+		verticalStartIndex: 0,
+		verticalEndIndex: -1,
+		horizontalStartIndex: 0,
+		horizontalEndIndex: -1
+	});
+	/**
+	* The rows kept mounted outside the range (absolutely positioned at their offsets): the rows holding
+	* the text selection and the row holding focus (`focusedKeyRef`).
+	*/
+	const keptKeysRef = useRef([]);
+	/** The key of the row that holds focus (`document.activeElement` is in it), tracked by focusin / focusout. */
+	const focusedKeyRef = useRef(null);
+	const keyToHeightOffsetRef = useRef(/* @__PURE__ */ new Map());
+	const leadingMarginRef = useRef(0);
+	/**
+	* Where the first mounted row in flow starts in the visible-items element (its top margin there,
+	* since nothing above it is mounted), as last written by `applyLayoutStyles`.
+	*/
+	const firstRowStartRef = useRef(0);
+	const pendingScrollTaskRef = useRef(null);
+	const pendingScrollTaskTimeoutRef = useRef(null);
+	const pendingScrollTaskRafRef = useRef(null);
+	const wheelScrollingRef = useRef(false);
+	/** Clears `wheelScrollingRef` in the next frame; this list's own, so other lists cannot replace it. */
+	const [runLatestInNextFrame] = useState(createLatestInNextFrame);
+	/** The wheel is only taken over (catchWheel) where the pointer is not coarse. */
+	const mayUseWheelRef = useRef(typeof document === "undefined" || !isCoarsePointer());
+	const reportRenderAnomaly = useEventCallback((anomaly) => {
+		onRenderAnomaly?.(anomaly);
+	});
+	const forcedRenderTimesRef = useRef([]);
+	/**
+	* The offset applied by the iOS compensation, created here (not in its hook) because
+	* `keepAnchorOnItemsChange` reads it while rendering, before the hook is called.
+	*/
+	const compensationYRef = useRef(0);
+	/** The items, Fenwick tree and session of the last commit (the tree is updated in place by measurements). */
+	const committedLayoutRef = useRef(null);
+	const itemsAnchor = useMemo(() => {
+		const committed = committedLayoutRef.current;
+		const listEl = listElRef.current;
+		if (!keepAnchorOnItemsChange || !virtual || committed === null || listEl === null || committed.items === items || committed.sessionId !== sessionId) return null;
+		return findItemsAnchor({
+			prevItems: committed.items,
+			prevTree: committed.tree,
+			prevPrependIndexes: rangeRef.current.prependIndexes,
+			nextItems: items,
+			getKey,
+			canAnchor: canAnchorItem,
+			top: listEl.scrollTop + compensationYRef.current - paddingTop - leadingMarginRef.current
+		});
+	}, [items]);
+	/** The anchor whose range has been committed to `rangeRef` (so it is applied once). */
+	const appliedItemsAnchorRef = useRef(null);
+	const pendingItemsAnchor = itemsAnchor !== null && itemsAnchor !== appliedItemsAnchorRef.current ? itemsAnchor : null;
+	let renderedRange = rangeRef.current;
+	if (pendingItemsAnchor !== null) {
+		const [verticalStartIndex, verticalEndIndex] = getAnchoredRange(renderedRange.verticalStartIndex, renderedRange.verticalEndIndex, pendingItemsAnchor.index, items.length);
+		renderedRange = {
+			...renderedRange,
+			prependIndexes: pendingItemsAnchor.prependIndexes,
+			verticalStartIndex,
+			verticalEndIndex
+		};
+	}
+	const { prependIndexes, verticalStartIndex: startIndex, verticalEndIndex: endIndex, horizontalStartIndex: colStartIndex, horizontalEndIndex: colEndIndex } = renderedRange;
+	const keyToIndexRef = useRef(void 0);
+	const prevSessionIdRef = useRef(sessionId);
+	const sessionChangedRef = useRef(false);
+	const lastTransformSignatureRef = useRef(null);
+	const clearPendingScrollTask = useCallback(() => {
+		if (pendingScrollTaskTimeoutRef.current !== null) {
+			window.clearTimeout(pendingScrollTaskTimeoutRef.current);
+			pendingScrollTaskTimeoutRef.current = null;
+		}
+		if (pendingScrollTaskRafRef.current != null) {
+			window.cancelAnimationFrame(pendingScrollTaskRafRef.current);
+			pendingScrollTaskRafRef.current = null;
+		}
+		pendingScrollTaskRef.current = null;
+	}, []);
+	useMemo(() => {
+		if (prevSessionIdRef.current === sessionId) return;
+		prevSessionIdRef.current = sessionId;
+		sessionChangedRef.current = true;
+		clearPendingScrollTask();
+		wheelScrollingRef.current = false;
+		keptKeysRef.current = [];
+		focusedKeyRef.current = null;
+		keyToHeightOffsetRef.current.clear();
+		leadingMarginRef.current = 0;
+		keyToIndexRef.current = /* @__PURE__ */ new Map();
+		rangeRef.current = {
+			prependIndexes: [],
+			verticalStartIndex: 0,
+			verticalEndIndex: -1,
+			horizontalStartIndex: 0,
+			horizontalEndIndex: -1
+		};
+		const viewport = viewportRef.current;
+		viewport.scrollTop = 0;
+		viewport.scrollLeft = 0;
+		const listEl = listElRef.current;
+		if (listEl != null) {
+			listEl.scrollTop = 0;
+			listEl.scrollLeft = 0;
+		}
+	}, [sessionId, clearPendingScrollTask]);
+	useMemo(() => {
+		lastTransformSignatureRef.current = null;
+	}, [sessionId]);
+	useMemo(() => {
+		const keyToIndex = /* @__PURE__ */ new Map();
+		items.forEach((item, index) => {
+			keyToIndex.set(getKey(item), index);
+		});
+		keyToIndexRef.current = keyToIndex;
+		const keptKeys = [];
+		keptKeysRef.current.forEach((key) => {
+			if (keyToIndexRef.current.has(key)) keptKeys.push(key);
+		});
+		keptKeysRef.current = keptKeys;
+	}, [
+		sessionId,
+		items,
+		getKey
+	]);
+	const totalColumnsWidth = useMemo(() => {
+		if (renderCol == null && renderItemWithCols == null || columns.length === 0) return;
+		let width = 0;
+		columns.forEach((column) => {
+			width += column.width;
+		});
+		return width;
+	}, [
+		sessionId,
+		renderCol,
+		renderItemWithCols,
+		columns
+	]);
+	/**
+	* Rebuilt whenever the items or the session change: `itemEstimatedSize` for every item plus the
+	* measured offsets cached by key, so measurements survive re-renders and reordering.
+	*/
+	const fenwickTree = useMemo(() => {
+		if (!virtual) return new FenwickTree(0, 0);
+		const tree = new FenwickTree(items.length, itemEstimatedSize);
+		const heightOffsets = keyToHeightOffsetRef.current;
+		items.forEach((item, index) => {
+			const key = getKey(item);
+			const offset = heightOffsets.get(key);
+			if (offset !== void 0) tree.add(index, offset);
+		});
+		return tree;
+	}, [
+		sessionId,
+		items,
+		itemEstimatedSize,
+		getKey,
+		virtual
+	]);
+	const visibleItems = useMemo(() => {
+		if (!virtual) return items;
+		if (endIndex < startIndex) return [];
+		const visible = [];
+		const lastIndex = Math.min(endIndex, items.length - 1);
+		for (let i = startIndex; i <= lastIndex; ++i) visible.push(items[i]);
+		return visible;
+	}, [
+		sessionId,
+		startIndex,
+		endIndex,
+		items,
+		virtual
+	]);
+	const xFenwickTree = useMemo(() => {
+		if (columns.length === 0) return null;
+		const tree = new FenwickTree(columns.length, 0);
+		columns.forEach((column, index) => {
+			tree.add(index, column.width);
+		});
+		return tree;
+	}, [sessionId, columns]);
+	const getColumnLeft = useEventCallback((index) => xFenwickTree !== null ? xFenwickTree.sum(index) : 0);
+	const columnsContextValue = useMemo(() => ({
+		startIndex: colStartIndex,
+		endIndex: colEndIndex,
+		columns,
+		renderCol,
+		renderItemWithCols,
+		getLeft: getColumnLeft
+	}), [
+		colStartIndex,
+		colEndIndex,
+		columns,
+		renderCol,
+		renderItemWithCols,
+		getColumnLeft
+	]);
+	/** Where the rows start in the spacer's content: `paddingTop` plus the first row's top margin. */
+	const getRowsTop = useEventCallback(() => paddingTop + leadingMarginRef.current);
+	/**
+	* The mounted rows in flow, in order: the measured elements of the rendered range. Kept rows (outside
+	* the range, absolutely positioned) are left out: they take no space in the flow.
+	*/
+	const getFlowRows = useEventCallback(() => {
+		const rows = [];
+		const visibleItemsEl = getVisibleItemsEl();
+		if (visibleItemsEl === null) return rows;
+		for (const el of Array.from(visibleItemsEl.children)) {
+			const key = el.getAttribute(ITEM_KEY_ATTR);
+			const index = key === null ? void 0 : keyToIndexRef.current.get(key);
+			if (key !== null && index !== void 0 && index >= startIndex && index <= endIndex && el instanceof HTMLElement) rows.push({
+				el,
+				key,
+				index
+			});
+		}
+		return rows;
+	});
+	/**
+	* Writes the layout without a render: the spacer height (the total size plus the first row's top
+	* margin; a min-height with itemResizable, so the real content may exceed it) and the visible items'
+	* translateY, with the CSS variables sticky children read (`--virtual-list-transform-y`,
+	* `--virtual-list-ios-compensation-y`).
+	*
+	* Unlike the reference implementation (DeepSeek web): the translateY puts the border box of the first
+	* mounted row at its offset (`firstIndex`, or the first row in the DOM), not the element's top. The visible-items element is a
+	* block formatting context, so the first mounted row's top margin is inside it, above the row, and
+	* does not collapse with the row before it (not mounted): the element starts that margin higher. The
+	* collapsed gap above that row is already in the size of the row before it (see `leadingMarginRef`),
+	* so the rows sit exactly where the tree has them whichever row is first, and moving the window's top
+	* edge moves no row. Read before anything is written, so it forces no extra layout.
+	*/
+	const applyLayoutStyles = useEventCallback((firstIndex) => {
+		if (!virtual) return;
+		let index = Math.min(firstIndex, items.length);
+		let firstRowStart = 0;
+		const itemsEl = itemsElRef.current;
+		const visibleItemsEl = itemsEl?.children[0];
+		const firstRow = itemResizable ? getFlowRows()[0] : void 0;
+		if (firstRow !== void 0 && visibleItemsEl instanceof HTMLElement) {
+			index = firstRow.index;
+			firstRowStart = measureRowStart(visibleItemsEl, firstRow.el);
+		}
+		firstRowStartRef.current = firstRowStart;
+		const leadingMargin = leadingMarginRef.current;
+		if (itemsEl) {
+			const height = px(fenwickTree.sum() + leadingMargin) || "";
+			if (itemResizable) {
+				itemsEl.style.height = "";
+				itemsEl.style.minHeight = height;
+			} else {
+				const changed = itemsEl.style.height !== height || itemsEl.style.minHeight !== "";
+				itemsEl.style.height = height;
+				itemsEl.style.minHeight = "";
+				if (changed) onContentResize?.();
+			}
+		}
+		if (visibleItemsEl instanceof HTMLElement) {
+			const offset = px(leadingMargin + fenwickTree.sum(index) - firstRowStart);
+			visibleItemsEl.style.transform = `translateY(${offset})`;
+			visibleItemsEl.style.setProperty("--virtual-list-transform-y", offset);
+			const compensation = px(compensationYRef.current);
+			visibleItemsEl.style.setProperty("--virtual-list-ios-compensation-y", compensation);
+			const signature = `${index}|${offset}`;
+			if (lastTransformSignatureRef.current !== signature) {
+				lastTransformSignatureRef.current = signature;
+				onTransformChange?.();
+			}
+		}
+	});
+	useLayoutEffect(() => {
+		if (!virtual) {
+			const itemsEl = itemsElRef.current;
+			if (itemsEl) {
+				itemsEl.style.height = "";
+				itemsEl.style.minHeight = "";
+			}
+		}
+	}, [virtual]);
+	/**
+	* The viewport sync. The range starts at the item at `scrollTop + compensation - paddingTop` and
+	* holds as many items as fit at `itemMinSize`, plus one. Items holding the text selection, and the item
+	* holding focus, stay
+	* mounted ("kept"). When the new range is inside the old one, only the layout styles are written;
+	* otherwise the items entering above the old start are recorded (`prependIndexes`) and the range is
+	* rendered with flushSync, now or in a microtask (`deferRenderToMicrotask`). At 120 forced renders
+	* within a second a "renderThrashing" anomaly is reported. `afterRender` runs after the layout styles
+	* of the new range are applied.
+	*/
+	const updateRange = useEventCallback((reason, deferRenderToMicrotask, afterRender) => {
+		if (!virtual) return;
+		const listEl = listElRef.current;
+		if (listEl == null) return;
+		const viewport = viewportRef.current;
+		if (viewport.listHeight === void 0) {
+			applyLayoutStyles(startIndex);
+			afterRender?.();
+			return;
+		}
+		const scrollTop = listEl.scrollTop;
+		const effectiveScrollTop = scrollTop + compensationYRef.current;
+		const scrollLeft = listEl.scrollLeft;
+		const range = rangeRef.current;
+		const prevRange = {
+			startIndex: range.verticalStartIndex,
+			endIndex: range.verticalEndIndex
+		};
+		const nextRange = getVerticalRange({
+			fenwickTree,
+			scrollTop: effectiveScrollTop,
+			listHeight: viewport.listHeight,
+			itemMinSize,
+			itemCount: items.length,
+			paddingTop: getRowsTop()
+		});
+		const rangeChanged = prevRange.startIndex !== nextRange.startIndex || prevRange.endIndex !== nextRange.endIndex;
+		const nextInsidePrev = nextRange.startIndex >= prevRange.startIndex && prevRange.endIndex >= nextRange.endIndex;
+		const prevColRange = {
+			startIndex: range.horizontalStartIndex,
+			endIndex: range.horizontalEndIndex
+		};
+		const nextColRange = getHorizontalRange({
+			xFenwickTree,
+			scrollLeft,
+			listWidth: viewport.listWidth,
+			columnCount: columns.length
+		});
+		const colRangeChanged = prevColRange.startIndex !== nextColRange.startIndex || prevColRange.endIndex !== nextColRange.endIndex;
+		viewport.scrollTop = scrollTop;
+		viewport.scrollLeft = scrollLeft;
+		let keptKeysChanged = false;
+		if (typeof window !== "undefined" && reason !== "sessionChanged") {
+			const { startIndex: nextStart, endIndex: nextEnd } = nextRange;
+			const keptKeys = [];
+			const keep = (key) => {
+				const index = keyToIndexRef.current.get(key);
+				if (index !== void 0 && (!(index >= nextStart) || !(index <= nextEnd)) && !keptKeys.includes(key)) keptKeys.push(key);
+			};
+			const focusedKey = focusedKeyRef.current;
+			if (focusedKey !== null) {
+				const active = document.activeElement;
+				if (active !== null && listEl.contains(active)) keep(focusedKey);
+				else focusedKeyRef.current = null;
+			}
+			const selection = window.getSelection();
+			if (selection != null && !selection.isCollapsed && selection.rangeCount > 0) listEl.querySelectorAll(`[${ITEM_KEY_ATTR}]`).forEach((itemEl) => {
+				if (!selection.containsNode(itemEl, true) && itemEl.getElementsByTagName("input").length !== 0) return;
+				const key = itemEl.getAttribute(ITEM_KEY_ATTR);
+				if (key !== null) keep(key);
+			});
+			if (!haveSameKeys(keptKeys, keptKeysRef.current)) {
+				keptKeysRef.current = keptKeys;
+				keptKeysChanged = true;
+			}
+		}
+		if (reason !== "sessionChanged" && !keptKeysChanged && (!rangeChanged || nextInsidePrev) && !colRangeChanged) {
+			if (nextInsidePrev) applyLayoutStyles(prevRange.startIndex);
+			else applyLayoutStyles(nextRange.startIndex);
+			afterRender?.();
+			return;
+		}
+		if (reason !== "sessionChanged") {
+			const entering = [];
+			if (pendingScrollTaskRef.current?.type === void 0 && nextRange.endIndex >= prevRange.startIndex) for (let i = nextRange.startIndex; i < prevRange.startIndex; ++i) entering.push(i);
+			range.prependIndexes = entering;
+		} else range.prependIndexes = [];
+		range.verticalStartIndex = nextRange.startIndex;
+		range.verticalEndIndex = nextRange.endIndex;
+		range.horizontalStartIndex = nextColRange.startIndex;
+		range.horizontalEndIndex = nextColRange.endIndex;
+		const now = Date.now();
+		const renderTimes = forcedRenderTimesRef.current;
+		renderTimes.push(now);
+		const windowStart = now - RENDER_THRASHING_WINDOW_MS;
+		while (renderTimes.length > 0 && renderTimes[0] < windowStart) renderTimes.shift();
+		if (renderTimes.length >= 120) {
+			reportRenderAnomaly({
+				type: "renderThrashing",
+				message: `${renderTimes.length} forced renders within ${RENDER_THRASHING_WINDOW_MS}ms`,
+				payload: {
+					renderCount: renderTimes.length,
+					windowMs: RENDER_THRASHING_WINDOW_MS,
+					triggerReason: reason,
+					itemCount: items.length
+				}
+			});
+			renderTimes.length = 0;
+		}
+		if (deferRenderToMicrotask) Promise.resolve().then(() => {
+			flushSync(() => {
+				setRenderState((state) => [
+					reason,
+					afterRender,
+					state[2] + 1
+				]);
+			});
+		});
+		else flushSync(() => {
+			setRenderState((state) => [
+				reason,
+				afterRender,
+				state[2] + 1
+			]);
+		});
+	});
+	/**
+	* A pending scroll task (to the top, the bottom, an index, or a custom task) stays armed for one
+	* animation frame plus one task, so that item sizes measured right after the jump replay it instead
+	* of being compensated.
+	*/
+	const schedulePendingScrollTaskExpiry = useCallback(() => {
+		pendingScrollTaskRafRef.current = requestAnimationFrame(() => {
+			pendingScrollTaskRafRef.current = null;
+			pendingScrollTaskTimeoutRef.current = window.setTimeout(() => {
+				pendingScrollTaskRef.current = null;
+				pendingScrollTaskTimeoutRef.current = null;
+			});
+		});
+	}, []);
+	const scrollToPosition = useEventCallback((left, top, behavior) => {
+		listElRef.current?.scrollTo({
+			left,
+			top,
+			behavior
+		});
+	});
+	/**
+	* Scrolls to the offset of `index` in the Fenwick tree (an estimate for items not measured yet);
+	* an "instant" jump is armed as the pending task, to be replayed after measurements. `ensureVisibleOnly`
+	* (the `debounce` option) scrolls only as far as needed to show the item. With virtualization off the
+	* offset is read from the DOM (`getBoundingClientRect` of the index-th child).
+	*/
+	const scrollToIndex = useEventCallback((index, behavior, ensureVisibleOnly, isReplay, scrollMarginTop = 0, scrollMarginBottom = 0) => {
+		if (!virtual) {
+			const listEl = listElRef.current;
+			const itemsEl = itemsElRef.current;
+			if (!itemsEl || !listEl) return;
+			const visibleItemsEl = itemsEl.firstElementChild;
+			if (!visibleItemsEl) return;
+			const itemEl = visibleItemsEl.children.item(index);
+			if (!(itemEl instanceof HTMLElement)) return;
+			const listRect = listEl.getBoundingClientRect();
+			const itemRect = itemEl.getBoundingClientRect();
+			const itemTop = itemRect.top - listRect.top + listEl.scrollTop;
+			if (ensureVisibleOnly) {
+				const { scrollTop, offsetHeight } = listEl;
+				const itemHeight = itemRect.height;
+				if (itemTop > scrollTop) {
+					if (!(itemTop + itemHeight <= scrollTop + offsetHeight)) listEl.scrollTo({
+						left: 0,
+						top: itemTop + itemHeight - offsetHeight + scrollMarginBottom,
+						behavior
+					});
+				} else listEl.scrollTo({
+					left: 0,
+					top: itemTop - scrollMarginTop,
+					behavior
+				});
+			} else listEl.scrollTo({
+				left: 0,
+				top: itemTop,
+				behavior
+			});
+			return;
+		}
+		const targetTop = fenwickTree.sum(index) + getRowsTop();
+		if (!isReplay) {
+			clearPendingScrollTask();
+			if (behavior === "instant") {
+				pendingScrollTaskRef.current = {
+					type: "index",
+					index,
+					debounce: ensureVisibleOnly
+				};
+				schedulePendingScrollTaskExpiry();
+			}
+		}
+		if (ensureVisibleOnly) {
+			const listEl = listElRef.current;
+			if (listEl) {
+				const { scrollTop, offsetHeight } = listEl;
+				if (targetTop > scrollTop) {
+					const itemSize = fenwickTree.get(index);
+					if (!(targetTop + itemSize <= scrollTop + offsetHeight)) {
+						listEl.scrollTo({
+							left: 0,
+							top: targetTop + itemSize - offsetHeight + scrollMarginBottom,
+							behavior
+						});
+						updateRange("listScroll", true, null);
+					}
+				} else {
+					listEl.scrollTo({
+						left: 0,
+						top: targetTop - scrollMarginTop,
+						behavior
+					});
+					updateRange("listScroll", true, null);
+				}
+			}
+		} else {
+			listElRef.current?.scrollTo({
+				left: 0,
+				top: targetTop,
+				behavior
+			});
+			updateRange("listScroll", true, null);
+		}
+	});
+	/**
+	* Measures the mounted rows in flow from layout, synchronously, and writes the sizes that changed into
+	* the Fenwick tree and the key -> offset cache, and the first row's top margin when the first row is
+	* mounted (`leadingMarginRef`). Reads everything first (`measureRowSpans`), then writes: no layout is
+	* forced in between. O(mounted rows).
+	*
+	* Unlike the reference implementation (DeepSeek web): it measured each row's own `offsetHeight`,
+	* which in block flow misses the margins between rows and a child's margins that collapse through a row, so the rows drifted from
+	* their offsets. A row's size here is the space it takes in the flow: from where its border box starts
+	* to where the next row's starts (the last mounted row: to the end of the rows), so collapsed margins
+	* are counted once, in the row above them, and the sizes add up to the laid-out height. A row's size
+	* depends on the next row's top margin, so every measurement measures the whole run, not the row that
+	* resized. The last mounted row's bottom margin does not collapse with the next row (not mounted): its
+	* size is provisional until the next row mounts, which corrects it without moving any mounted row
+	* (they are laid out by the browser, positioned by the first row's offset alone). Kept rows are not
+	* measured: absolutely positioned, they take no space in the flow, and keep the size they were
+	* measured at in it.
+	*/
+	const measureFlowRun = useEventCallback(() => {
+		const resizes = [];
+		const visibleItemsEl = getVisibleItemsEl();
+		if (!virtual || ignoreItemResize || !itemResizable || !(visibleItemsEl instanceof HTMLElement)) return {
+			resizes,
+			leadingMarginDelta: 0
+		};
+		const rows = getFlowRows();
+		if (rows.length === 0) return {
+			resizes,
+			leadingMarginDelta: 0
+		};
+		const { spans, firstStart } = measureRowSpans(visibleItemsEl, rows.map((row) => row.el));
+		let leadingMarginDelta = 0;
+		if (rows[0].index === 0 && firstStart !== leadingMarginRef.current) {
+			leadingMarginDelta = firstStart - leadingMarginRef.current;
+			leadingMarginRef.current = firstStart;
+		}
+		rows.forEach(({ key, index }, i) => {
+			const size = spans[i];
+			const previousSize = fenwickTree.get(index);
+			if (size === previousSize) return;
+			if (size - itemEstimatedSize === 0) keyToHeightOffsetRef.current.delete(key);
+			else keyToHeightOffsetRef.current.set(key, size - itemEstimatedSize);
+			fenwickTree.add(index, size - previousSize);
+			resizes.push({
+				index,
+				key,
+				delta: size - previousSize
+			});
+		});
+		return {
+			resizes,
+			leadingMarginDelta
+		};
+	});
+	/**
+	* Measures the mounted rows now (`measureFlowRun`) and applies the layout; returns whether any size
+	* changed. Used by the aligned jump, which cannot wait for the batch (a microtask) or the
+	* ResizeObserver (after layout, possibly a frame later) to learn the sizes.
+	*/
+	const measureMountedItems = useEventCallback(() => {
+		const { resizes, leadingMarginDelta } = measureFlowRun();
+		const changed = resizes.length !== 0 || leadingMarginDelta !== 0;
+		if (changed) {
+			applyLayoutStyles(startIndex);
+			onContentResize?.();
+		}
+		return changed;
+	});
+	/**
+	* Where item `index` is, in the list's scroll coordinates: read from the DOM when
+	* it is mounted (exact), else its offset in the Fenwick tree (estimates for unmeasured items).
+	*/
+	const getItemExtent = useEventCallback((index) => {
+		const listEl = listElRef.current;
+		const item = items[index];
+		const visibleItemsEl = getVisibleItemsEl();
+		if (listEl && item !== void 0 && visibleItemsEl && itemResizable) {
+			const key = getKey(item);
+			for (const itemEl of Array.from(visibleItemsEl.children)) if (itemEl.getAttribute("data-virtual-list-item-key") === key) {
+				const rect = itemEl.getBoundingClientRect();
+				const listTop = listEl.getBoundingClientRect().top + listEl.clientTop;
+				return {
+					top: rect.top - listTop + listEl.scrollTop,
+					size: rect.height,
+					measured: true
+				};
+			}
+		}
+		return {
+			top: fenwickTree.sum(index) + getRowsTop(),
+			size: fenwickTree.get(index),
+			measured: !itemResizable
+		};
+	});
+	/** Bumped by every aligned jump: a chain of steps stops when a newer jump has started. */
+	const alignRunRef = useRef(0);
+	/**
+	* One step of an aligned jump: measure the mounted items, work out the exact
+	* `scrollTop` for the item from the DOM, set it, and update the range. If the range changes, the rows it
+	* brings into view are rendered (in a microtask, still before the browser paints) and the next step runs
+	* from the render callback (a layout effect) to measure them; the jump is done when a step finds the item
+	* mounted, no size changed and `scrollTop` already right. Bounded by `MAX_ALIGN_STEPS`.
+	*/
+	const alignStep = useEventCallback((run, index, align, scrollMarginTop, scrollMarginBottom, remaining) => {
+		const listEl = listElRef.current;
+		if (listEl == null || run !== alignRunRef.current || index >= items.length) return;
+		const sizesChanged = measureMountedItems();
+		const { top: itemTop, size: itemSize, measured } = getItemExtent(index);
+		const viewportHeight = listEl.clientHeight;
+		const target = Math.round(getAlignedScrollTop({
+			itemTop,
+			itemSize,
+			viewportHeight,
+			align,
+			scrollMarginTop,
+			scrollMarginBottom,
+			maxScrollTop: listEl.scrollHeight - viewportHeight
+		}));
+		const moved = Math.abs(listEl.scrollTop - target) >= .5;
+		if (moved) listEl.scrollTo({
+			left: listEl.scrollLeft,
+			top: target,
+			behavior: "instant"
+		});
+		viewportRef.current.scrollTop = listEl.scrollTop;
+		if (!moved && !sizesChanged && measured || remaining <= 0) return;
+		updateRange("listScroll", true, () => {
+			alignStep(run, index, align, scrollMarginTop, scrollMarginBottom, remaining - 1);
+		});
+	});
+	/**
+	* `scrollTo({ index | key, align })`. Instant (or "auto"): the aligned steps above, armed as the pending
+	* task like the other instant jumps (item sizes reported after the jump replay it, for one frame plus one
+	* task). Smooth: one scroll to the position worked out from the current layout (estimates for rows not
+	* measured yet), like the smooth index jump. Virtualization off: read from the DOM.
+	*/
+	const scrollToAligned = useEventCallback((index, align, behavior, isReplay, scrollMarginTop, scrollMarginBottom) => {
+		const listEl = listElRef.current;
+		if (listEl == null) return;
+		if (!virtual) {
+			const itemEl = getVisibleItemsEl()?.children.item(index);
+			if (!itemEl) return;
+			const rect = itemEl.getBoundingClientRect();
+			const listTop = listEl.getBoundingClientRect().top + listEl.clientTop;
+			const top = getAlignedScrollTop({
+				itemTop: rect.top - listTop + listEl.scrollTop,
+				itemSize: rect.height,
+				viewportHeight: listEl.clientHeight,
+				align,
+				scrollMarginTop,
+				scrollMarginBottom,
+				maxScrollTop: listEl.scrollHeight - listEl.clientHeight
+			});
+			listEl.scrollTo({
+				left: 0,
+				top: Math.round(top),
+				behavior
+			});
+			return;
+		}
+		const smooth = behavior === "smooth";
+		if (!isReplay) {
+			clearPendingScrollTask();
+			if (!smooth) {
+				pendingScrollTaskRef.current = {
+					type: "align",
+					index,
+					align,
+					scrollMarginTop,
+					scrollMarginBottom
+				};
+				schedulePendingScrollTaskExpiry();
+			}
+		}
+		const run = ++alignRunRef.current;
+		if (smooth) {
+			const { top: itemTop, size: itemSize } = getItemExtent(index);
+			const top = getAlignedScrollTop({
+				itemTop,
+				itemSize,
+				viewportHeight: listEl.clientHeight,
+				align,
+				scrollMarginTop,
+				scrollMarginBottom,
+				maxScrollTop: listEl.scrollHeight - listEl.clientHeight
+			});
+			listEl.scrollTo({
+				left: 0,
+				top: Math.round(top),
+				behavior
+			});
+			updateRange("listScroll", true, null);
+			return;
+		}
+		alignStep(run, index, align, scrollMarginTop, scrollMarginBottom, MAX_ALIGN_STEPS);
+	});
+	const scrollTo = useEventCallback((options, topIfNumber) => {
+		if (typeof options == "number") {
+			scrollToPosition(options, topIfNumber, "instant");
+			return;
+		}
+		const { left, top, index, key, position, behavior = "instant", debounce = true, scrollMarginTop = 0, scrollMarginBottom = 0, align } = options;
+		if (left !== void 0 || top !== void 0) scrollToPosition(left, top, behavior);
+		else if (align !== void 0 && (index !== void 0 || key !== void 0)) {
+			const alignIndex = index ?? keyToIndexRef.current.get(key);
+			if (alignIndex !== void 0) scrollToAligned(alignIndex, align, behavior, false, scrollMarginTop, scrollMarginBottom);
+		} else if (index !== void 0) scrollToIndex(index, behavior, debounce, false, scrollMarginTop, scrollMarginBottom);
+		else if (key !== void 0) {
+			const keyIndex = keyToIndexRef.current.get(key);
+			if (keyIndex !== void 0) scrollToIndex(keyIndex, behavior, debounce, false, scrollMarginTop, scrollMarginBottom);
+		} else if (position) {
+			if (virtual) {
+				clearPendingScrollTask();
+				if (behavior === "instant") {
+					pendingScrollTaskRef.current = { type: position };
+					schedulePendingScrollTaskExpiry();
+				}
+			}
+			if (position === "bottom") {
+				scrollToPosition(0, listElRef.current?.scrollHeight || 2e9, behavior);
+				if (virtual) updateRange("listScroll", true, null);
+			} else if (position === "top") scrollToPosition(0, 0, behavior);
+		}
+	});
+	const replayPendingScrollTask = useEventCallback(() => {
+		const task = pendingScrollTaskRef.current;
+		if (task) {
+			if (task.type === "top") scrollToPosition(0, 0, "instant");
+			else if (task.type === "bottom") scrollToPosition(0, listElRef.current?.scrollHeight || 2e9, "instant");
+			else if (task.type === "index") scrollToIndex(task.index, "instant", task.debounce, true);
+			else if (task.type === "align") scrollToAligned(task.index, task.align, "instant", true, task.scrollMarginTop, task.scrollMarginBottom);
+			else if (task.type === "custom") task.task();
+		}
+	});
+	/**
+	* Runs `task` now (after a range update) and again after every batch of item resizes while it is
+	* armed (one frame plus one task).
+	*/
+	const submitScrollAdjustingTask = useCallback((task) => {
+		clearPendingScrollTask();
+		pendingScrollTaskRef.current = {
+			type: "custom",
+			task
+		};
+		schedulePendingScrollTaskExpiry();
+		updateRange("listScroll", true, replayPendingScrollTask);
+	}, [
+		replayPendingScrollTask,
+		clearPendingScrollTask,
+		schedulePendingScrollTaskExpiry,
+		updateRange
+	]);
+	const syncViewport = useCallback(() => {
+		updateRange("listScroll", false, null);
+	}, [updateRange]);
+	const restoreItemsAnchor = useEventCallback((anchor) => {
+		appliedItemsAnchorRef.current = anchor;
+		rangeRef.current = renderedRange;
+		const listEl = listElRef.current;
+		const index = keyToIndexRef.current.get(anchor.key);
+		if (listEl == null || index === void 0 || pendingScrollTaskRef.current?.type !== void 0) return;
+		applyLayoutStyles(startIndex);
+		const diff = fenwickTree.sum(index) + anchor.delta + getRowsTop() - (listEl.scrollTop + compensationYRef.current);
+		if (diff !== 0 && !addCompensation(diff)) listEl.scrollBy(0, diff);
+		viewportRef.current.scrollTop = listEl.scrollTop;
+	});
+	useLayoutEffect(() => {
+		if (pendingItemsAnchor !== null && !sessionChangedRef.current) restoreItemsAnchor(pendingItemsAnchor);
+		if (sessionChangedRef.current) {
+			updateRange("sessionChanged", true, replayPendingScrollTask);
+			sessionChangedRef.current = false;
+		} else if (itemResizable) {
+			const heightBefore = listElRef.current?.offsetHeight;
+			applyLayoutStyles(startIndex);
+			if (heightBefore === listElRef.current?.offsetHeight) updateRange("itemsChanged", true, replayPendingScrollTask);
+		} else updateRange("itemsChanged", true, replayPendingScrollTask);
+	}, [
+		sessionId,
+		items,
+		replayPendingScrollTask,
+		updateRange,
+		itemResizable,
+		applyLayoutStyles
+	]);
+	useLayoutEffect(() => {
+		committedLayoutRef.current = {
+			items,
+			tree: fenwickTree,
+			sessionId
+		};
+	});
+	useLayoutEffect(() => {
+		applyLayoutStyles(startIndex);
+		renderCallback?.();
+	}, [
+		renderReason,
+		renderCallback,
+		renderVersion,
+		applyLayoutStyles
+	]);
+	const getOffsetTopOfKey = useEventCallback((key) => {
+		const index = keyToIndexRef.current.get(key);
+		if (index !== void 0) return fenwickTree.sum(index) + getRowsTop();
+	});
+	const refreshListWidth = useCallback(() => {
+		const listEl = listElRef.current;
+		if (listEl) listEl.style.setProperty("--virtual-list-width", `${listEl.offsetWidth}px`);
+	}, [listElRef]);
+	const imperativeApi = useMemo(() => ({
+		listElRef,
+		itemsElRef,
+		scrollTo,
+		syncViewport,
+		getOffsetTopOfKey,
+		submitScrollAdjustingTask,
+		refreshListWidth
+	}), [
+		getOffsetTopOfKey,
+		scrollTo,
+		syncViewport,
+		submitScrollAdjustingTask,
+		refreshListWidth
+	]);
+	useImperativeHandle(componentRef, () => imperativeApi, [imperativeApi]);
+	const itemResizeQueueRef = useRef([]);
+	const enqueueItemResize = useEventCallback((entry) => {
+		itemResizeQueueRef.current.push(entry);
+	});
+	const clearItemResizeQueue = useEventCallback(() => {
+		itemResizeQueueRef.current = [];
+	});
+	const batchResizeScheduledRef = useRef(false);
+	/**
+	* Applies the queued item measurements (in place of the browser's scroll anchoring): the mounted rows
+	* are measured (`measureFlowRun`: all of them, since a row's size depends on its neighbour) and each
+	* size change goes into the Fenwick tree and the key -> offset cache. With no pending scroll task,
+	* the size changes of items measured for the FIRST time among those that entered above the old start
+	* of the range (`prependIndexes`), and of rows above the view, are scrolled away (`scrollBy`, or
+	* through the iOS compensation during a touch scroll); with a pending task, the task is replayed.
+	*/
+	const handleItemBatchResize = useEventCallback(() => {
+		if (!virtual) return;
+		const queue = itemResizeQueueRef.current;
+		if (ignoreItemResize) return;
+		const listElBefore = listElRef.current;
+		const viewTop = listElBefore == null ? 0 : listElBefore.scrollTop + compensationYRef.current - getRowsTop();
+		const viewTopIndex = listElBefore == null ? 0 : fenwickTree.getBound(viewTop);
+		const isFirstOfKey = /* @__PURE__ */ new Map();
+		for (const { key, isFirst } of queue) if (!isFirstOfKey.has(key)) isFirstOfKey.set(key, isFirst);
+		const { resizes, leadingMarginDelta } = measureFlowRun();
+		applyLayoutStyles(startIndex);
+		onContentResize?.();
+		const listEl = listElRef.current;
+		if (listEl != null) {
+			if (pendingScrollTaskRef.current?.type === void 0) {
+				const compensates = (index, key) => key !== void 0 && isFirstOfKey.get(key) === true && prependIndexes.includes(index) || index < viewTopIndex;
+				let compensation = 0;
+				for (const { index, key, delta } of resizes) if (compensates(index, key)) compensation += delta;
+				const firstItem = items[0];
+				if (leadingMarginDelta !== 0 && (viewTop > 0 || compensates(0, firstItem === void 0 ? void 0 : getKey(firstItem)))) compensation += leadingMarginDelta;
+				if (compensation !== 0 && !addCompensation(compensation)) listEl.scrollBy(0, compensation);
+			} else replayPendingScrollTask();
+			const viewport = viewportRef.current;
+			viewport.scrollTop = listEl.scrollTop;
+			viewport.scrollLeft = listEl.scrollLeft;
+		}
+		clearItemResizeQueue();
+		updateRange("batchItemResize", false, null);
+	});
+	/** Measurements of items that just mounted are applied together, in one microtask. */
+	const scheduleItemBatchResize = useEventCallback(() => {
+		if (!batchResizeScheduledRef.current) {
+			Promise.resolve().then(() => {
+				handleItemBatchResize();
+				batchResizeScheduledRef.current = false;
+			});
+			batchResizeScheduledRef.current = true;
+		}
+	});
+	/**
+	* Ignores scroll events while a flush of the iOS compensation suppresses them; otherwise updates
+	* the range (replaying a pending task) and calls `onScroll`.
+	*/
+	const handleListScroll = useEventCallback((event) => {
+		const scrollTop = event.target.scrollTop;
+		if (!isScrollSuppressedWithForceRestore(scrollTop)) {
+			if (!wheelScrollingRef.current) updateRange("listScroll", false, pendingScrollTaskRef.current ? replayPendingScrollTask : null);
+			onScroll?.(event.nativeEvent);
+		}
+	});
+	/**
+	* With `catchWheel` (and a fine pointer): scrolls by the wheel itself (`preventDefault`, then
+	* `scrollTop +=`) and updates the range at once, so the rows are rendered in the same frame.
+	*/
+	const handleWheel = useEventCallback((wheelEvent) => {
+		if (catchWheel) {
+			if (mayUseWheelRef.current) {
+				const listEl = listElRef.current;
+				if (listEl != null) {
+					const scale = getWheelDeltaScale();
+					const deltaX = wheelEvent.deltaX / scale;
+					const deltaY = wheelEvent.deltaY / scale;
+					if (deltaX === 0 && (listEl.scrollTop === 0 && deltaY <= 0 || listEl.scrollTop + listEl.offsetHeight >= listEl.scrollHeight && deltaY >= 0)) return;
+					wheelEvent.preventDefault();
+					listEl.scrollTop += deltaY;
+					listEl.scrollLeft += deltaX;
+					syncViewport();
+					wheelScrollingRef.current = true;
+					runLatestInNextFrame(() => {
+						wheelScrollingRef.current = false;
+					});
+				}
+			}
+			onWheel?.(wheelEvent);
+		}
+	});
+	useNonPassiveWheel(useCallback(() => listElRef.current, []), handleWheel, catchWheel);
+	const iosCompensationEnabled = isIOS && virtual;
+	const { addCompensation, isScrollSuppressedWithForceRestore } = useIosMomentumCompensation({
+		enabled: iosCompensationEnabled,
+		listElRef,
+		itemsElRef,
+		syncViewport,
+		compensationYRef
+	});
+	/**
+	* The list's own resize: stores its height and width, sets `--virtual-list-width` and updates
+	* the range. Skipped while the list is hidden with `display: none`.
+	*/
+	const handleListResize = useEventCallback((listEl, deferRender) => {
+		if (isHiddenByDisplayNone(listEl)) return;
+		const height = listEl.offsetHeight;
+		const width = listEl.offsetWidth;
+		const viewport = viewportRef.current;
+		if (listElRef.current) listElRef.current.style.setProperty("--virtual-list-width", `${width}px`);
+		if (renderCol == null && renderItemWithCols == null) {
+			if (height === viewport.listHeight) return;
+		} else if (height === viewport.listHeight && width === viewport.listWidth) return;
+		viewport.listHeight = height;
+		viewport.listWidth = width;
+		updateRange("listResize", deferRender, replayPendingScrollTask);
+	});
+	const onListResizeObserved = useEventCallback(({ entry }) => {
+		handleListResize(entry.target, false);
+		onResize?.(entry);
+	});
+	const onListRefUpdated = useEventCallback((el) => {
+		if (el) handleListResize(el, true);
+	});
+	/**
+	* Tracks the row holding focus: focusin finds the row the target is in (the visible-items element's
+	* child it is inside); focusout to outside the list releases it, and the range is updated so the row
+	* unmounts if it is out of the range.
+	*/
+	const handleFocusIn = useEventCallback((event) => {
+		const visibleItemsEl = getVisibleItemsEl();
+		let el = event.target instanceof Element ? event.target : null;
+		while (el !== null && el.parentElement !== visibleItemsEl) el = el.parentElement;
+		focusedKeyRef.current = el?.getAttribute("data-virtual-list-item-key") ?? null;
+	});
+	const handleFocusOut = useEventCallback((event) => {
+		const listEl = listElRef.current;
+		const next = event.relatedTarget;
+		if (listEl === null || next instanceof Node && listEl.contains(next)) return;
+		if (focusedKeyRef.current !== null) {
+			focusedKeyRef.current = null;
+			updateRange("listScroll", true, null);
+		}
+	});
+	useLayoutEffect(() => {
+		const listEl = listElRef.current;
+		if (listEl === null) return;
+		listEl.addEventListener("focusin", handleFocusIn);
+		listEl.addEventListener("focusout", handleFocusOut);
+		return () => {
+			listEl.removeEventListener("focusin", handleFocusIn);
+			listEl.removeEventListener("focusout", handleFocusOut);
+		};
+	}, [handleFocusIn, handleFocusOut]);
+	useLayoutEffect(() => {
+		if (defaultScrollIndex != null) scrollTo({ index: defaultScrollIndex });
+		else if (defaultScrollKey != null) scrollTo({ key: defaultScrollKey });
+	}, [sessionId]);
+	const itemsContainerStyle = useMemo(() => ({
+		boxSizing: "content-box",
+		width: px(totalColumnsWidth) ?? void 0,
+		paddingTop: px(paddingTop) ?? void 0,
+		...typeof itemsStyle == "object" ? itemsStyle : {}
+	}), [
+		totalColumnsWidth,
+		paddingTop,
+		itemsStyle
+	]);
+	const [keptItemsBefore, keptItemsAfter] = useMemo(() => {
+		if (!virtual) return [EMPTY_ARRAY, EMPTY_ARRAY];
+		const before = [];
+		const after = [];
+		keptKeysRef.current.forEach((key) => {
+			const index = keyToIndexRef.current.get(key);
+			if (index === void 0) return;
+			const item = items[index];
+			if (item !== void 0) {
+				if (index < startIndex) before.push(item);
+				else if (index > endIndex) after.push(item);
+			}
+		});
+		return [before, after];
+	}, [
+		virtual,
+		keptKeysRef.current,
+		items,
+		startIndex,
+		endIndex
+	]);
+	/**
+	* Renders one item. With `itemResizable` it is wrapped in a ResizeObserverWrapper: when the ref is
+	* set the item gets `data-virtual-list-item-key` and is measured in the next microtask batch
+	* (`isFirst`); later sizes come from the ResizeObserver. The React key is `sessionId:key`, so a new
+	* session remounts every item.
+	*/
+	const renderItem = useCallback((item, absolute) => {
+		const key = getKey(item);
+		const index = keyToIndexRef.current.get(key);
+		const reactKey = sessionId !== void 0 ? `${sessionId}:${key}` : key;
+		const absoluteStyle = absolute ? {
+			position: "absolute",
+			top: px(fenwickTree.sum(index) - fenwickTree.sum(startIndex) + firstRowStartRef.current),
+			left: 0,
+			right: 0
+		} : void 0;
+		const colsNode = renderCol != null ? /* @__PURE__ */ jsx(ItemColumns, {
+			index,
+			item
+		}) : void 0;
+		const itemWithColsNode = renderItemWithCols != null ? /* @__PURE__ */ jsx(ItemColumns, {
+			index,
+			item
+		}) : void 0;
+		if (itemResizable) return /* @__PURE__ */ jsx(ResizeObserverWrapper, {
+			simulateRefUpdateTrigger: sessionId,
+			disabled: !virtual,
+			onRefUpdate: (el) => {
+				if (el) {
+					el.setAttribute(ITEM_KEY_ATTR, key);
+					if (!ignoreItemResize && virtual) {
+						enqueueItemResize({
+							key,
+							target: el,
+							isFirst: true
+						});
+						scheduleItemBatchResize();
+					}
+				}
+			},
+			onResize: ({ entry, isFirst }) => {
+				if (!ignoreItemResize) {
+					enqueueItemResize({
+						key,
+						target: entry.target,
+						isFirst
+					});
+					getResizeObserverDelegate().runAfterEntries(handleItemBatchResize);
+				}
+			},
+			children: ({ ref }) => {
+				if (ItemComponent) return /* @__PURE__ */ jsx(ItemComponent, {
+					domRef: ref,
+					item,
+					index,
+					renderedCols: colsNode,
+					renderedItemWithCols: itemWithColsNode,
+					style: absoluteStyle
+				});
+				else if (renderItemChild == null) return;
+				else return renderItemChild({
+					key: void 0,
+					domRef: ref,
+					item,
+					index,
+					renderedCols: colsNode,
+					renderedItemWithCols: itemWithColsNode,
+					style: absoluteStyle
+				});
+			}
+		}, reactKey);
+		else if (ItemComponent) return /* @__PURE__ */ jsx(ItemComponent, {
+			domRef: null,
+			item,
+			index,
+			renderedCols: colsNode,
+			renderedItemWithCols: itemWithColsNode,
+			style: absoluteStyle
+		}, reactKey);
+		else if (renderItemChild == null) return;
+		else return renderItemChild({
+			key: reactKey,
+			domRef: null,
+			item,
+			index,
+			renderedCols: colsNode,
+			renderedItemWithCols: itemWithColsNode,
+			style: absoluteStyle
+		});
+	}, [
+		virtual,
+		getKey,
+		fenwickTree,
+		startIndex,
+		renderCol,
+		renderItemWithCols,
+		itemResizable,
+		sessionId,
+		ignoreItemResize,
+		enqueueItemResize,
+		scheduleItemBatchResize,
+		handleItemBatchResize,
+		ItemComponent,
+		renderItemChild
+	]);
+	const renderedVisibleItems = useMemo(() => visibleItems.map((item) => renderItem(item, false)), [renderItem, visibleItems]);
+	const renderedKeptBefore = useMemo(() => keptItemsBefore.map((item) => renderItem(item, true)), [renderItem, keptItemsBefore]);
+	const renderedKeptAfter = useMemo(() => keptItemsAfter.map((item) => renderItem(item, true)), [renderItem, keptItemsAfter]);
+	useNonVirtualContentResize(itemsElRef, onContentResize, !virtual);
+	const onContentResizeRef = useLatestRef(onContentResize);
+	const hasItems = items.length !== 0;
+	const footerNode = useMemo(() => typeof footer != "function" ? footer : /* @__PURE__ */ jsx(ResizeObserverWrapper, {
+		onResize: () => {
+			onContentResizeRef.current?.();
+		},
+		onUnmounted: () => {
+			onContentResizeRef.current?.();
+		},
+		children: ({ ref }) => footer({ domRef: ref })
+	}), [footer, onContentResizeRef]);
+	const emptyNode = useMemo(() => typeof empty != "function" ? empty : /* @__PURE__ */ jsx(ResizeObserverWrapper, {
+		onResize: () => {
+			onContentResizeRef.current?.();
+		},
+		onUnmounted: () => {
+			onContentResizeRef.current?.();
+		},
+		children: ({ ref }) => empty({ domRef: ref })
+	}), [empty, onContentResizeRef]);
+	const { snapshotAnchorElementStateAndSaveToRef, restoreScrollStateFromAnchor, clearAnchor } = useScrollAnchor(listElRef, getVisibleItemsEl);
+	useMemoWithPrevious((previous) => {
+		if (!previous || !itemResizable) return;
+		const [wasVirtual, previousSessionId] = previous;
+		if (previousSessionId === sessionId) {
+			if (wasVirtual && !virtual) snapshotAnchorElementStateAndSaveToRef();
+			else {
+				const visibleItemsEl = getVisibleItemsEl();
+				if (!(visibleItemsEl instanceof HTMLElement)) return;
+				const rows = [];
+				for (const el of Array.from(visibleItemsEl.children)) {
+					const key = el.getAttribute(ITEM_KEY_ATTR);
+					if (key !== null && el instanceof HTMLElement) rows.push({
+						el,
+						key
+					});
+				}
+				const { spans, firstStart } = measureRowSpans(visibleItemsEl, rows.map((row) => row.el));
+				if (rows[0] !== void 0 && keyToIndexRef.current.get(rows[0].key) === 0) leadingMarginRef.current = firstStart;
+				rows.forEach(({ key }, i) => {
+					const offset = spans[i] - itemEstimatedSize;
+					if (offset === 0) keyToHeightOffsetRef.current.delete(key);
+					else keyToHeightOffsetRef.current.set(key, offset);
+				});
+			}
+		}
+	}, [virtual, sessionId]);
+	useLayoutEffectWithPrevious((previous) => {
+		if (!itemResizable || !previous) return;
+		const [wasVirtual, previousSessionId] = previous;
+		if (previousSessionId === sessionId && wasVirtual && !virtual) {
+			restoreScrollStateFromAnchor();
+			clearAnchor();
+		}
+	}, [virtual, sessionId]);
+	const { onKeyDown: onKeyboardScroll } = useKeyboardScroll(scrollTo, { pageBottomOcclusion: keyboardPageBottomOcclusion });
+	/** The consumer's `onKeyDown` first: a key it takes (`preventDefault`) does not scroll the list. */
+	const onKeyDown = useCallback((event) => {
+		onNativeKeyDown?.(event);
+		onKeyboardScroll(event);
+	}, [onNativeKeyDown, onKeyboardScroll]);
+	const emptyCentered = items.length === 0 && emptyAlign === "center";
+	const rootClassName = cn("r-virtual-list", columns.length !== 0 && "r-virtual-list--x-scrollable", showScrollbar && "r-virtual-list--show-scrollbar", printable === true && "r-virtual-list--printable", emptyCentered && "r-virtual-list--empty-centered", iosCompensationEnabled && "r-virtual-list--ios-compensation-enabled", className);
+	return /* @__PURE__ */ jsx(ResizeObserverWrapper, {
+		forwardedRef: mergedListRefSetter,
+		onRefUpdate: onListRefUpdated,
+		onResize: onListResizeObserved,
+		children: ({ ref }) => /* @__PURE__ */ jsxs("div", {
+			...nativeProps,
+			"data-slot": "virtual-list",
+			className: rootClassName,
+			style,
+			onScroll: handleListScroll,
+			ref,
+			onKeyDown,
+			tabIndex: focusable ? 0 : -1,
+			children: [
+				header,
+				hasItems ? /* @__PURE__ */ jsx("div", {
+					"data-slot": "virtual-list-items",
+					ref: itemsElRef,
+					className: itemsClassName,
+					style: itemsContainerStyle,
+					children: /* @__PURE__ */ jsx(VirtualListContext.Provider, {
+						value: imperativeApi,
+						children: /* @__PURE__ */ jsx(ColumnsContext.Provider, {
+							value: columnsContextValue,
+							children: createElement(visibleItemsTag, {
+								"data-slot": "virtual-list-visible-items",
+								style: virtual ? VIRTUAL_VISIBLE_ITEMS_STYLE : NON_VIRTUAL_VISIBLE_ITEMS_STYLE,
+								...visibleItemsProps
+							}, ...renderedKeptBefore, ...renderedVisibleItems, ...renderedKeptAfter)
+						})
+					})
+				}, "items") : /* @__PURE__ */ jsx("div", {
+					"data-slot": "virtual-list-empty",
+					className: cn("r-virtual-list__empty", emptyCentered && "r-virtual-list__empty--center"),
+					children: emptyNode
+				}, "empty"),
+				footerNode,
+				paddingBottom ? /* @__PURE__ */ jsx("div", { style: { paddingBottom } }) : null,
+				footerAfterBottomPadding
+			]
+		})
+	});
+}
+//#endregion
 //#region src/components/tasks/tasks-panel.recipe.ts
 const tasksPanel = tv({ slots: {
 	root: ["flex min-h-0 min-w-0 flex-1 flex-col", "bg-layer-canvas text-foreground"],
@@ -16688,4 +18827,4 @@ function ThemeProvider({ mode, defaultMode = "light", onModeChange, storageKey,
 	});
 }
 //#endregion
-export { ActivityInboxControls, ActivityInboxLoadingMore, ActivityInboxPanel, ActivityInboxSelectionCount, ActivityInboxSelectionToolbar, ActivityInboxSidebar, ActivityInboxViewport, AlertDialog, AlertDialogAction, AlertDialogBody, AlertDialogCancel, AlertDialogClose, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AppRailFooter, AppRailHeader, AppRailItem, AppRailItemAttention, AppRailItemBadge, AppRailItemIcon, AppRailItemIndicator, AppRailItemLabel, AppRailNav, AppRailRoot, AppShellMainSlot, AppShellOverlaySlot, AppShellPanelSlot, AppShellRailSlot, AppShellRoot, AppShellSidebarSlot, AppShellSidebarTrigger, Avatar, AvatarBadge, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarImage, Badge, Banner, BannerAction, BannerDescription, BannerTitle, Button, Card, CardContent, CardDescription, CardFooter, CardHeader, CardLeading, CardTitle, CardTrailing, ChatIcon, Checkbox, CheckboxIndicator, CodeBlock, CodeBlockAction, CodeBlockActions, CodeBlockBody, CodeBlockHeader, CodeBlockTitle, Combobox, ComboboxChip, ComboboxChipRemove, ComboboxChips, ComboboxClear, ComboboxCollection, ComboboxContent, ComboboxControl, ComboboxEmpty, ComboboxGroup, ComboboxGroupLabel, ComboboxHeader, ComboboxInput, ComboboxInputGroup, ComboboxItem, ComboboxItemIndicator, ComboboxLabel, ComboboxList, ComboboxPopup, ComboboxPortal, ComboboxRow, ComboboxSeparator, ComboboxTrigger, ComboboxTriggerCount, ComboboxTriggerIndicator, ComboboxValue, Composer, ComposerActions, ComposerAttachment, ComposerAttachmentBody, ComposerAttachmentFailedOverlay, ComposerAttachmentFile, ComposerAttachmentImage, ComposerAttachmentMeta, ComposerAttachmentRemove, ComposerAttachmentTitle, ComposerAttachmentUploadProgressBar, ComposerAttachmentUploadingOverlay, ComposerAttachments, ComposerAttachmentsScrollArea, ComposerDropOverlay, ComposerDropOverlayLabel, ComposerDropOverlayPrompt, ComposerIconButton, ComposerInput, ComposerMeta, ComposerRoot, ComposerSubmit, ComposerSuggestionAside, ComposerSuggestionContent, ComposerSuggestionGroup, ComposerSuggestionGroupLabel, ComposerSuggestionIcon, ComposerSuggestionList, ComposerSuggestionMeta, ComposerSuggestionOption, ComposerSuggestionTitle, ComposerToolbar, ComposerToolbarLabel, ContextMenu, ContextMenuCheckboxItem, ContextMenuCheckboxItemIndicator, ContextMenuContent, ContextMenuFooter, ContextMenuItem, ContextMenuItemLabel, ContextMenuLabel, ContextMenuPopup, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuRadioItemIndicator, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSubmenu, ContextMenuSubmenuTrigger, ContextMenuTrigger, ConversationPanelBody, ConversationPanelContent, ConversationPanelEmptyState, ConversationPanelEmptyStateBrand, ConversationPanelEmptyStateBrandMark, ConversationPanelFooter, ConversationPanelRoot, ConversationPanelTabs, CopyableCode, CopyableCodeAction, CopyableCodeRoot, DescriptionDetails, DescriptionItem, DescriptionList, DescriptionTerm, Dialog, DialogBody, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogNav, DialogOverlay, DialogPortal, DialogSurface, DialogTitle, DialogTrigger, DirectMessageIcon, Drawer, DrawerActions, DrawerBody, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuCheckboxItemIndicator, DropdownMenuContent, DropdownMenuFooter, DropdownMenuItem, DropdownMenuItemCount, DropdownMenuItemLabel, DropdownMenuLabel, DropdownMenuPopup, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuRadioItemIndicator, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSubmenu, DropdownMenuSubmenuTrigger, DropdownMenuTrigger, EmptyState, EmptyStateActions, EmptyStateContent, EmptyStateDescription, EmptyStateIcon, EmptyStateTitle, Field, FieldControl, FieldDescription, FieldError, FieldItem, FieldLabel, FieldValidity, FileAction, FileActions, FileContent, FileImage, FileMeta, FileMetaItem, FileName, FilePreview, FilePreviewBadge, FilePreviewCode, FilePreviewDocument, FilePreviewFile, FilePreviewMedia, FileRow, FileRowOpen, FileThumbnail, FilesList, FilesPanel, FilesViewport, FloatButton, FloatButtonGroup, FormSection, IconTile, InboxItem, InboxItemActions, InboxItemBody, InboxItemContent, InboxItemContext, InboxItemHeading, InboxItemHoverTarget, InboxItemLeading, InboxItemMarks, InboxItemMessage, InboxItemMetadata, InboxItemSelection, InboxItemSender, InboxItemSubtitle, InboxItemTimestamp, InboxItemTitle, InboxItemTrailing, InboxItemTrigger, InlineCode, Input, InputGroup, InputGroupAddon, InputGroupInput, Kbd, KbdGroup, Label, LabelAsterisk, LabelOptional, LabelSub, LegacyTaskPanelActions, LegacyTaskPanelBody, LegacyTaskPanelField, LegacyTaskPanelFieldLabel, LegacyTaskPanelFieldText, LegacyTaskPanelFieldTitle, LegacyTaskPanelHeader, LegacyTaskPanelIcon, LegacyTaskPanelMeta, LegacyTaskPanelMetaLabel, LegacyTaskPanelMetaRow, LegacyTaskPanelMetaValue, LegacyTaskPanelRoot, LegacyTaskPanelSection, LegacyTaskPanelStatus, LegacyTaskPanelTitle, LegacyTaskPanelTitleMeta, Lightbox, LightboxActions, LightboxClose, LightboxContent, LightboxHeader, LightboxHeaderLabel, LightboxHeaderMeta, LightboxInfoActions, LightboxInfoBar, LightboxInfoDock, LightboxInfoTitle, LightboxMedia, LightboxNavigationButton, LightboxPortal, LightboxStage, LightboxThumbnail, LightboxThumbnailStrip, LightboxTitle, LightboxToolbar, LightboxTrigger, ListRow, ListRowBody, ListRowBottom, ListRowChevron, ListRowDescription, ListRowGroup, ListRowIcon, ListRowMeta, ListRowTitle, ListRowTop, ListRowValue, LiveAgentActivityBar, LiveAgentActivityBarAvatar, LiveAgentActivityBarContent, LiveAgentActivityBarRow, LiveAgentActivityBarStatus, LiveAgentActivityBarText, MarkdownBlockquote, MarkdownCell, MarkdownCheckbox, MarkdownHeaderCell, MarkdownHeading, MarkdownImage, MarkdownInlineCode, MarkdownLink, MarkdownList, MarkdownListItem, MarkdownMark, MarkdownOrderedList, MarkdownParagraph, MarkdownRule, MarkdownTable, MarkdownTableRow, MarkdownTableScroll, MessageActionCard, MessageActionCardActions, MessageActionCardActionsNote, MessageActionCardCollapseTrigger, MessageActionCardCompletion, MessageActionCardContent, MessageActionCardHeader, MessageActionCardHeaderDescription, MessageActionCardHeaderIcon, MessageActionCardHeaderStatus, MessageActionCardHeaderTitle, MessageActionCardHint, MessageActionCardHintLabel, MessageActionCardNotice, MessageActionCardProperties, MessageActionCardProperty, MessageActionCardPropertyLabel, MessageActionCardPropertyValue, MessageActionCardScope, MessageActionCardScopeDescription, MessageActionCardScopeList, MessageActionCardScopeListLabel, MessageActionCardScopeListViewport, MessageActionCardScopeName, MessageActionCardStatus, MessageAttachmentAction, MessageAttachmentCard, MessageAttachmentCommentSummary, MessageAttachmentDiffAddition, MessageAttachmentDiffDeletion, MessageAttachmentDiffSummary, MessageAttachmentGroup, MessageAttachmentMeta, MessageAttachmentMetaEnd, MessageAttachmentMetaStart, MessageAttachmentSummary, MessageAttachmentTitle, MessageEmbed, MessageEmbedContent, MessageEmbedFooter, MessageEmbedHeader, MessageForwardedBundle, MessageForwardedBundleAttachment, MessageForwardedBundleAttachmentMeta, MessageForwardedBundleAttachmentName, MessageForwardedBundleAttachments, MessageForwardedBundleFooter, MessageForwardedBundleFooterAction, MessageForwardedBundleGallery, MessageForwardedBundleGalleryTile, MessageForwardedBundleHeader, MessageForwardedBundleHeaderContent, MessageForwardedBundleHeaderCount, MessageForwardedBundleHeaderLabel, MessageForwardedBundleItem, MessageForwardedBundleItemAuthor, MessageForwardedBundleItemContent, MessageForwardedBundleItemMeta, MessageForwardedBundleItems, MessageForwardedBundleSource, MessageForwardedBundleSourceLabel, MessageIcon, MessageImageGallery, MessageImageGalleryAction, MessageImageGalleryItem, MessageImageGalleryMedia, MessageImageGalleryOverlay, MessageImageGalleryPreview, MessageImageGalleryRow, MessageItem, MessageItemAttachments, MessageItemAvatarSlot, MessageItemBadge, MessageItemBadgeSeparator, MessageItemBody, MessageItemContent, MessageItemContinuationTime, MessageItemEdited, MessageItemEmbedded, MessageItemFooter, MessageItemGutter, MessageItemHeader, MessageItemInlineStatus, MessageItemMeta, MessageItemReadReceipt, MessageItemSavedIndicator, MessageItemSearchMatch, MessageItemSender, MessageItemSenderBadges, MessageItemSenderButton, MessageItemSenderGroup, MessageItemTime, MessageItemToolbar, MessageItemToolbarButton, MessageItemTranslationAction, MessageItemTranslationFailedStatus, MessageItemTranslationOriginal, MessageItemTranslationOriginalLabel, MessageItemTranslationProgressTrack, MessageItemTranslationRetryAction, MessageItemTranslationStatus, MessageList, MessageListDateDivider, MessageListHistoryLimited, MessageListNotice, MessageMultiSelect, MessageMultiSelectCheckbox, MessageMultiSelectToolbar, MessageQuotedPreview, MessageQuotedPreviewAttachment, MessageQuotedPreviewAttachments, MessageQuotedPreviewAuthor, MessageQuotedPreviewAuthorMeta, MessageQuotedPreviewAuthorName, MessageQuotedPreviewChannel, MessageQuotedPreviewContent, MessageQuotedPreviewHeader, MessageQuotedPreviewLoading, MessageQuotedPreviewText, MessageQuotedPreviewThread, MessageQuotedPreviewTimestamp, MessageQuotedPreviewUnavailable, MessageReactionAddButton, MessageReactionChip, MessageReactionCount, MessageReactionErrorIndicator, MessageReactionGlyph, MessageReactionPickerContent, MessageReactionPickerStatic, MessageReactionQuickButton, MessageReactionQuickRow, MessageReactionTooltipContent, MessageReactionTooltipMeta, MessageReactionTooltipName, MessageReactionTooltipNameText, MessageReactionTooltipNames, MessageReactionTooltipSeparator, MessageReferenceChip, MessageReferenceIndicator, MessageReferenceLabel, MessageReferencePending, MessageReferenceText, MessageReferenceUnavailable, MessageReplies, MessageRepliesItem, MessageRepliesItemContent, MessageRepliesItemSender, MessageRepliesItemTime, MessageRepliesSummary, MessageRepliesSummaryItem, MessageTextSelectionToolbar, MessageTextSelectionToolbarButton, MessageTextSelectionToolbarSeparator, MessageVideoPreview, MessageVideoPreviewAction, MessageVideoPreviewFailureAction, MessageVideoPreviewFailureContent, MessageVideoPreviewFailureIcon, MessageVideoPreviewFailureTitle, MessageVideoPreviewFallback, MessageVideoPreviewMedia, MobileNavItem, MobileNavLabel, MobileNavRoot, NotificationCenter, NotificationCenterActionButton, NotificationCenterCount, NotificationCenterEmptyState, NotificationCenterHeader, NotificationCenterItem, NotificationCenterItemActions, NotificationCenterItemBody, NotificationCenterItemContent, NotificationCenterItemIcon, NotificationCenterItemRow, NotificationCenterItemTitle, NotificationCenterList, NotificationCenterPopup, NotificationCenterScroller, NotificationCenterTitle, NotificationCenterTrigger, OtterIndicator, Panel, PanelAction, PanelActions, PanelActivity, PanelBody, PanelFooter, PanelHeader, PanelHeaderContent, PanelHeaderIcon, PanelHeaderRoot, PanelHeading, PanelMeta, PanelNotice, PanelNoticeActions, PanelNoticeContent, PanelScrollContent, PanelScrollViewport, PanelSection, PanelSectionHeader, PanelStatus, PanelTitle, PanelToggleAction, PickerTriggerButton, Popover, PopoverArrow, PopoverBackdrop, PopoverClose, PopoverContent, PopoverDescription, PopoverHeader, PopoverPopup, PopoverPortal, PopoverSeparator, PopoverTitle, PopoverTrigger, PopoverViewport, PreviewCard, PreviewCardArrow, PreviewCardContent, PreviewCardDescription, PreviewCardHeader, PreviewCardPopup, PreviewCardPortal, PreviewCardSeparator, PreviewCardTitle, PreviewCardTrigger, ProfilePanel, ProfilePanelBody, ProfilePanelHeader, ProfilePanelHeaderContent, ProfilePanelSection, Progress, ProgressHeader, ProgressIndicator, ProgressLabel, ProgressTrack, ProgressValue, RadioGroup, RadioGroupIndicator, RadioGroupItem, RaftLogo, RaftLogoLockup, RaftWordmark, ResizableGroup, ResizableHandle, ResizablePanel, SINGLE_IMAGE_MAX_HEIGHT, SINGLE_IMAGE_MAX_WIDTH, ScrollArea, ScrollAreaContent, ScrollAreaCorner, ScrollAreaScrollbar, ScrollAreaThumb, ScrollAreaViewport, SearchEntityResult, SearchEntityResultActivity, SearchEntityResultContent, SearchEntityResultDescription, SearchEntityResultHeader, SearchEntityResultIcon, SearchEntityResultLeading, SearchEntityResultTitle, SearchMessageResult, SearchMessageResultBody, SearchMessageResultHeader, SearchMessageResultMatch, SearchMessageResultMeta, SearchMessageResultSender, SearchMessageResultThreadMeta, SearchMessageResultTimestamp, SearchResultsList, SearchResultsSection, SearchResultsSectionHeading, SearchResultsSummary, SearchShellFilters, SearchShellRoot, SearchShellViewport, SearchThreadMessageResult, SearchThreadResult, SearchThreadResultHeader, SearchThreadResultMessages, SearchThreadResultMeta, SearchThreadResultTimestamp, SearchThreadResultTitle, SearchTrigger, SearchTriggerLabel, SearchTriggerShortcut, SegmentedControl, SegmentedControlCount, SegmentedControlItem, SegmentedControlLabel, Select, SelectArrow, SelectContent, SelectGroup, SelectGroupLabel, SelectIcon, SelectItem, SelectItemDescription, SelectItemIndicator, SelectItemLeading, SelectItemText, SelectLabel, SelectList, SelectPopup, SelectPortal, SelectScrollDownArrow, SelectScrollUpArrow, SelectSeparator, SelectTrigger, SelectValue, Separator, SidebarBody, SidebarContent, SidebarControl, SidebarGroupLabel, SidebarHeader, SidebarHeaderTitle, SidebarItem, SidebarItemAside, SidebarItemChannelIcon, SidebarItemContent, SidebarItemCount, SidebarItemCountSeparator, SidebarItemIcon, SidebarItemIndicator, SidebarItemMeta, SidebarItemMetaIcon, SidebarItemStatus, SidebarItemSubtitle, SidebarItemThreadCount, SidebarItemTitle, SidebarList, SidebarLiveActivity, SidebarMenu, SidebarMenuAside, SidebarMenuCount, SidebarMenuIcon, SidebarMenuTitle, SidebarRoot, SidebarSection, SidebarSectionAttention, SidebarSectionChevron, SidebarSectionControl, SidebarSectionControls, SidebarSectionCount, SidebarSectionDisclosure, SidebarSectionEmpty, SidebarSectionHeader, SidebarSectionTitle, SidebarSectionTrailing, Skeleton, SortableComposerAttachment, SortableComposerAttachments, SortableComposerAttachmentsScroll, SortableTabsList, SortableTabsTab, Spinner, Status, Step, Steps, Switch, SwitchThumb, SystemMessage, SystemMessageContent, SystemMessageGroup, SystemMessageGroupChevron, SystemMessageGroupDisclosure, SystemMessageGroupHeader, SystemMessageGroupPanel, SystemMessageGroupSummary, SystemMessageTime, TASK_STATUS_IDS, Table, TableBody, TableCaption, TableCell, TableColgroup, TableColumn, TableHead, TableHeader, TableRow, Tabs, TabsLabel, TabsList, TabsPanel, TabsTab, TaskBoardColumn, TaskBoardColumnBadge, TaskBoardColumnChevron, TaskBoardColumnCount, TaskBoardColumnEmpty, TaskBoardColumnEmptyAllowed, TaskBoardColumnEmptyBlocked, TaskBoardColumnEmptyIdle, TaskBoardColumnHeading, TaskBoardColumnItems, TaskBoardColumnPanel, TaskBoardColumnTrigger, TaskBoardRoot, TaskCard, TaskCardBody, TaskCardChannel, TaskCardDescription, TaskCardLegacy, TaskCardMeta, TaskCardNumber, TaskCardRow, TaskCardStatus, TaskCardTitle, TaskChip, TaskClosedIcon, TaskDndProvider, TaskDoneIcon, TaskDragOverlay, TaskDraggable, TaskDropPlaceholder, TaskDropZone, TaskInProgressIcon, TaskInReviewIcon, TaskListRoot, TaskLoadingList, TaskLoadingRow, TaskSection, TaskSectionBadge, TaskSectionChevron, TaskSectionCount, TaskSectionEmpty, TaskSectionHeading, TaskSectionItems, TaskSectionPanel, TaskSectionTrigger, TaskStatusBadge, TaskStatusIcon, TaskTodoIcon, TasksPanelEmpty, TasksPanelRoot, TasksPanelToolbar, TasksPanelToolbarFilters, TasksPanelToolbarGroup, TasksPanelToolbarLabel, TasksPanelToolbarNewTask, TasksPanelToolbarView, TasksPanelViewport, Text, TextHeading, TextLink, TextMono, TextSans, Textarea, TextareaCounter, TextareaGroup, ThemeProvider, ThreadIcon, ThreadPanelActions, ThreadPanelBody, ThreadPanelContent, ThreadPanelFooter, ThreadPanelHeader, ThreadPanelOriginalMessage, ThreadPanelReplyCount, ThreadPanelReplySummary, ThreadPanelRoot, ThreadPanelSearch, ThreadPanelSearchCount, ThreadPanelSearchTrailing, ThreadPanelTitle, ThreadPanelTitleMeta, Timeline, TimelineContent, TimelineItem, TimelineTime, TimelineTitle, ToastAction, ToastActions, ToastArrow, ToastBody, ToastClose, ToastContent, ToastDescription, ToastIcon, ToastPortal, ToastPositioner, ToastProgress, ToastProvider, ToastRoot, ToastTitle, ToastViewport, ToggleGroup, ToggleGroupItem, ToggleGroupLabel, Tooltip, TooltipContent, TooltipPortal, TooltipProvider, TooltipTrigger, buildMessageImageGalleryRows, buttonVariants, classifyMessageImageAspect, cn, createMessageTextSelectionAnchor, createToastManager, getTextSelectionFocusRect, installInputModality, taskStatusSoft, taskStatusStrong, textLinkVariants, toast, useComposerSuggestions, useOrderedTabs, useTheme, useToastManager };
+export { ActivityInboxControls, ActivityInboxLoadingMore, ActivityInboxPanel, ActivityInboxSelectionCount, ActivityInboxSelectionToolbar, ActivityInboxSidebar, ActivityInboxViewport, AlertDialog, AlertDialogAction, AlertDialogBody, AlertDialogCancel, AlertDialogClose, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AppRailFooter, AppRailHeader, AppRailItem, AppRailItemAttention, AppRailItemBadge, AppRailItemIcon, AppRailItemIndicator, AppRailItemLabel, AppRailNav, AppRailRoot, AppShellMainSlot, AppShellOverlaySlot, AppShellPanelSlot, AppShellRailSlot, AppShellRoot, AppShellSidebarSlot, AppShellSidebarTrigger, Avatar, AvatarBadge, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarImage, Badge, Banner, BannerAction, BannerDescription, BannerTitle, Button, Card, CardContent, CardDescription, CardFooter, CardHeader, CardLeading, CardTitle, CardTrailing, ChatIcon, Checkbox, CheckboxIndicator, CodeBlock, CodeBlockAction, CodeBlockActions, CodeBlockBody, CodeBlockHeader, CodeBlockTitle, Combobox, ComboboxChip, ComboboxChipRemove, ComboboxChips, ComboboxClear, ComboboxCollection, ComboboxContent, ComboboxControl, ComboboxEmpty, ComboboxGroup, ComboboxGroupLabel, ComboboxHeader, ComboboxInput, ComboboxInputGroup, ComboboxItem, ComboboxItemIndicator, ComboboxLabel, ComboboxList, ComboboxPopup, ComboboxPortal, ComboboxRow, ComboboxSeparator, ComboboxTrigger, ComboboxTriggerCount, ComboboxTriggerIndicator, ComboboxValue, Composer, ComposerActions, ComposerAttachment, ComposerAttachmentBody, ComposerAttachmentFailedOverlay, ComposerAttachmentFile, ComposerAttachmentImage, ComposerAttachmentMeta, ComposerAttachmentRemove, ComposerAttachmentTitle, ComposerAttachmentUploadProgressBar, ComposerAttachmentUploadingOverlay, ComposerAttachments, ComposerAttachmentsScrollArea, ComposerDropOverlay, ComposerDropOverlayLabel, ComposerDropOverlayPrompt, ComposerIconButton, ComposerInput, ComposerMeta, ComposerRoot, ComposerSubmit, ComposerSuggestionAside, ComposerSuggestionContent, ComposerSuggestionGroup, ComposerSuggestionGroupLabel, ComposerSuggestionIcon, ComposerSuggestionList, ComposerSuggestionMeta, ComposerSuggestionOption, ComposerSuggestionTitle, ComposerToolbar, ComposerToolbarLabel, ContextMenu, ContextMenuCheckboxItem, ContextMenuCheckboxItemIndicator, ContextMenuContent, ContextMenuFooter, ContextMenuItem, ContextMenuItemLabel, ContextMenuLabel, ContextMenuPopup, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuRadioItemIndicator, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSubmenu, ContextMenuSubmenuTrigger, ContextMenuTrigger, ConversationPanelBody, ConversationPanelContent, ConversationPanelEmptyState, ConversationPanelEmptyStateBrand, ConversationPanelEmptyStateBrandMark, ConversationPanelFooter, ConversationPanelRoot, ConversationPanelTabs, CopyableCode, CopyableCodeAction, CopyableCodeRoot, DescriptionDetails, DescriptionItem, DescriptionList, DescriptionTerm, Dialog, DialogBody, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogNav, DialogOverlay, DialogPortal, DialogSurface, DialogTitle, DialogTrigger, DirectMessageIcon, Drawer, DrawerActions, DrawerBody, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuCheckboxItemIndicator, DropdownMenuContent, DropdownMenuFooter, DropdownMenuItem, DropdownMenuItemCount, DropdownMenuItemLabel, DropdownMenuLabel, DropdownMenuPopup, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuRadioItemIndicator, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSubmenu, DropdownMenuSubmenuTrigger, DropdownMenuTrigger, EmptyState, EmptyStateActions, EmptyStateContent, EmptyStateDescription, EmptyStateIcon, EmptyStateTitle, Field, FieldControl, FieldDescription, FieldError, FieldItem, FieldLabel, FieldValidity, FileAction, FileActions, FileContent, FileImage, FileMeta, FileMetaItem, FileName, FilePreview, FilePreviewBadge, FilePreviewCode, FilePreviewDocument, FilePreviewFile, FilePreviewMedia, FileRow, FileRowOpen, FileThumbnail, FilesList, FilesPanel, FilesViewport, FloatButton, FloatButtonGroup, FormSection, IconTile, InboxItem, InboxItemActions, InboxItemBody, InboxItemContent, InboxItemContext, InboxItemHeading, InboxItemHoverTarget, InboxItemLeading, InboxItemMarks, InboxItemMessage, InboxItemMetadata, InboxItemSelection, InboxItemSender, InboxItemSubtitle, InboxItemTimestamp, InboxItemTitle, InboxItemTrailing, InboxItemTrigger, InlineCode, Input, InputGroup, InputGroupAddon, InputGroupInput, Kbd, KbdGroup, Label, LabelAsterisk, LabelOptional, LabelSub, LegacyTaskPanelActions, LegacyTaskPanelBody, LegacyTaskPanelField, LegacyTaskPanelFieldLabel, LegacyTaskPanelFieldText, LegacyTaskPanelFieldTitle, LegacyTaskPanelHeader, LegacyTaskPanelIcon, LegacyTaskPanelMeta, LegacyTaskPanelMetaLabel, LegacyTaskPanelMetaRow, LegacyTaskPanelMetaValue, LegacyTaskPanelRoot, LegacyTaskPanelSection, LegacyTaskPanelStatus, LegacyTaskPanelTitle, LegacyTaskPanelTitleMeta, Lightbox, LightboxActions, LightboxClose, LightboxContent, LightboxHeader, LightboxHeaderLabel, LightboxHeaderMeta, LightboxInfoActions, LightboxInfoBar, LightboxInfoDock, LightboxInfoTitle, LightboxMedia, LightboxNavigationButton, LightboxPortal, LightboxStage, LightboxThumbnail, LightboxThumbnailStrip, LightboxTitle, LightboxToolbar, LightboxTrigger, ListRow, ListRowBody, ListRowBottom, ListRowChevron, ListRowDescription, ListRowGroup, ListRowIcon, ListRowMeta, ListRowTitle, ListRowTop, ListRowValue, LiveAgentActivityBar, LiveAgentActivityBarAvatar, LiveAgentActivityBarContent, LiveAgentActivityBarRow, LiveAgentActivityBarStatus, LiveAgentActivityBarText, MarkdownBlockquote, MarkdownCell, MarkdownCheckbox, MarkdownHeaderCell, MarkdownHeading, MarkdownImage, MarkdownInlineCode, MarkdownLink, MarkdownList, MarkdownListItem, MarkdownMark, MarkdownOrderedList, MarkdownParagraph, MarkdownRule, MarkdownTable, MarkdownTableRow, MarkdownTableScroll, MessageActionCard, MessageActionCardActions, MessageActionCardActionsNote, MessageActionCardCollapseTrigger, MessageActionCardCompletion, MessageActionCardContent, MessageActionCardHeader, MessageActionCardHeaderDescription, MessageActionCardHeaderIcon, MessageActionCardHeaderStatus, MessageActionCardHeaderTitle, MessageActionCardHint, MessageActionCardHintLabel, MessageActionCardNotice, MessageActionCardProperties, MessageActionCardProperty, MessageActionCardPropertyLabel, MessageActionCardPropertyValue, MessageActionCardScope, MessageActionCardScopeDescription, MessageActionCardScopeList, MessageActionCardScopeListLabel, MessageActionCardScopeListViewport, MessageActionCardScopeName, MessageActionCardStatus, MessageAttachmentAction, MessageAttachmentCard, MessageAttachmentCommentSummary, MessageAttachmentDiffAddition, MessageAttachmentDiffDeletion, MessageAttachmentDiffSummary, MessageAttachmentGroup, MessageAttachmentMeta, MessageAttachmentMetaEnd, MessageAttachmentMetaStart, MessageAttachmentSummary, MessageAttachmentTitle, MessageEmbed, MessageEmbedContent, MessageEmbedFooter, MessageEmbedHeader, MessageForwardedBundle, MessageForwardedBundleAttachment, MessageForwardedBundleAttachmentMeta, MessageForwardedBundleAttachmentName, MessageForwardedBundleAttachments, MessageForwardedBundleFooter, MessageForwardedBundleFooterAction, MessageForwardedBundleGallery, MessageForwardedBundleGalleryTile, MessageForwardedBundleHeader, MessageForwardedBundleHeaderContent, MessageForwardedBundleHeaderCount, MessageForwardedBundleHeaderLabel, MessageForwardedBundleItem, MessageForwardedBundleItemAuthor, MessageForwardedBundleItemContent, MessageForwardedBundleItemMeta, MessageForwardedBundleItems, MessageForwardedBundleSource, MessageForwardedBundleSourceLabel, MessageIcon, MessageImageGallery, MessageImageGalleryAction, MessageImageGalleryItem, MessageImageGalleryMedia, MessageImageGalleryOverlay, MessageImageGalleryPreview, MessageImageGalleryRow, MessageItem, MessageItemAttachments, MessageItemAvatarSlot, MessageItemBadge, MessageItemBadgeSeparator, MessageItemBody, MessageItemContent, MessageItemContinuationTime, MessageItemEdited, MessageItemEmbedded, MessageItemFooter, MessageItemGutter, MessageItemHeader, MessageItemInlineStatus, MessageItemMeta, MessageItemReadReceipt, MessageItemSavedIndicator, MessageItemSearchMatch, MessageItemSender, MessageItemSenderBadges, MessageItemSenderButton, MessageItemSenderGroup, MessageItemTime, MessageItemToolbar, MessageItemToolbarButton, MessageItemTranslationAction, MessageItemTranslationFailedStatus, MessageItemTranslationOriginal, MessageItemTranslationOriginalLabel, MessageItemTranslationProgressTrack, MessageItemTranslationRetryAction, MessageItemTranslationStatus, MessageList, MessageListDateDivider, MessageListHistoryLimited, MessageListNotice, MessageMultiSelect, MessageMultiSelectCheckbox, MessageMultiSelectToolbar, MessageQuotedPreview, MessageQuotedPreviewAttachment, MessageQuotedPreviewAttachments, MessageQuotedPreviewAuthor, MessageQuotedPreviewAuthorMeta, MessageQuotedPreviewAuthorName, MessageQuotedPreviewChannel, MessageQuotedPreviewContent, MessageQuotedPreviewHeader, MessageQuotedPreviewLoading, MessageQuotedPreviewText, MessageQuotedPreviewThread, MessageQuotedPreviewTimestamp, MessageQuotedPreviewUnavailable, MessageReactionAddButton, MessageReactionChip, MessageReactionCount, MessageReactionErrorIndicator, MessageReactionGlyph, MessageReactionPickerContent, MessageReactionPickerStatic, MessageReactionQuickButton, MessageReactionQuickRow, MessageReactionTooltipContent, MessageReactionTooltipMeta, MessageReactionTooltipName, MessageReactionTooltipNameText, MessageReactionTooltipNames, MessageReactionTooltipSeparator, MessageReferenceChip, MessageReferenceIndicator, MessageReferenceLabel, MessageReferencePending, MessageReferenceText, MessageReferenceUnavailable, MessageReplies, MessageRepliesItem, MessageRepliesItemContent, MessageRepliesItemSender, MessageRepliesItemTime, MessageRepliesSummary, MessageRepliesSummaryItem, MessageTextSelectionToolbar, MessageTextSelectionToolbarButton, MessageTextSelectionToolbarSeparator, MessageVideoPreview, MessageVideoPreviewAction, MessageVideoPreviewFailureAction, MessageVideoPreviewFailureContent, MessageVideoPreviewFailureIcon, MessageVideoPreviewFailureTitle, MessageVideoPreviewFallback, MessageVideoPreviewMedia, MobileNavItem, MobileNavLabel, MobileNavRoot, NotificationCenter, NotificationCenterActionButton, NotificationCenterCount, NotificationCenterEmptyState, NotificationCenterHeader, NotificationCenterItem, NotificationCenterItemActions, NotificationCenterItemBody, NotificationCenterItemContent, NotificationCenterItemIcon, NotificationCenterItemRow, NotificationCenterItemTitle, NotificationCenterList, NotificationCenterPopup, NotificationCenterScroller, NotificationCenterTitle, NotificationCenterTrigger, OtterIndicator, Panel, PanelAction, PanelActions, PanelActivity, PanelBody, PanelFooter, PanelHeader, PanelHeaderContent, PanelHeaderIcon, PanelHeaderRoot, PanelHeading, PanelMeta, PanelNotice, PanelNoticeActions, PanelNoticeContent, PanelScrollContent, PanelScrollViewport, PanelSection, PanelSectionHeader, PanelStatus, PanelTitle, PanelToggleAction, PickerTriggerButton, Popover, PopoverArrow, PopoverBackdrop, PopoverClose, PopoverContent, PopoverDescription, PopoverHeader, PopoverPopup, PopoverPortal, PopoverSeparator, PopoverTitle, PopoverTrigger, PopoverViewport, PreviewCard, PreviewCardArrow, PreviewCardContent, PreviewCardDescription, PreviewCardHeader, PreviewCardPopup, PreviewCardPortal, PreviewCardSeparator, PreviewCardTitle, PreviewCardTrigger, ProfilePanel, ProfilePanelBody, ProfilePanelHeader, ProfilePanelHeaderContent, ProfilePanelSection, Progress, ProgressHeader, ProgressIndicator, ProgressLabel, ProgressTrack, ProgressValue, RadioGroup, RadioGroupIndicator, RadioGroupItem, RaftLogo, RaftLogoLockup, RaftWordmark, ResizableGroup, ResizableHandle, ResizablePanel, SINGLE_IMAGE_MAX_HEIGHT, SINGLE_IMAGE_MAX_WIDTH, ScrollArea, ScrollAreaContent, ScrollAreaCorner, ScrollAreaScrollbar, ScrollAreaThumb, ScrollAreaViewport, SearchEntityResult, SearchEntityResultActivity, SearchEntityResultContent, SearchEntityResultDescription, SearchEntityResultHeader, SearchEntityResultIcon, SearchEntityResultLeading, SearchEntityResultTitle, SearchMessageResult, SearchMessageResultBody, SearchMessageResultHeader, SearchMessageResultMatch, SearchMessageResultMeta, SearchMessageResultSender, SearchMessageResultThreadMeta, SearchMessageResultTimestamp, SearchResultsList, SearchResultsSection, SearchResultsSectionHeading, SearchResultsSummary, SearchShellFilters, SearchShellRoot, SearchShellViewport, SearchThreadMessageResult, SearchThreadResult, SearchThreadResultHeader, SearchThreadResultMessages, SearchThreadResultMeta, SearchThreadResultTimestamp, SearchThreadResultTitle, SearchTrigger, SearchTriggerLabel, SearchTriggerShortcut, SegmentedControl, SegmentedControlCount, SegmentedControlItem, SegmentedControlLabel, Select, SelectArrow, SelectContent, SelectGroup, SelectGroupLabel, SelectIcon, SelectItem, SelectItemDescription, SelectItemIndicator, SelectItemLeading, SelectItemText, SelectLabel, SelectList, SelectPopup, SelectPortal, SelectScrollDownArrow, SelectScrollUpArrow, SelectSeparator, SelectTrigger, SelectValue, Separator, SidebarBody, SidebarContent, SidebarControl, SidebarGroupLabel, SidebarHeader, SidebarHeaderTitle, SidebarItem, SidebarItemAside, SidebarItemChannelIcon, SidebarItemContent, SidebarItemCount, SidebarItemCountSeparator, SidebarItemIcon, SidebarItemIndicator, SidebarItemMeta, SidebarItemMetaIcon, SidebarItemStatus, SidebarItemSubtitle, SidebarItemThreadCount, SidebarItemTitle, SidebarList, SidebarLiveActivity, SidebarMenu, SidebarMenuAside, SidebarMenuCount, SidebarMenuIcon, SidebarMenuTitle, SidebarRoot, SidebarSection, SidebarSectionAttention, SidebarSectionChevron, SidebarSectionControl, SidebarSectionControls, SidebarSectionCount, SidebarSectionDisclosure, SidebarSectionEmpty, SidebarSectionHeader, SidebarSectionTitle, SidebarSectionTrailing, Skeleton, SortableComposerAttachment, SortableComposerAttachments, SortableComposerAttachmentsScroll, SortableTabsList, SortableTabsTab, Spinner, Status, Step, Steps, Switch, SwitchThumb, SystemMessage, SystemMessageContent, SystemMessageGroup, SystemMessageGroupChevron, SystemMessageGroupDisclosure, SystemMessageGroupHeader, SystemMessageGroupPanel, SystemMessageGroupSummary, SystemMessageTime, TASK_STATUS_IDS, Table, TableBody, TableCaption, TableCell, TableColgroup, TableColumn, TableHead, TableHeader, TableRow, Tabs, TabsLabel, TabsList, TabsPanel, TabsTab, TaskBoardColumn, TaskBoardColumnBadge, TaskBoardColumnChevron, TaskBoardColumnCount, TaskBoardColumnEmpty, TaskBoardColumnEmptyAllowed, TaskBoardColumnEmptyBlocked, TaskBoardColumnEmptyIdle, TaskBoardColumnHeading, TaskBoardColumnItems, TaskBoardColumnPanel, TaskBoardColumnTrigger, TaskBoardRoot, TaskCard, TaskCardBody, TaskCardChannel, TaskCardDescription, TaskCardLegacy, TaskCardMeta, TaskCardNumber, TaskCardRow, TaskCardStatus, TaskCardTitle, TaskChip, TaskClosedIcon, TaskDndProvider, TaskDoneIcon, TaskDragOverlay, TaskDraggable, TaskDropPlaceholder, TaskDropZone, TaskInProgressIcon, TaskInReviewIcon, TaskListRoot, TaskLoadingList, TaskLoadingRow, TaskSection, TaskSectionBadge, TaskSectionChevron, TaskSectionCount, TaskSectionEmpty, TaskSectionHeading, TaskSectionItems, TaskSectionPanel, TaskSectionTrigger, TaskStatusBadge, TaskStatusIcon, TaskTodoIcon, TasksPanelEmpty, TasksPanelRoot, TasksPanelToolbar, TasksPanelToolbarFilters, TasksPanelToolbarGroup, TasksPanelToolbarLabel, TasksPanelToolbarNewTask, TasksPanelToolbarView, TasksPanelViewport, Text, TextHeading, TextLink, TextMono, TextSans, Textarea, TextareaCounter, TextareaGroup, ThemeProvider, ThreadIcon, ThreadPanelActions, ThreadPanelBody, ThreadPanelContent, ThreadPanelFooter, ThreadPanelHeader, ThreadPanelOriginalMessage, ThreadPanelReplyCount, ThreadPanelReplySummary, ThreadPanelRoot, ThreadPanelSearch, ThreadPanelSearchCount, ThreadPanelSearchTrailing, ThreadPanelTitle, ThreadPanelTitleMeta, Timeline, TimelineContent, TimelineItem, TimelineTime, TimelineTitle, ToastAction, ToastActions, ToastArrow, ToastBody, ToastClose, ToastContent, ToastDescription, ToastIcon, ToastPortal, ToastPositioner, ToastProgress, ToastProvider, ToastRoot, ToastTitle, ToastViewport, ToggleGroup, ToggleGroupItem, ToggleGroupLabel, Tooltip, TooltipContent, TooltipPortal, TooltipProvider, TooltipTrigger, VirtualList, buildMessageImageGalleryRows, buttonVariants, classifyMessageImageAspect, cn, createMessageTextSelectionAnchor, createToastManager, getTextSelectionFocusRect, installInputModality, taskStatusSoft, taskStatusStrong, textLinkVariants, toast, useComposerSuggestions, useOrderedTabs, useTheme, useToastManager };