@botiverse/raft-ui 0.35.1 → 0.36.1

package/dist/{inbox-item-Cgu0ERol.mjs → inbox-item-BB6vO4PO.mjs}

@@ -14,13 +14,14 @@ import { ScrollArea } from "@base-ui/react/scroll-area";
 import { Avatar } from "@base-ui/react";
 import { Menu } from "@base-ui/react/menu";
 import { Popover } from "@base-ui/react/popover";
-import { PointerSensor, TouchSensor, useSensor } from "@dnd-kit/core";
+import { DragOverlay, KeyboardSensor, PointerSensor, TouchSensor, defaultDropAnimationSideEffects, useDndContext, useSensor, useSensors } from "@dnd-kit/core";
 import { PreviewCard } from "@base-ui/react/preview-card";
 import { Input } from "@base-ui/react/input";
 import { Radio } from "@base-ui/react/radio";
 import { RadioGroup } from "@base-ui/react/radio-group";
 import { Toggle } from "@base-ui/react/toggle";
 import { Toolbar } from "@base-ui/react/toolbar";
+import { sortableKeyboardCoordinates } from "@dnd-kit/sortable";
 //#region src/lib/decision-width.ts
 /**
 * The width of every decision dialog (dialog.md#variants): AlertDialog and a
@@ -2540,6 +2541,42 @@ function MobileNavLabel({ className, render, ...props }) {
 	});
 }
 //#endregion
+//#region src/lib/drag-escape.ts
+/** The drags in progress in each window, each with its own cancel. */
+const holds$1 = /* @__PURE__ */ new WeakMap();
+function onKeydown(event) {
+	if (event.key !== "Escape" && event.code !== "Escape") return;
+	const drags = holds$1.get(this);
+	if (!drags || drags.size === 0) return;
+	event.preventDefault();
+	event.stopImmediatePropagation();
+	for (const cancel of drags.values()) cancel(event);
+}
+function guard(win) {
+	let drags = holds$1.get(win);
+	if (!drags) {
+		drags = /* @__PURE__ */ new Map();
+		holds$1.set(win, drags);
+		win.addEventListener("keydown", onKeydown, { capture: true });
+	}
+	return drags;
+}
+if (typeof window !== "undefined") guard(window);
+/** A sensor's drag has started: Escape now cancels it, and only it. */
+function holdEscape(win, sensor, cancel) {
+	if (!win) return;
+	guard(win).set(sensor, cancel);
+}
+/** The sensor's drag is over: Escape behaves as it does everywhere else again. */
+function releaseEscape(win, sensor) {
+	if (!win) return;
+	holds$1.get(win)?.delete(sensor);
+}
+/** The window an event happened in. */
+function eventWindow(event) {
+	return (event?.target)?.ownerDocument?.defaultView ?? (typeof window === "undefined" ? null : window);
+}
+//#endregion
 //#region src/lib/touch-drag.ts
 /**
 * How a finger picks up something that can be dragged
@@ -2563,6 +2600,8 @@ function MobileNavLabel({ className, render, ...props }) {
 * touch on its distance and this sensor would never run.
 */
 const TOUCH_DRAG_HOLD_MS = 500;
+const TOUCH_DRAG_DISTANCE_PX = 10;
+const TOUCH_DRAG_TOLERANCE_PX = 10;
 const holds = /* @__PURE__ */ new WeakMap();
 function touchPoint(event) {
 	const touch = event.touches?.[0] ?? event.changedTouches?.[0];
@@ -2574,6 +2613,18 @@ function touchPoint(event) {
 function farther(from, to, limit) {
 	return Math.hypot(to.x - from.x, to.y - from.y) > limit;
 }
+/**
+* Once a pointer sensor's drag has started, Escape cancels it and reaches
+* nothing else (`drag-escape.ts`): no app handler on the window, the document
+* or an element hears it.
+*/
+function holdEscapeOnceActive(sensor) {
+	const self = sensor;
+	if (self.activated) holdEscape(eventWindow(self.props.event), sensor, () => self.handleCancel());
+}
+function releaseEscapeOf(sensor) {
+	releaseEscape(eventWindow(sensor.props.event), sensor);
+}
 var HoldThenMoveTouchSensorImpl = class extends TouchSensor {
 	static activators = TouchSensor.activators;
 	static setup() {
@@ -2592,6 +2643,10 @@ var HoldThenMoveTouchSensorImpl = class extends TouchSensor {
 		};
 		holds.set(this, state);
 	}
+	handleStart() {
+		super.handleStart();
+		holdEscapeOnceActive(this);
+	}
 	handleMove(event) {
 		const self = this;
 		const state = holds.get(this);
@@ -2619,22 +2674,33 @@ var HoldThenMoveTouchSensorImpl = class extends TouchSensor {
 		const state = holds.get(this);
 		if (state) clearTimeout(state.timer);
 		holds.delete(this);
+		releaseEscapeOf(this);
 		super.detach();
 	}
 };
 /** A TouchSensor that starts a drag on the first move after a still hold (see above). */
 const HoldThenMoveTouchSensor = HoldThenMoveTouchSensorImpl;
-/**
-* dnd-kit's PointerSensor for a mouse and a pen only: a finger's pointerdown is
-* left to `HoldThenMoveTouchSensor`.
-*/
-var MouseOnlyPointerSensor = class extends PointerSensor {
+var MouseOnlyPointerSensorImpl = class extends PointerSensor {
 	static activators = [{
 		eventName: "onPointerDown",
 		handler: (event, options) => event.nativeEvent.pointerType === "touch" ? false : PointerSensor.activators[0].handler(event, options)
 	}];
+	handleStart() {
+		super.handleStart();
+		holdEscapeOnceActive(this);
+	}
+	detach() {
+		releaseEscapeOf(this);
+		super.detach();
+	}
 };
 /**
+* dnd-kit's PointerSensor for a mouse and a pen only: a finger's pointerdown is
+* left to `HoldThenMoveTouchSensor`. While it holds a drag, Escape puts the
+* item back and reaches nothing else.
+*/
+const MouseOnlyPointerSensor = MouseOnlyPointerSensorImpl;
+/**
 * `useSensor(HoldThenMoveTouchSensor, …)` with the activation the sensor relies
 * on: no constraint dnd-kit would act on by itself, so only a move after the
 * hold starts the drag.
@@ -5753,6 +5819,728 @@ function MessageListJumpPillDismiss({ className, children, render, nativeButton,
 	});
 }
 //#endregion
+//#region src/components/drag/drag-announcements.ts
+function at({ place, position, count }) {
+	const where = position == null ? "" : count == null ? `position ${position}` : `position ${position} of ${count}`;
+	if (!place) return where;
+	return where ? `${place}, ${where}` : place;
+}
+function sentence(text) {
+	return /[.!?]$/.test(text) ? text : `${text}.`;
+}
+const DEFAULT_DRAG_MESSAGES = {
+	instructions: "To pick up an item, press Space. Use the arrow keys to move it, Space to drop it, Escape to cancel.",
+	pickedUp: ({ name, ...place }) => at(place) ? `Picked up ${name}. Over ${at(place)}.` : `Picked up ${name}.`,
+	over: ({ name: _name, ...place }) => `Over ${at(place)}.`,
+	notOver: () => "Not over a place. Dropping now cancels.",
+	refused: ({ name, place, reason }) => `${name} can't go to ${place}. ${reason}`,
+	dropped: ({ name, ...place }) => `Dropped ${name} in ${at(place)}.`,
+	cancelled: ({ name, ...place }) => at(place) ? `Cancelled. ${name} is back in ${at(place)}.` : `Cancelled. ${name} is back.`,
+	refusedDrop: ({ reason, ...rest }) => `${sentence(reason)} ${DEFAULT_DRAG_MESSAGES.cancelled(rest)}`
+};
+/** Merges your messages over the English defaults. */
+function dragMessages(messages) {
+	return messages ? {
+		...DEFAULT_DRAG_MESSAGES,
+		...messages
+	} : DEFAULT_DRAG_MESSAGES;
+}
+/**
+* dnd-kit `announcements` that speak by name, from your names and places,
+* in your language. Pass them with `dragInstructions` as a `DndContext`'s
+* `accessibility`, or to `TaskDndProvider`'s.
+*/
+function createDragAnnouncements(source, messages) {
+	const say = dragMessages(messages);
+	let lastPlace = null;
+	const placeKey = (place) => place ? JSON.stringify(place) : null;
+	const describeOver = (name, activeId, overId) => {
+		if (overId == null) {
+			lastPlace = null;
+			return say.notOver({ name });
+		}
+		const refused = source.refusal?.(activeId, overId);
+		if (refused) {
+			lastPlace = null;
+			return say.refused({
+				name,
+				...refused
+			});
+		}
+		if (!source.place) return void 0;
+		const place = source.place(activeId, overId);
+		if (!place) {
+			lastPlace = null;
+			return say.notOver({ name });
+		}
+		const key = placeKey(place);
+		if (key === lastPlace) return void 0;
+		lastPlace = key;
+		return say.over({
+			name,
+			...place
+		});
+	};
+	const named = (speak) => (event) => {
+		const name = source.name(event.active.id);
+		return name ? speak(name, event) : void 0;
+	};
+	return {
+		onDragStart: named((name, { active }) => {
+			const home = source.place?.(active.id, null);
+			lastPlace = placeKey(home);
+			return say.pickedUp({
+				name,
+				...home
+			});
+		}),
+		onDragOver: named((name, { active, over }) => describeOver(name, active.id, over?.id ?? null)),
+		onDragMove: () => void 0,
+		onDragEnd: named((name, { active, over }) => {
+			const refused = over == null ? null : source.refusal?.(active.id, over.id);
+			if (over != null && !refused && !source.place) return void 0;
+			const place = over == null || refused ? null : source.place?.(active.id, over.id);
+			if (place) return say.dropped({
+				name,
+				...place
+			});
+			const home = source.place?.(active.id, null);
+			return refused ? say.refusedDrop({
+				name,
+				reason: refused.reason,
+				...home
+			}) : say.cancelled({
+				name,
+				...home
+			});
+		}),
+		onDragCancel: named((name, { active }) => say.cancelled({
+			name,
+			...source.place?.(active.id, null)
+		}))
+	};
+}
+/** Announcements that say nothing, for a surface that announces on its own or has no names. */
+const SILENT_DRAG_ANNOUNCEMENTS = {
+	onDragStart: () => void 0,
+	onDragMove: () => void 0,
+	onDragOver: () => void 0,
+	onDragEnd: () => void 0,
+	onDragCancel: () => void 0
+};
+/** dnd-kit `screenReaderInstructions`: Space, not Enter, in your language. */
+function dragInstructions(messages) {
+	return { draggable: dragMessages(messages).instructions };
+}
+//#endregion
+//#region src/components/drag/drag.recipe.ts
+/**
+* The lift look, for a copy drawn outside `DragLift`: an opaque popover
+* surface, `shadow-float` and the `line-seam` ring. No scale, no tilt.
+*/
+const LIFT_CLASS = "bg-layer-popover shadow-float ring-1 ring-line-seam";
+const drag = tv$1({
+	slots: {
+		lift: [
+			"pointer-events-none size-full",
+			"rounded-control",
+			LIFT_CLASS
+		],
+		placeholder: [
+			"pointer-events-none box-border",
+			"rounded-control",
+			"border-[1.5px] border-dashed border-line-strong bg-fill-subtle"
+		],
+		hint: [
+			"pointer-events-none fixed top-0 left-0 z-70 max-w-80",
+			"rounded-chip px-2 py-1",
+			"font-sans text-caption",
+			"bg-layer-hud text-foreground-on-hud shadow-float ring-1 ring-line-seam"
+		]
+	},
+	variants: { opaque: { true: { placeholder: ["bg-layer-canvas", "bg-[linear-gradient(var(--fill-subtle),var(--fill-subtle))]"] } } }
+});
+//#endregion
+//#region src/components/drag/drag-lift.tsx
+/**
+* A drag settling (motion.md, `motion-drag-settle-*`): the lifted copy
+* gliding into its place on a drop or back home on a cancel, siblings sliding
+* apart to open the place, and a layout reflowing on a drop.
+*/
+const DRAG_SETTLE = {
+	duration: 160,
+	easing: "cubic-bezier(0.25, 1, 0.5, 1)"
+};
+/** For `useSortable({ transition })`: siblings slide with the same token. */
+const DRAG_SIBLING_TRANSITION = {
+	duration: DRAG_SETTLE.duration,
+	easing: DRAG_SETTLE.easing
+};
+/** The item a drag came from, while nothing else has taken its place (`data-drag-origin`). */
+const ORIGIN_OPACITY = .4;
+/** Auto-scroll starts this close to the edge of anything that scrolls. */
+const DRAG_AUTO_SCROLL_ZONE_PX = 48;
+/** How far a keyboard drag sets the copy off its place, so the place's dashed outline shows. */
+const DRAG_KEYBOARD_OFFSET_PX = 6;
+const hideActiveWhileGliding = defaultDropAnimationSideEffects({ styles: { active: { opacity: "0" } } });
+/**
+* Drop: the copy glides into its place. Cancel: it glides back home. While
+* it glides, the item it will become stays hidden, then appears there.
+*/
+const DROP_GLIDE = {
+	duration: DRAG_SETTLE.duration,
+	easing: DRAG_SETTLE.easing,
+	sideEffects: (parameters) => {
+		const restore = hideActiveWhileGliding(parameters);
+		const copy = parameters.dragOverlay.node.querySelector("[data-slot=drag-lift]");
+		if (copy?.style.translate) {
+			copy.style.transition = `translate ${DRAG_SETTLE.duration}ms ${DRAG_SETTLE.easing}`;
+			copy.style.translate = "0px 0px";
+		}
+		return restore;
+	}
+};
+const OVERLAY_STYLE = { pointerEvents: "none" };
+const REDUCED_MOTION = "(prefers-reduced-motion: reduce)";
+function subscribeReducedMotion(listener) {
+	if (typeof window === "undefined" || typeof window.matchMedia !== "function") return () => {};
+	const query = window.matchMedia(REDUCED_MOTION);
+	query.addEventListener("change", listener);
+	return () => query.removeEventListener("change", listener);
+}
+function reducedMotion() {
+	return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia(REDUCED_MOTION).matches;
+}
+/**
+* The sibling transition for `useSortable({ transition })`: the drag-settle
+* slide, or none with `prefers-reduced-motion`.
+*/
+function useDragSiblingTransition() {
+	return useSyncExternalStore(subscribeReducedMotion, reducedMotion, () => false) ? null : DRAG_SIBLING_TRANSITION;
+}
+const KEYBOARD_OFFSET = `6px 6px`;
+function isKeyboardEvent(event) {
+	return typeof KeyboardEvent !== "undefined" && event instanceof KeyboardEvent;
+}
+/**
+* For a compact proxy (a section's head, at most 240px wide): the grab point
+* is kept, but pulled to within `inset` of the proxy's end, so the hand never
+* holds empty air beside it. A constant shift: the copy still tracks 1:1.
+*/
+function keepGrabInside(proxyWidth, inset = 20) {
+	return ({ transform, activatorEvent, activeNodeRect }) => {
+		if (!activeNodeRect || !activatorEvent) return transform;
+		const point = eventPoint(activatorEvent);
+		if (!point) return transform;
+		const grabX = point.x - activeNodeRect.left;
+		const max = proxyWidth - inset;
+		return grabX > max ? {
+			...transform,
+			x: transform.x + (grabX - max)
+		} : transform;
+	};
+}
+function eventPoint(event) {
+	if ("clientX" in event && typeof event.clientX === "number") {
+		const pointerEvent = event;
+		return {
+			x: pointerEvent.clientX,
+			y: pointerEvent.clientY
+		};
+	}
+	const touch = event.touches?.[0] ?? event.changedTouches?.[0];
+	return touch ? {
+		x: touch.clientX,
+		y: touch.clientY
+	} : null;
+}
+/**
+* Cancels the drag in progress, whichever sensor holds it. Every dnd-kit
+* sensor (and so every sensor of `useDragSensors`) puts the item back when the
+* window is resized, so this sends the window a `resize`: unlike a synthetic
+* Escape, no app's own Escape handler (a dialog, a panel, a popover) hears it.
+*/
+function cancelDrag(win = window) {
+	win.dispatchEvent(new Event("resize"));
+}
+/**
+* Above every raft-ui layer (popovers 50, a stacked dialog 60, toasts and the
+* lightbox 70) and an app's own top layers: the copy in the hand is always on
+* top. dnd-kit's own default.
+*/
+const DRAG_LIFT_Z_INDEX = 999;
+const noSubscribe = () => () => {};
+const clientBody = () => document.body;
+const serverBody = () => null;
+/**
+* For a component whose copy goes to `document.body` unless it is told
+* otherwise: `undefined` is the body (once on the client, so hydration
+* matches), `null` is in place, and an element is that element.
+*/
+function useLiftContainer(container) {
+	const body = useSyncExternalStore(noSubscribe, clientBody, serverBody);
+	return container === void 0 ? body : container;
+}
+/**
+* The copy of a dragged item that follows the hand
+* (design/patterns/drag-and-drop.md#what-follows-the-hand): an opaque popover
+* surface with `shadow-float` and a `line-seam` ring, no scale and no tilt,
+* 1:1 with the pointer from the grab point, never clamped to its container and
+* never held to one axis. On a drop it glides into its place, and on a cancel
+* back home (160ms, `motion-drag-settle-*`; none with reduced motion).
+*
+* While something is lifted it also sets the grabbing cursor, cancels the
+* drag when the window loses focus or the tab is hidden, and scrolls an area
+* the pointer is near the edge of. Render it inside the `DndContext`.
+*/
+function DragLift({ children, className, style, modifiers, autoScroll = true, container, zIndex = 999 }) {
+	const { lift } = drag();
+	const { resolvedMode } = useTheme();
+	const reduced = useSyncExternalStore(subscribeReducedMotion, reducedMotion, () => false);
+	const { activatorEvent } = useDndContext();
+	const liftStyle = useMemo(() => isKeyboardEvent(activatorEvent) ? {
+		translate: KEYBOARD_OFFSET,
+		...style
+	} : style, [activatorEvent, style]);
+	const overlay = /* @__PURE__ */ jsx(DragOverlay, {
+		dropAnimation: reduced ? null : DROP_GLIDE,
+		modifiers,
+		zIndex,
+		style: OVERLAY_STYLE,
+		children: children == null || children === false ? null : /* @__PURE__ */ jsx("div", {
+			className: "size-full",
+			children: /* @__PURE__ */ jsx("div", {
+				"data-slot": "drag-lift",
+				className: lift({ className }),
+				style: liftStyle,
+				children
+			})
+		})
+	});
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(DragSession, { autoScroll }), container ? createPortal(/* @__PURE__ */ jsx("div", {
+		"data-slot": "drag-lift-portal",
+		className: cn("contents", resolvedMode),
+		children: overlay
+	}), container) : overlay] });
+}
+/** Where the pointer is during a drag: auto-scroll and the refusal hint read it. */
+const pointer = {
+	x: 0,
+	y: 0,
+	known: false
+};
+function trackPointer(event) {
+	const point = "touches" in event ? event.touches[0] : event;
+	if (!point) return;
+	pointer.x = point.clientX;
+	pointer.y = point.clientY;
+	pointer.known = true;
+}
+/** The pointer's last place, for a hint that follows it. */
+function dragPointer() {
+	return pointer.known ? {
+		x: pointer.x,
+		y: pointer.y
+	} : null;
+}
+function DragSession({ autoScroll }) {
+	const { active, activatorEvent } = useDndContext();
+	const dragging = active != null;
+	const viaKeyboard = isKeyboardEvent(activatorEvent);
+	useEffect(() => {
+		if (!dragging) return;
+		const root = document.documentElement;
+		root.setAttribute("data-dragging", "");
+		if (activatorEvent && !viaKeyboard) trackPointer(activatorEvent);
+		const onMove = (event) => trackPointer(event);
+		const onBlur = () => cancelDrag();
+		const onVisibility = () => {
+			if (document.visibilityState === "hidden") cancelDrag();
+		};
+		window.addEventListener("pointermove", onMove, {
+			capture: true,
+			passive: true
+		});
+		window.addEventListener("touchmove", onMove, {
+			capture: true,
+			passive: true
+		});
+		window.addEventListener("blur", onBlur);
+		document.addEventListener("visibilitychange", onVisibility);
+		let frame = 0;
+		const tick = () => {
+			if (pointer.known) autoScrollAt(pointer.x, pointer.y);
+			frame = requestAnimationFrame(tick);
+		};
+		if (autoScroll && !viaKeyboard) frame = requestAnimationFrame(tick);
+		return () => {
+			root.removeAttribute("data-dragging");
+			pointer.known = false;
+			window.removeEventListener("pointermove", onMove, { capture: true });
+			window.removeEventListener("touchmove", onMove, { capture: true });
+			window.removeEventListener("blur", onBlur);
+			document.removeEventListener("visibilitychange", onVisibility);
+			cancelAnimationFrame(frame);
+		};
+	}, [
+		dragging,
+		viaKeyboard,
+		autoScroll,
+		activatorEvent
+	]);
+	return null;
+}
+function scrollable(element) {
+	const style = getComputedStyle(element);
+	return {
+		x: /(auto|scroll)/.test(style.overflowX) && element.scrollWidth > element.clientWidth,
+		y: /(auto|scroll)/.test(style.overflowY) && element.scrollHeight > element.clientHeight
+	};
+}
+/** Faster the nearer the edge: up to 16px a frame at the edge itself. */
+function speed(depth) {
+	return Math.ceil(16 * Math.min(1, depth / 48) ** 2);
+}
+function scrollDelta(start, end, at, position, max) {
+	const zone = 48;
+	if (at < start + zone && position > 0) return -speed(start + zone - at);
+	if (at > end - zone && position < max) return speed(at - (end - zone));
+	return 0;
+}
+/** Scrolls the nearest area under the point that can still scroll toward the edge it is near. */
+function autoScrollAt(x, y) {
+	let element = document.elementFromPoint(x, y);
+	while (element && element !== document.documentElement && element !== document.body) {
+		const can = scrollable(element);
+		if (can.x || can.y) {
+			const rect = element.getBoundingClientRect();
+			const dy = can.y ? scrollDelta(rect.top, rect.bottom, y, element.scrollTop, element.scrollHeight - element.clientHeight - 1) : 0;
+			const dx = can.x ? scrollDelta(rect.left, rect.right, x, element.scrollLeft, element.scrollWidth - element.clientWidth - 1) : 0;
+			if (dx || dy) {
+				element.scrollBy(dx, dy);
+				return;
+			}
+		}
+		element = element.parentElement;
+	}
+	const page = document.scrollingElement ?? document.documentElement;
+	const dy = scrollDelta(0, window.innerHeight, y, page.scrollTop, page.scrollHeight - window.innerHeight - 1);
+	if (dy) window.scrollBy(0, dy);
+}
+//#endregion
+//#region src/components/drag/drag-sensors.ts
+/**
+* A mouse or a pen picks an item up once it has moved this far, so a click
+* never moves anything (design/patterns/drag-and-drop.md#starting-a-drag).
+*/
+const MOUSE_DRAG_DISTANCE_PX = 6;
+/**
+* Space picks up and drops, Escape puts back, the arrow keys move. Enter
+* never starts a drag: on an item that can also be opened or activated, Enter
+* does that.
+*/
+const DRAG_KEYBOARD_CODES = {
+	start: ["Space"],
+	cancel: ["Escape"],
+	end: ["Space"]
+};
+var DragKeyboardSensorImpl = class extends KeyboardSensor {
+	static activators = KeyboardSensor.activators;
+	attach() {
+		super.attach();
+		holdEscape(eventWindow(this.props.event), this, (event) => this.handleCancel(event));
+	}
+	detach() {
+		releaseEscape(eventWindow(this.props.event), this);
+		super.detach();
+	}
+};
+/**
+* dnd-kit's KeyboardSensor, but Escape during the drag puts the item back and
+* reaches nothing else: no dialog, panel or popover that closes on Escape
+* hears it (`drag-escape.ts`). The pointer sensors of `useDragSensors` do the
+* same.
+*/
+const DragKeyboardSensor = DragKeyboardSensorImpl;
+const NO_TOUCH = {};
+/**
+* The one sensor set for everything that can be dragged
+* (design/patterns/drag-and-drop.md#starting-a-drag):
+*
+* - a mouse or a pen: after 6px of movement;
+* - a finger: hold still 500ms, then move 10px (`useHoldThenMoveTouchSensor`);
+* - the keyboard: Space picks up, the arrows move, Space drops, Escape puts
+*   back. Enter never starts a drag.
+*
+* However the drag started, Escape during it only puts the item back: it is
+* taken in the capture phase on the window and stopped, so no app handler
+* (a dialog, a panel, a popover that closes on Escape) hears it. Once the drag
+* is over, Escape reaches the app again.
+*
+* Pass the options, or only the keyboard's `coordinateGetter`.
+*/
+function useDragSensors(options = {}) {
+	const { coordinateGetter = listKeyboardCoordinates, keyboard = true, touch = NO_TOUCH } = typeof options === "function" ? { coordinateGetter: options } : options;
+	const keyboardOptions = useMemo(() => ({
+		keyboardCodes: DRAG_KEYBOARD_CODES,
+		coordinateGetter
+	}), [coordinateGetter]);
+	const mouse = useMouseOnlyPointerSensor(6);
+	const finger = useHoldThenMoveTouchSensor(touch);
+	const keys = useSensor(DragKeyboardSensor, keyboardOptions);
+	return useSensors(mouse, finger, keyboard ? keys : null);
+}
+/**
+* dnd-kit's sortable keyboard steps, measured from where the item's place
+* actually is (its own node, slid into the landing spot) rather than from the
+* lifted copy. After an item moves into another list the two differ, and the
+* arrows would skip a place. Use it for lists inside one `DndContext`.
+*/
+const listKeyboardCoordinates = (event, args) => {
+	const { context } = args;
+	const node = context.active == null ? null : context.draggableNodes.get(context.active.id)?.node.current;
+	if (!node) return sortableKeyboardCoordinates(event, args);
+	const rect = node.getBoundingClientRect();
+	const collisionRect = {
+		top: rect.top,
+		left: rect.left,
+		width: rect.width,
+		height: rect.height,
+		bottom: rect.bottom,
+		right: rect.right
+	};
+	return sortableKeyboardCoordinates(event, {
+		...args,
+		context: {
+			...context,
+			collisionRect
+		}
+	});
+};
+/**
+* The keyboard fix for an item that moves between lists while it is dragged
+* (a sidebar's sections, a board's columns). Without it, dnd-kit still counts
+* the row the item was put next to as the place under it, projects one more
+* move, and the next arrow skips a place: what is announced and where the item
+* drops disagree. With it:
+*
+* - right after it moves list, the item is over itself (by keyboard until the
+*   next arrow, by pointer for one frame);
+* - the arrows are measured from the item's real place (`listKeyboardCoordinates`).
+*
+* Render `DragRemeasure` too, so the lists are measured again after the move.
+*/
+function useDragAcrossLists(collisionDetection) {
+	const box = useRef({
+		overSelf: false,
+		justMoved: false,
+		frame: 0
+	});
+	return useMemo(() => {
+		const clearFrame = () => {
+			const state = box.current;
+			if (state.frame && typeof cancelAnimationFrame !== "undefined") cancelAnimationFrame(state.frame);
+			state.frame = 0;
+		};
+		return {
+			collisionDetection: (args) => (box.current.justMoved || box.current.overSelf) && args.active ? [{ id: args.active.id }] : collisionDetection(args),
+			coordinateGetter: (event, args) => {
+				box.current.overSelf = false;
+				return listKeyboardCoordinates(event, args);
+			},
+			moved: (viaKeyboard) => {
+				const state = box.current;
+				state.justMoved = true;
+				if (viaKeyboard) state.overSelf = true;
+				clearFrame();
+				if (typeof requestAnimationFrame === "undefined") {
+					state.justMoved = false;
+					return;
+				}
+				state.frame = requestAnimationFrame(() => {
+					state.frame = requestAnimationFrame(() => {
+						state.justMoved = false;
+						state.frame = 0;
+					});
+				});
+			},
+			reset: () => {
+				clearFrame();
+				box.current.overSelf = false;
+				box.current.justMoved = false;
+			}
+		};
+	}, [collisionDetection]);
+}
+/**
+* Measures every drop target again once an item's move into another list has
+* rendered. dnd-kit's own observers skip targets whose size didn't change,
+* even when they moved. Render it inside the `DndContext`.
+*/
+function DragRemeasure({ version }) {
+	const context = useDndContext();
+	const latest = useRef(context);
+	useLayoutEffect(() => {
+		latest.current = context;
+	});
+	useLayoutEffect(() => {
+		const { active, droppableContainers } = latest.current;
+		if (active) latest.current.measureDroppableContainers([...droppableContainers.keys()]);
+	}, [version]);
+	return null;
+}
+//#endregion
+//#region src/components/drag/drop-placeholder.tsx
+/**
+* Where a dragged item will land (design/patterns/drag-and-drop.md#where-it-will-land):
+* a 1.5px dashed `line-strong` outline on `fill-subtle`, with the item's
+* radius and size. One look for every place. The control radius is the
+* default; pass the item's own (`rounded-container` for a card). Hidden from
+* assistive technology: the announcements say where the item is.
+*/
+function DropPlaceholder({ opaque = false, className, render, ...props }) {
+	const { placeholder } = drag({ opaque });
+	return useRender({
+		defaultTagName: "div",
+		render,
+		props: mergeProps({
+			"aria-hidden": true,
+			className: placeholder({ className })
+		}, props, { "data-slot": "drop-placeholder" })
+	});
+}
+/** The chip sits this far right of and below the pointer. */
+const HINT_OFFSET = {
+	x: 14,
+	y: 16
+};
+/** It stays at least this far inside the window on every side. */
+const HINT_INSET = 8;
+/** Pushed off the lifted copy, it keeps this far from it. */
+const HINT_GAP = 6;
+function overlaps(a, b) {
+	return a.left < b.right && a.right > b.left && a.top < b.bottom && a.bottom > b.top;
+}
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(value, Math.max(min, max)));
+}
+/**
+* Where the refusal chip goes (design/patterns/drag-and-drop.md#refused-places):
+* right of and below the pointer; left of it (and of the copy) where the
+* window's right edge would cut it, above it where the bottom edge would; off
+* the lifted copy, which is drawn over it; and always at least 8px inside the
+* window.
+*/
+function placeRefusalHint(point, size, lift, viewport) {
+	const { width, height } = size;
+	const maxX = viewport.width - HINT_INSET - width;
+	const maxY = viewport.height - HINT_INSET - height;
+	const fitsX = (x) => x >= HINT_INSET && x <= maxX;
+	const fitsY = (y) => y >= HINT_INSET && y <= maxY;
+	const right = point.x + HINT_OFFSET.x;
+	const onRight = right <= maxX;
+	let x = onRight ? right : Math.min(point.x, lift?.left ?? point.x) - HINT_OFFSET.x - width;
+	const below = point.y + HINT_OFFSET.y;
+	const onBelow = below <= maxY;
+	let y = onBelow ? below : point.y - HINT_OFFSET.y - height;
+	const box = (bx, by) => ({
+		left: bx,
+		top: by,
+		right: bx + width,
+		bottom: by + height
+	});
+	if (lift && overlaps(box(x, y), lift)) {
+		const clearBelow = lift.bottom + HINT_GAP;
+		const clearAbove = lift.top - HINT_GAP - height;
+		const vertical = (onBelow ? [clearBelow, clearAbove] : [clearAbove, clearBelow]).find(fitsY);
+		if (vertical !== void 0) y = vertical;
+		else {
+			const besideRight = lift.right + HINT_OFFSET.x;
+			const besideLeft = lift.left - HINT_OFFSET.x - width;
+			const beside = (onRight ? [besideRight, besideLeft] : [besideLeft, besideRight]).find(fitsX);
+			if (beside !== void 0) x = beside;
+		}
+	}
+	return {
+		x: Math.round(clamp(x, HINT_INSET, maxX)),
+		y: Math.round(clamp(y, HINT_INSET, maxY))
+	};
+}
+/**
+* Shown while the hand is over a place that refuses the item
+* (design/patterns/drag-and-drop.md#refused-places): the reason, in a HUD
+* chip by the pointer (by the lifted copy in a keyboard drag), and the
+* not-allowed cursor. Render it only while the place is refused, inside the
+* `DndContext`, with no placeholder anywhere. Announce the reason as well:
+* the chip is not read out.
+*
+* The chip sits right of and below the pointer. Near the window's right edge
+* it goes left of the pointer and of the lifted copy, near the bottom edge
+* above the pointer; it never sits under the copy, and always stays 8px inside
+* the window. Its size is measured when its content changes, not every frame.
+*/
+function DragRefusalHint({ children, container, className, style, ...props }) {
+	const { hint } = drag();
+	const ref = useRef(null);
+	const { active, activatorEvent } = useDndContext();
+	const dragging = active != null;
+	const viaKeyboard = typeof KeyboardEvent !== "undefined" && activatorEvent instanceof KeyboardEvent;
+	useEffect(() => {
+		if (!dragging) return;
+		const root = document.documentElement;
+		root.setAttribute("data-drag-refused", "");
+		const node = ref.current;
+		const size = {
+			width: node?.offsetWidth ?? 0,
+			height: node?.offsetHeight ?? 0
+		};
+		const observer = node && typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => {
+			size.width = node.offsetWidth;
+			size.height = node.offsetHeight;
+		}) : null;
+		if (node) observer?.observe(node);
+		let frame = 0;
+		const tick = () => {
+			if (node) {
+				const lift = document.querySelector("[data-slot=drag-lift]")?.getBoundingClientRect();
+				let point = dragPointer();
+				if ((viaKeyboard || !point) && lift) point = {
+					x: lift.right,
+					y: lift.top + lift.height / 2
+				};
+				if (point) {
+					const at = placeRefusalHint(point, size, lift ?? null, {
+						width: window.innerWidth,
+						height: window.innerHeight
+					});
+					node.style.transform = `translate(${at.x}px, ${at.y}px)`;
+					node.style.visibility = "visible";
+				}
+			}
+			frame = requestAnimationFrame(tick);
+		};
+		tick();
+		return () => {
+			root.removeAttribute("data-drag-refused");
+			observer?.disconnect();
+			cancelAnimationFrame(frame);
+		};
+	}, [dragging, viaKeyboard]);
+	if (!dragging || typeof document === "undefined") return null;
+	return createPortal(/* @__PURE__ */ jsx("div", {
+		...props,
+		ref,
+		"data-slot": "drag-refusal-hint",
+		"aria-hidden": true,
+		className: hint({ className }),
+		style: {
+			visibility: "hidden",
+			...style
+		},
+		children
+	}), container ?? document.body);
+}
+//#endregion
 //#region src/components/skeleton/skeleton.tsx
 const skeleton = tv$1({
 	slots: { root: [
@@ -6196,4 +6984,4 @@ function InboxItemActions({ className, render, reveal, ...props }) {
 	});
 }
 //#endregion
-export { MessageTextSelectionToolbarSeparator as $, controlIconInset as $i, PopoverClose as $n, ListRow as $r, MessageItemSearchMatch as $t, MessageList as A, DialogSheetBack as Ai, PreviewCardHeader as An, DropdownMenuSeparator as Ar, MessageItemBadgeSeparator as At, MessageQuotedPreviewHeader as B, Button$1 as Bi, MobileNavServerPopoverDestination as Bn, PanelHeaderRoot as Br, MessageItemInlineStatus as Bt, MessageListJumpPill as C, DialogDescription as Ci, PreviewCardActions as Cn, DropdownMenuLabel as Cr, MessageReactionTooltipContent as Ct, MessageListEndFade as D, DialogNav as Di, PreviewCardDescription as Dn, DropdownMenuRadioGroup as Dr, MessageReactionTooltipNames as Dt, MessageListDateDivider as E, DialogHeader as Ei, PreviewCardContent as En, DropdownMenuPortal as Er, MessageReactionTooltipNameText as Et, MessageQuotedPreviewAuthorDelegatedBy as F, panelToggleAction as Fi, PreviewCardTitle as Fn, Kbd as Fr, MessageItemDelegatedAvatar as Ft, MessageQuotedPreviewUnavailable as G, useParentOverlayKind as Gi, MobileNavServerPopoverRowBody as Gn, ScrollAreaContent as Gr, MessageItemSenderGroup as Gt, MessageQuotedPreviewText as H, Spinner as Hi, MobileNavServerPopoverGroup as Hn, PanelScrollViewport as Hr, MessageItemSender as Ht, MessageQuotedPreviewAuthorMeta as I, TextLink as Ii, PreviewCardTrigger as In, KbdGroup as Ir, MessageItemDelegatedBy as It, MessageEmbedFooter as J, useTheme as Ji, Popover$1 as Jn, ScrollAreaThumb as Jr, MessageItemBody as Jt, MessageEmbed as K, withOverlayLayer as Ki, MobileNavServerPopoverRowDescription as Kn, ScrollAreaCorner as Kr, MessageItemTime as Kt, MessageQuotedPreviewAuthorName as L, TextLinkExternalIcon as Li, MobileNavServerItem as Ln, Panel as Lr, MessageItemDelegatedByButton as Lt, MessageQuotedPreviewAttachment as M, DialogTitle as Mi, PreviewCardPopup as Mn, DropdownMenuSubmenu as Mr, MessageItemSavedIndicator as Mt, MessageQuotedPreviewAttachments as N, DialogTrigger as Ni, PreviewCardPortal as Nn, DropdownMenuSubmenuTrigger as Nr, MessageItemToolbar as Nt, MessageListHistoryLimited as O, DialogOverlay as Oi, PreviewCardEyebrow as On, DropdownMenuRadioItem as Or, MessageReactionTooltipSeparator as Ot, MessageQuotedPreviewAuthor as P, PanelAction as Pi, PreviewCardSeparator as Pn, DropdownMenuTrigger as Pr, MessageItemToolbarButton as Pt, MessageTextSelectionToolbarButton as Q, useStackedActions as Qi, PopoverBody as Qn, PRESENCE_COLOR as Qr, MessageItemFooter as Qt, MessageQuotedPreviewChannel as R, textLinkVariants as Ri, MobileNavServerPopover as Rn, PanelBody as Rr, MessageItemDelegatedByName as Rt, MessageListJumpControls as S, DialogContent as Si, PreviewCard$1 as Sn, DropdownMenuItemLabel as Sr, MessageReactionQuickRow as St, MessageListJumpPillGroup as T, DialogFooterNote as Ti, PreviewCardBody as Tn, DropdownMenuPopup as Tr, MessageReactionTooltipName as Tt, MessageQuotedPreviewThread as U, defaultNativeButton as Ui, MobileNavServerPopoverList as Un, PanelSection as Ur, MessageItemSenderBadges as Ut, MessageQuotedPreviewLoading as V, buttonVariants as Vi, MobileNavServerPopoverDestinations as Vn, PanelScrollContent as Vr, MessageItemMeta as Vt, MessageQuotedPreviewTimestamp as W, OverlayLayerProvider as Wi, MobileNavServerPopoverRow as Wn, ScrollArea$1 as Wr, MessageItemSenderButton as Wt, messageEmbed as X, tv$1 as Xi, PopoverArrow as Xn, Checkbox$1 as Xr, MessageItemEdited as Xt, MessageEmbedHeader as Y, ThemeStateContext as Yi, PopoverActions as Yn, ScrollAreaViewport as Yr, MessageItemContent as Yt, MessageTextSelectionToolbar as Z, stackedActions as Zi, PopoverBackdrop as Zn, CheckboxIndicator as Zr, MessageItemEmbedded as Zt, InboxItemTrailing as _, DialogSheetContent as _i, useOverflowTitle as _n, DropdownMenuCheckboxItemIndicator as _r, MessageReactionErrorIndicator as _t, InboxItemContext as a, ListRowIcon as ai, Avatar$1 as an, PopoverSeparator as ar, MessageReferenceIcon as at, useLatestRef as b, DialogBody as bi, observeTruncation as bn, DropdownMenuItem as br, MessageReactionPickerStatic as bt, InboxItemLeading as c, ListRowTop as ci, AvatarGroup as cn, PopoverViewport as cr, MessageReferencePending as ct, InboxItemMetadata as d, TooltipContent as di, RadioGroup$1 as dn, useMouseOnlyPointerSensor as dr, MessageReferenceText as dt, headEdgePull as ea, ListRowBody as ei, MessageItemAvatarSlot as en, PopoverContent as er, MessageMultiSelect as et, InboxItemSelection as f, TooltipPortal as fi, RadioGroupIndicator as fn, MobileNavItem as fr, MessageReferenceUnavailable as ft, InboxItemTitle as g, DialogCommit as gi, InputGroupInput as gn, DropdownMenuCheckboxItem as gr, MessageReactionCount as gt, InboxItemTimestamp as h, Badge as hi, InputGroupAddon as hn, DropdownMenu as hr, MessageReactionChip as ht, InboxItemContent as i, ListRowGroup as ii, searchHit as in, PopoverPortal as ir, MessageReferenceChip as it, MessageQuotedPreview as j, DialogSurface as ji, PreviewCardMeta as jn, DropdownMenuShortcut as jr, MessageItemReadReceipt as jt, MessageListNotice as k, DialogPortal as ki, PreviewCardFooter as kn, DropdownMenuRadioItemIndicator as kr, MessageItemBadge as kt, InboxItemMarks as l, ListRowValue as li, AvatarGroupCount as ln, TOUCH_DRAG_HOLD_MS as lr, MessageReferenceReadMark as lt, InboxItemSubtitle as m, TooltipTrigger as mi, InputGroup as mn, MobileNavRoot as mr, MessageReactionAddButton as mt, InboxItemActions as n, decisionWidth as na, ListRowChevron as ni, MessageItemGutter as nn, PopoverHeader as nr, MessageMultiSelectToolbar as nt, InboxItemHeading as o, ListRowMeta as oi, AvatarBadge as on, PopoverTitle as or, MessageReferenceIndicator as ot, InboxItemSender as p, TooltipProvider as pi, RadioGroupItem as pn, MobileNavLabel as pr, inlineChip as pt, MessageEmbedContent as q, useThemeScopeProps as qi, MobileNavServerPopoverRowLabel as qn, ScrollAreaScrollbar as qr, MessageItemAttachments as qt, InboxItemBody as r, ListRowDescription as ri, MessageItem as rn, PopoverPopup as rr, MessageMultiSelectToolbarActions as rt, InboxItemHoverTarget as s, ListRowTitle as si, AvatarFallback as sn, PopoverTrigger as sr, MessageReferenceLabel as st, InboxItem as t, headEdges as ta, ListRowBottom as ti, MessageItemContinuationTime as tn, PopoverDescription as tr, MessageMultiSelectCheckbox as tt, InboxItemMessage as u, Tooltip$1 as ui, AvatarImage as un, useHoldThenMoveTouchSensor as ur, MessageReferenceSuffix as ut, InboxItemTrigger as v, useMobileViewport as vi, measureContent as vn, DropdownMenuContent as vr, MessageReactionGlyph as vt, MessageListJumpPillDismiss as w, DialogFooter as wi, PreviewCardArrow as wn, DropdownMenuLinkItem as wr, MessageReactionTooltipMeta as wt, Skeleton as x, DialogClose as xi, readNow as xn, DropdownMenuItemCount as xr, MessageReactionQuickButton as xt, inboxItem as y, Dialog$1 as yi, measureElement as yn, DropdownMenuFooter as yr, MessageReactionPickerContent as yt, MessageQuotedPreviewContent as z, DialogSheetReset as zi, MobileNavServerPopoverContent as zn, PanelFooter as zr, MessageItemHeader as zt };
+export { MessageListDateDivider as $, DialogContent as $i, PreviewCardContent as $n, DropdownMenuItemLabel as $r, MessageReactionTooltipNameText as $t, DRAG_AUTO_SCROLL_ZONE_PX as A, controlIconInset as Aa, ListRow as Ai, MessageItem as An, PopoverPopup as Ar, MessageMultiSelectToolbarActions as At, useDragSiblingTransition as B, ListRowValue as Bi, RadioGroupItem as Bn, TOUCH_DRAG_TOLERANCE_PX as Br, inlineChip as Bt, DropPlaceholder as C, withOverlayLayer as Ca, ScrollAreaCorner as Ci, MessageItemEdited as Cn, PopoverArrow as Cr, messageEmbed as Ct, listKeyboardCoordinates as D, tv$1 as Da, Checkbox$1 as Di, MessageItemAvatarSlot as Dn, PopoverContent as Dr, MessageMultiSelect as Dt, MOUSE_DRAG_DISTANCE_PX as E, ThemeStateContext as Ea, ScrollAreaViewport as Ei, MessageItemSearchMatch as En, PopoverClose as Er, MessageTextSelectionToolbarSeparator as Et, DROP_GLIDE as F, ListRowGroup as Fi, AvatarGroup as Fn, PopoverViewport as Fr, MessageReferencePending as Ft, SILENT_DRAG_ANNOUNCEMENTS as G, TooltipTrigger as Gi, measureContent as Gn, MobileNavRoot as Gr, MessageReactionGlyph as Gt, LIFT_CLASS as H, TooltipContent as Hi, InputGroupAddon as Hn, useMouseOnlyPointerSensor as Hr, MessageReactionChip as Ht, DragLift as I, ListRowIcon as Ii, AvatarGroupCount as In, HoldThenMoveTouchSensor as Ir, MessageReferenceReadMark as It, dragMessages as J, DialogSheetContent as Ji, readNow as Jn, DropdownMenuCheckboxItemIndicator as Jr, MessageReactionQuickButton as Jt, createDragAnnouncements as K, Badge as Ki, measureElement as Kn, DropdownMenu as Kr, MessageReactionPickerContent as Kt, ORIGIN_OPACITY as L, ListRowMeta as Li, AvatarImage as Ln, MouseOnlyPointerSensor as Lr, MessageReferenceSuffix as Lt, DRAG_LIFT_Z_INDEX as M, headEdges as Ma, ListRowBottom as Mi, Avatar$1 as Mn, PopoverSeparator as Mr, MessageReferenceIcon as Mt, DRAG_SETTLE as N, decisionWidth as Na, ListRowChevron as Ni, AvatarBadge as Nn, PopoverTitle as Nr, MessageReferenceIndicator as Nt, useDragAcrossLists as O, stackedActions as Oa, CheckboxIndicator as Oi, MessageItemContinuationTime as On, PopoverDescription as Or, MessageMultiSelectCheckbox as Ot, DRAG_SIBLING_TRANSITION as P, ListRowDescription as Pi, AvatarFallback as Pn, PopoverTrigger as Pr, MessageReferenceLabel as Pt, MessageListJumpPillGroup as Q, DialogClose as Qi, PreviewCardBody as Qn, DropdownMenuItemCount as Qr, MessageReactionTooltipName as Qt, cancelDrag as R, ListRowTitle as Ri, RadioGroup$1 as Rn, TOUCH_DRAG_DISTANCE_PX as Rr, MessageReferenceText as Rt, DragRefusalHint as S, useParentOverlayKind as Sa, ScrollAreaContent as Si, MessageItemContent as Sn, PopoverActions as Sr, MessageEmbedHeader as St, DragRemeasure as T, useTheme as Ta, ScrollAreaThumb as Ti, MessageItemFooter as Tn, PopoverBody as Tr, MessageTextSelectionToolbarButton as Tt, drag as U, TooltipPortal as Ui, InputGroupInput as Un, MobileNavItem as Ur, MessageReactionCount as Ut, useLiftContainer as V, Tooltip$1 as Vi, InputGroup as Vn, useHoldThenMoveTouchSensor as Vr, MessageReactionAddButton as Vt, DEFAULT_DRAG_MESSAGES as W, TooltipProvider as Wi, useOverflowTitle as Wn, MobileNavLabel as Wr, MessageReactionErrorIndicator as Wt, MessageListJumpPill as X, Dialog$1 as Xi, PreviewCardActions as Xn, DropdownMenuFooter as Xr, MessageReactionTooltipContent as Xt, MessageListJumpControls as Y, useMobileViewport as Yi, PreviewCard$1 as Yn, DropdownMenuContent as Yr, MessageReactionQuickRow as Yt, MessageListJumpPillDismiss as Z, DialogBody as Zi, PreviewCardArrow as Zn, DropdownMenuItem as Zr, MessageReactionTooltipMeta as Zt, InboxItemTrailing as _, Button$1 as _a, PanelHeaderRoot as _i, MessageItemSenderButton as _n, MobileNavServerPopoverRow as _r, MessageQuotedPreviewTimestamp as _t, InboxItemContext as a, DialogOverlay as aa, DropdownMenuRadioItem as ai, MessageItemSavedIndicator as an, PreviewCardPopup as ar, MessageQuotedPreviewAttachment as at, useLatestRef as b, defaultNativeButton as ba, PanelSection as bi, MessageItemAttachments as bn, MobileNavServerPopoverRowLabel as br, MessageEmbedContent as bt, InboxItemLeading as c, DialogSurface as ca, DropdownMenuShortcut as ci, MessageItemDelegatedAvatar as cn, PreviewCardTitle as cr, MessageQuotedPreviewAuthorDelegatedBy as ct, InboxItemMetadata as d, PanelAction as da, DropdownMenuTrigger as di, MessageItemDelegatedByName as dn, MobileNavServerPopover as dr, MessageQuotedPreviewChannel as dt, DialogDescription as ea, DropdownMenuLabel as ei, MessageReactionTooltipNames as en, PreviewCardDescription as er, MessageListEndFade as et, InboxItemSelection as f, panelToggleAction as fa, Kbd as fi, MessageItemHeader as fn, MobileNavServerPopoverContent as fr, MessageQuotedPreviewContent as ft, InboxItemTitle as g, DialogSheetReset as ga, PanelFooter as gi, MessageItemSenderBadges as gn, MobileNavServerPopoverList as gr, MessageQuotedPreviewThread as gt, InboxItemTimestamp as h, textLinkVariants as ha, PanelBody as hi, MessageItemSender as hn, MobileNavServerPopoverGroup as hr, MessageQuotedPreviewText as ht, InboxItemContent as i, DialogNav as ia, DropdownMenuRadioGroup as ii, MessageItemReadReceipt as in, PreviewCardMeta as ir, MessageQuotedPreview as it, DRAG_KEYBOARD_OFFSET_PX as j, headEdgePull as ja, ListRowBody as ji, searchHit as jn, PopoverPortal as jr, MessageReferenceChip as jt, useDragSensors as k, useStackedActions as ka, PRESENCE_COLOR as ki, MessageItemGutter as kn, PopoverHeader as kr, MessageMultiSelectToolbar as kt, InboxItemMarks as l, DialogTitle as la, DropdownMenuSubmenu as li, MessageItemDelegatedBy as ln, PreviewCardTrigger as lr, MessageQuotedPreviewAuthorMeta as lt, InboxItemSubtitle as m, TextLinkExternalIcon as ma, Panel as mi, MessageItemMeta as mn, MobileNavServerPopoverDestinations as mr, MessageQuotedPreviewLoading as mt, InboxItemActions as n, DialogFooterNote as na, DropdownMenuPopup as ni, MessageItemBadge as nn, PreviewCardFooter as nr, MessageListNotice as nt, InboxItemHeading as o, DialogPortal as oa, DropdownMenuRadioItemIndicator as oi, MessageItemToolbar as on, PreviewCardPortal as or, MessageQuotedPreviewAttachments as ot, InboxItemSender as p, TextLink as pa, KbdGroup as pi, MessageItemInlineStatus as pn, MobileNavServerPopoverDestination as pr, MessageQuotedPreviewHeader as pt, dragInstructions as q, DialogCommit as qi, observeTruncation as qn, DropdownMenuCheckboxItem as qr, MessageReactionPickerStatic as qt, InboxItemBody as r, DialogHeader as ra, DropdownMenuPortal as ri, MessageItemBadgeSeparator as rn, PreviewCardHeader as rr, MessageList as rt, InboxItemHoverTarget as s, DialogSheetBack as sa, DropdownMenuSeparator as si, MessageItemToolbarButton as sn, PreviewCardSeparator as sr, MessageQuotedPreviewAuthor as st, InboxItem as t, DialogFooter as ta, DropdownMenuLinkItem as ti, MessageReactionTooltipSeparator as tn, PreviewCardEyebrow as tr, MessageListHistoryLimited as tt, InboxItemMessage as u, DialogTrigger as ua, DropdownMenuSubmenuTrigger as ui, MessageItemDelegatedByButton as un, MobileNavServerItem as ur, MessageQuotedPreviewAuthorName as ut, InboxItemTrigger as v, buttonVariants as va, PanelScrollContent as vi, MessageItemSenderGroup as vn, MobileNavServerPopoverRowBody as vr, MessageQuotedPreviewUnavailable as vt, DRAG_KEYBOARD_CODES as w, useThemeScopeProps as wa, ScrollAreaScrollbar as wi, MessageItemEmbedded as wn, PopoverBackdrop as wr, MessageTextSelectionToolbar as wt, Skeleton as x, OverlayLayerProvider as xa, ScrollArea$1 as xi, MessageItemBody as xn, Popover$1 as xr, MessageEmbedFooter as xt, inboxItem as y, Spinner as ya, PanelScrollViewport as yi, MessageItemTime as yn, MobileNavServerPopoverRowDescription as yr, MessageEmbed as yt, keepGrabInside as z, ListRowTop as zi, RadioGroupIndicator as zn, TOUCH_DRAG_HOLD_MS as zr, MessageReferenceUnavailable as zt };