@teaflask/assistant 0.3.0 → 0.6.0

package/dist/components/primitives/floating-panel.js

@@ -6,19 +6,12 @@ import { focusAutofocusTarget } from "./autofocus.js";
 import { cx } from "./cx.js";
 import { useDockReflow } from "./use-dock-reflow.js";
 import { useSwipeDismiss } from "./use-swipe-dismiss.js";
-/** Where focus actually is, from the panel's own tree: getRootNode(),
- * never the document, which retargets activeElement to the shadow HOST
- * inside the script-tag distribution — the contains() guard would always
- * fail and the captured opener would be the host. */
 function _activeElementNear(panel) {
     const root = panel.getRootNode();
     return root instanceof Document || root instanceof ShadowRoot
         ? root.activeElement
         : null;
 }
-/** Restores focus to the remembered opener, but only when the close is
- * taking focus away from the user — i.e. focus still lives inside the
- * panel. A user who opened the panel and moved on keeps their place. */
 function _returnFocusToOpener(panel, opener) {
     if (!panel.contains(_activeElementNear(panel))) {
         return;
@@ -30,8 +23,6 @@ function _returnFocusToOpener(panel, opener) {
 export function TfFloatingPanel({ open, onOpenChange, corner = "bottom-right", dock = "floating", focusOnOpen, className, children, ...props }) {
     const panelRef = useRef(null);
     const parkOnForcedHide = usePopoverPresence(panelRef, open, focusOnOpen);
-    // Esc closes the surface it is pressed in, and nothing else: scoped to
-    // keydowns that reach the panel, stopped so one keystroke does one thing.
     const closeFromEscape = useCallback((event) => {
         if (event.key !== "Escape" || event.defaultPrevented) {
             return;
@@ -42,10 +33,6 @@ export function TfFloatingPanel({ open, onOpenChange, corner = "bottom-right", d
     const dismiss = useCallback(() => {
         onOpenChange(false);
     }, [onOpenChange]);
-    // Downward swipe on the grab region dismisses — confined to the handle
-    // because the content scrolls the same axis. Docked, the gesture is
-    // off: a full-height pane reads as page furniture, and furniture that
-    // flies away under a drag reads as breakage.
     const swipe = useSwipeDismiss({
         axis: "y",
         direction: 1,
@@ -55,59 +42,15 @@ export function TfFloatingPanel({ open, onOpenChange, corner = "bottom-right", d
         handleSelector: "[data-tf-swipe-handle]",
     });
     useDockReflow(panelRef, dock);
-    return (
-    // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions -- the keydown is the panel's own Esc-to-close; the pointer handlers are the handle's swipe. Keyboard users close via Esc.
-    _jsx("div", { ref: panelRef, popover: "manual", role: "dialog", "data-tf-assistant": "", "data-tf-floating-panel": corner, "data-tf-panel-dock": dock, "data-tf-glass": dock === "floating" ? "" : undefined, onToggle: parkOnForcedHide, onKeyDown: closeFromEscape, onPointerDown: swipe.onPointerDown, onPointerMove: swipe.onPointerMove, onPointerUp: swipe.onPointerUp, onPointerCancel: swipe.onPointerCancel, onClickCapture: swipe.onClickCapture, className: cx(
-        // `hidden` restates the UA's closed-popover display and is the
-        // whole display without popover support; the important marker is
-        // ordering insurance between tf:hidden and tf:open:flex.
-        "tf:m-0 tf:hidden tf:p-0 tf:open:flex!", "tf:flex-col tf:overflow-hidden tf:text-tf-foreground", dock === "sidebar"
-            ? // Flush full-height, edge to edge, never an inset column: the
-                // Portal Lift rule inverted — no shadow, square corners, a
-                // hairline left border (in styles.css, not a border-l utility:
-                // border utilities ride an @property registration Chromium honours
-                // only in document sheets; this must paint everywhere). A fixed 26rem
-                // on ultrawide too — a pane, not a proportion; max-w guards an
-                // inflated host rem. left-auto is load-bearing: the UA popover
-                // style is inset:0, and left+right 0 resolves to the LEFT edge in LTR.
+    return (_jsx("div", { ref: panelRef, popover: "manual", role: "dialog", "data-tf-assistant": "", "data-tf-floating-panel": corner, "data-tf-panel-dock": dock, "data-tf-glass": dock === "floating" ? "" : undefined, onToggle: parkOnForcedHide, onKeyDown: closeFromEscape, onPointerDown: swipe.onPointerDown, onPointerMove: swipe.onPointerMove, onPointerUp: swipe.onPointerUp, onPointerCancel: swipe.onPointerCancel, onClickCapture: swipe.onClickCapture, className: cx("tf:m-0 tf:hidden tf:p-0 tf:open:flex!", "tf:flex-col tf:overflow-hidden tf:text-tf-foreground", dock === "sidebar"
+            ?
                 "tf:inset-y-0 tf:right-0 tf:left-auto tf:h-dvh tf:w-104 tf:max-w-[calc(100vw-2rem)] tf:rounded-none tf:bg-tf-background tf:shadow-none"
-            : cx(
-            // A floating corner card, never flush: the viewport-edge margins
-            // signal "the page is still there". Compose-window proportions
-            // (~44vw): the 24rem floor is the phone card, 46rem caps the
-            // ultrawide so the panel stays a card, never a pane.
-            "tf:inset-auto tf:bottom-4 tf:w-[clamp(24rem,44vw,46rem)] tf:max-w-[calc(100vw-2rem)]", 
-            // Fixed height under viewport-relative caps so the panel never
-            // jumps between empty and busy: ~68dvh is the compose-window
-            // register, 52rem stops tall monitors growing a tower, and the
-            // 6rem headroom term keeps the software-keyboard behavior.
-            "tf:h-[min(68dvh,52rem,calc(100dvh-6rem))]", 
-            // The floating-surface chrome comes from the liquid-glass
-            // material (data-tf-glass, styles.css). The 24px corner is the
-            // panel step of the radius ladder (the composer slab wears the
-            // same literal), not derived from --tf-radius so a host's
-            // control-radius theme can't unround the surface.
-            "tf:rounded-3xl tf:border", corner === "bottom-left" ? "tf:left-4" : "tf:right-4"), className), ...props, children: children }));
+            : cx("tf:inset-auto tf:bottom-4 tf:w-[clamp(24rem,44vw,46rem)] tf:max-w-[calc(100vw-2rem)]", "tf:h-[min(68dvh,52rem,calc(100dvh-6rem))]", "tf:rounded-3xl tf:border", corner === "bottom-left" ? "tf:left-4" : "tf:right-4"), className), ...props, children: children }));
 }
-/**
- * The popover discipline: `open` shows and hides the top-layer panel
- * (focus captured on a gesture's open, returned on close), a hide the
- * panel did not initiate parks it, and the way-is-clear watcher restores
- * it. Returns the toggle handler that detects the forced hide.
- */
 function usePopoverPresence(panelRef, open, focusOnOpen) {
     const openerRef = useRef(null);
     const focusOnOpenRef = useLatestRef(focusOnOpen);
-    // Parked by a modal (or a meddling host script): hidden while `open`
-    // still says true, waiting for the way to clear. A ref, not state:
-    // nothing rendered depends on it and the watcher reads it live.
     const yieldedRef = useRef(false);
-    // The `open` prop stays authoritative: external hides are parked or
-    // reported, never applied locally, and this effect is the only writer.
-    // Inert is written here for the whole not-open stretch, not rendered:
-    // inert={!open} would commit before this effect and blur the focused
-    // descendant, so the focus return's "still inside" check could never
-    // pass. On open it lifts BEFORE showPopover(); on close it lands after.
     useEffect(() => {
         const panel = panelRef.current;
         if (panel === null) {
@@ -127,8 +70,6 @@ function usePopoverPresence(panelRef, open, focusOnOpen) {
             }
             else if (!open) {
                 if (showing) {
-                    // Before hidePopover(), while "focus is still inside" is still
-                    // observable.
                     _returnFocusToOpener(panel, openerRef.current);
                     panel.hidePopover();
                 }
@@ -139,18 +80,11 @@ function usePopoverPresence(panelRef, open, focusOnOpen) {
             panel.setAttribute("inert", "");
         }
     }, [panelRef, open, focusOnOpenRef]);
-    // The yield detector. Our own hide only ever runs with `open` already
-    // false, so a closed-toggle arriving while `open` is true was forced
-    // from outside — a modal's hide-all-popovers, or a host script.
     const parkOnForcedHide = useCallback((event) => {
         if (event.newState === "closed" && open) {
             yieldedRef.current = true;
         }
     }, [open]);
-    // The way-is-clear watcher, listening for the whole open stretch and
-    // acting only while parked. `close` doesn't bubble, so the document
-    // hears it in the capture phase; fullscreen exits hide popovers through
-    // the same spec step. Restoration never touches focus.
     useEffect(() => {
         const panel = panelRef.current;
         if (!open || panel === null || typeof panel.showPopover !== "function") {
@@ -158,9 +92,6 @@ function usePopoverPresence(panelRef, open, focusOnOpen) {
         }
         const doc = panel.ownerDocument;
         const restoreWhenClear = () => {
-            // fullscreenchange fires on the way IN too, and entering fullscreen
-            // is itself a popover-hiding step — without the fullscreenElement
-            // check this would pop the panel over the fullscreen element.
             if (!yieldedRef.current ||
                 doc.querySelector("dialog:modal") !== null ||
                 doc.fullscreenElement !== null) {
@@ -180,4 +111,3 @@ function usePopoverPresence(panelRef, open, focusOnOpen) {
     }, [panelRef, open]);
     return parkOnForcedHide;
 }
-//# sourceMappingURL=floating-panel.js.map

package/dist/components/primitives/kbd.d.ts

@@ -1,3 +1,2 @@
 import type { ComponentPropsWithoutRef } from "react";
 export declare function Kbd({ className, ...props }: ComponentPropsWithoutRef<"kbd">): import("react").JSX.Element;
-//# sourceMappingURL=kbd.d.ts.map

package/dist/components/primitives/kbd.js

@@ -1,20 +1,6 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { cx } from "./cx.js";
-// A key cap: the question panel's ↑ ↓ ↵ hints at the right edge of the
-// active answer row. Hairline on a transparent ground (so it sits on the
-// emphasis wash in light and dark alike), the badge step, the control
-// radius — an instrument marking, never a decoration — and always
-// aria-hidden at the call site: the hint duplicates what the radiogroup's
-// description already tells assistive tech, so it must not be read twice.
-// Never wraps: a two-token cap ("Ctrl ↵") must stay one line inside its
-// 20px height. Geist Sans, not mono: the visual spec keeps the mono face
-// for code alone; the glyphs themselves are icons at the call site,
-// because a host font cannot be trusted to carry U+21B5.
-// WithoutRef on purpose: a plain function component cannot forward a ref
-// under React 18.3, so admitting one in the props type would type-check a
-// silent no-op (tests/ref-prop-surface.test.ts holds the line).
 export function Kbd({ className, ...props }) {
     return (_jsx("kbd", { className: cx("tf:inline-flex tf:h-5 tf:min-w-5 tf:items-center tf:justify-center tf:gap-0.5 tf:rounded-tf", "tf:border tf:border-tf-input tf:bg-tf-transparent tf:px-1 tf:font-tf-sans tf:text-xs", "tf:leading-none tf:whitespace-nowrap tf:text-tf-muted-foreground", className), ...props }));
 }
-//# sourceMappingURL=kbd.js.map

package/dist/components/primitives/sheet.d.ts

@@ -2,7 +2,6 @@ import { type ReactNode } from "react";
 interface TfSheetProps {
     open: boolean;
     onOpenChange: (open: boolean) => void;
-    /** The drawer's edge. Also the direction a dismissing swipe travels. */
     side: "left" | "right";
     "aria-label": string;
     className?: string;
@@ -10,4 +9,3 @@ interface TfSheetProps {
 }
 export declare function TfSheet({ open, onOpenChange, side, className, children, ...props }: TfSheetProps): import("react").JSX.Element;
 export {};
-//# sourceMappingURL=sheet.d.ts.map

package/dist/components/primitives/sheet.js

@@ -8,21 +8,11 @@ export function TfSheet({ open, onOpenChange, side, className, children, ...prop
     const dismiss = useCallback(() => {
         onOpenChange(false);
     }, [onOpenChange]);
-    // The handlers ride the <dialog> element itself, so currentTarget is
-    // always the panel — no ref to forward, and pointer capture retargets
-    // the rest of the gesture here regardless of what it started over.
     const swipe = useSwipeDismiss({
         axis: "x",
         direction: side === "left" ? -1 : 1,
         open,
         onDismiss: dismiss,
     });
-    return (_jsx(TfDialog, { open: open, onOpenChange: onOpenChange, "data-tf-sheet": side, "data-tf-glass": "", onPointerDown: swipe.onPointerDown, onPointerMove: swipe.onPointerMove, onPointerUp: swipe.onPointerUp, onPointerCancel: swipe.onPointerCancel, onClickCapture: swipe.onClickCapture, className: cx(
-        // Flush to three edges at full height. Square corners are the
-        // point: a full-height panel with rounded outer corners reads as
-        // a modal, not as an edge. The peek left over beside it (the
-        // max-width) is both the "there is a page behind this" signal and
-        // a thumb-sized dismiss target.
-        "tf:m-0 tf:h-dvh tf:max-h-dvh tf:w-80 tf:max-w-[calc(100vw-3rem)] tf:flex-col", "tf:overflow-hidden tf:text-tf-foreground", side === "left" ? "tf:mr-auto" : "tf:ml-auto", className), ...props, children: children }));
+    return (_jsx(TfDialog, { open: open, onOpenChange: onOpenChange, "data-tf-sheet": side, "data-tf-glass": "", onPointerDown: swipe.onPointerDown, onPointerMove: swipe.onPointerMove, onPointerUp: swipe.onPointerUp, onPointerCancel: swipe.onPointerCancel, onClickCapture: swipe.onClickCapture, className: cx("tf:m-0 tf:h-dvh tf:max-h-dvh tf:w-80 tf:max-w-[calc(100vw-3rem)] tf:flex-col", "tf:overflow-hidden tf:text-tf-foreground", side === "left" ? "tf:mr-auto" : "tf:ml-auto", className), ...props, children: children }));
 }
-//# sourceMappingURL=sheet.js.map

package/dist/components/primitives/textarea.d.ts

@@ -5,4 +5,3 @@ interface TfTextareaProps extends ComponentPropsWithoutRef<"textarea"> {
 }
 export declare const TfTextarea: import("react").ForwardRefExoticComponent<TfTextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;
 export {};
-//# sourceMappingURL=textarea.d.ts.map

package/dist/components/primitives/textarea.js

@@ -8,10 +8,6 @@ const VARIANT_CLASSES = {
         "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-1 tf:focus-visible:outline-tf-ring",
     bare: "tf:border-0 tf:bg-transparent tf:px-2 tf:py-1.5 tf:text-tf-body tf:focus-visible:outline-none",
 };
-// forwardRef rather than ref-as-prop: the peer range admits React 18.3,
-// where a function component receives no ref through props — and the
-// composer's caret machinery anchors to this element.
 export const TfTextarea = forwardRef(function TfTextarea({ variant = "framed", className, ...props }, ref) {
     return (_jsx("textarea", { ref: ref, className: cx("tf:w-full tf:resize-none tf:text-tf-foreground", "tf:placeholder:text-tf-muted-foreground", "tf:disabled:cursor-not-allowed tf:disabled:opacity-50", VARIANT_CLASSES[variant], className), ...props }));
 });
-//# sourceMappingURL=textarea.js.map

package/dist/components/primitives/use-dock-reflow.d.ts

@@ -1,12 +1,2 @@
 import { type RefObject } from "react";
-/** Keeps the host page pushed exactly while the docked panel is actually
- * visible. Visibility, not the mode setting or the open prop: a host
- * modal that force-hides (parks) the panel must un-push the page, and
- * the way-is-clear restore must re-push it. The native `toggle` event is
- * the one signal that fires on every show and hide regardless of who
- * drove it — our own show/hide effect, the modal's spec-mandated
- * hide-all-popovers, a meddling host script, the watcher's re-show — so
- * it is the single source of truth here, and the React onToggle prop
- * stays the park detector's alone. */
 export declare function useDockReflow(panelRef: RefObject<HTMLDivElement | null>, dock: "floating" | "sidebar"): void;
-//# sourceMappingURL=use-dock-reflow.d.ts.map

package/dist/components/primitives/use-dock-reflow.js

@@ -2,15 +2,6 @@
 import { useEffect } from "react";
 import { dockReflowFor } from "../../core/dock-reflow.js";
 const REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
-/** Keeps the host page pushed exactly while the docked panel is actually
- * visible. Visibility, not the mode setting or the open prop: a host
- * modal that force-hides (parks) the panel must un-push the page, and
- * the way-is-clear restore must re-push it. The native `toggle` event is
- * the one signal that fires on every show and hide regardless of who
- * drove it — our own show/hide effect, the modal's spec-mandated
- * hide-all-popovers, a meddling host script, the watcher's re-show — so
- * it is the single source of truth here, and the React onToggle prop
- * stays the park detector's alone. */
 export function useDockReflow(panelRef, dock) {
     useEffect(() => {
         const panel = panelRef.current;
@@ -20,16 +11,9 @@ export function useDockReflow(panelRef, dock) {
             return;
         }
         const controller = dockReflowFor(panel.ownerDocument.documentElement);
-        // Both switches the stylesheet answers, answered here too: the OS
-        // preference and the host's data-reduce-motion kill switch — an
-        // inline transition is invisible to those CSS selectors.
         const reduceMotion = () => (panel.ownerDocument.defaultView ?? window).matchMedia(REDUCED_MOTION_QUERY).matches || panel.closest('[data-reduce-motion="true"]') !== null;
         const syncPushToVisibility = () => {
             if (panel.matches(":popover-open")) {
-                // The rendered width, not the nominal 26rem: offsetWidth is
-                // layout width (the sidebar pins scale to 1), and it already
-                // reflects a host root font-size inflating rem and the
-                // max-width clamp on narrow viewports.
                 controller.push(panel.offsetWidth, reduceMotion());
             }
             else {
@@ -37,16 +21,10 @@ export function useDockReflow(panelRef, dock) {
             }
         };
         panel.addEventListener("toggle", syncPushToVisibility);
-        // A dock-mode switch on an already-open panel changes no popover
-        // state and fires no toggle; this one call covers it.
         syncPushToVisibility();
         return () => {
             panel.removeEventListener("toggle", syncPushToVisibility);
-            // Mode switch, close, or unmount: the un-push still animates —
-            // the controller lives on the documentElement's lifetime, which
-            // outlives this panel.
             controller.release();
         };
     }, [panelRef, dock]);
 }
-//# sourceMappingURL=use-dock-reflow.js.map

package/dist/components/primitives/use-swipe-dismiss.d.ts

@@ -1,29 +1,12 @@
 import { type MouseEvent, type PointerEvent } from "react";
 export interface SwipeDismissOptions {
-    /** The axis the dismissing travel moves along. */
     axis: "x" | "y";
-    /** The sign along that axis that travels toward dismissal: +1 for
-     * rightward/downward, -1 for leftward/upward. */
     direction: 1 | -1;
-    /** The surface's open state. Every change of it ends whatever gesture
-     * was in flight (see the effect below for why). */
     open: boolean;
-    /** Gates the whole machine — the docked panel keeps the handlers
-     * mounted (rules of hooks) but must never dismiss by touch. While
-     * false, new gestures are declined, and flipping it mid-gesture
-     * releases the drag with its decoration stripped. */
     enabled?: boolean;
     onDismiss: () => void;
-    /** When set, a drag may only begin on a press inside a matching
-     * descendant — the grab region of a surface whose content scrolls
-     * along the dismissal axis. Absent, the whole panel drags. */
     handleSelector?: string;
 }
-/** The five handlers, all meant for the panel element itself so that
- * currentTarget is always the panel — no ref to forward, and pointer
- * capture retargets the rest of the gesture there. The stylesheet
- * animates what the machine writes: the live offset on
- * `--_tf-swipe-drag`, and `data-tf-swipe-dragging` while a finger owns it. */
 export interface SwipeDismissHandlers {
     onPointerDown: (event: PointerEvent<HTMLElement>) => void;
     onPointerMove: (event: PointerEvent<HTMLElement>) => void;
@@ -32,4 +15,3 @@ export interface SwipeDismissHandlers {
     onClickCapture: (event: MouseEvent<HTMLElement>) => void;
 }
 export declare function useSwipeDismiss({ axis, direction, open, enabled, onDismiss, handleSelector, }: SwipeDismissOptions): SwipeDismissHandlers;
-//# sourceMappingURL=use-swipe-dismiss.d.ts.map

package/dist/components/primitives/use-swipe-dismiss.js

@@ -1,30 +1,9 @@
 "use client";
 import { useCallback, useEffect, useRef, } from "react";
-// The swipe-to-dismiss machine, shared by every surface that leaves with
-// a push: the edge sheet along x toward its own edge, the corner panel
-// down along y. Axis and closing direction are the only gesture parameters;
-// everything else here is a fixed bug that must not be copied twice.
-// The scroll conflict is deliberately NOT a parameter: content that
-// scrolls along the dismissal axis cannot be disambiguated by axis, so
-// such a surface confines the drag to a grab region (`handleSelector`);
-// content scrolling only across the axis lets the axis test arbitrate.
-// Past this fraction of the panel's own extent along the axis, the
-// release commits to a close instead of springing back: far enough that
-// a lazy scroll never dismisses, near enough that a push needn't go all the way.
 const DISMISS_TRAVEL_FRACTION = 0.25;
-// Or past this speed, however far it got: a flick is an intent.
 const DISMISS_VELOCITY_PX_PER_MS = 0.5;
-// How stale a velocity reading may be and still count as a flick: speed is
-// sampled only on pointermove, so without this a flick-then-hold-then-lift
-// dismisses a panel the thumb deliberately parked.
 const FLICK_GOES_STALE_AFTER_MS = 100;
-// Slop before a press becomes a drag. Below it the gesture is undecided
-// and the scrollable content underneath keeps the pointer.
 const DRAG_SLOP_PX = 8;
-/** Takes the drag decoration back off the panel and hands the pointer
- * back. Every way a gesture can end runs this: the marker and offset are
- * written on an element that outlives the close, and left behind they
- * render every later open shoved aside with its slide switched off. */
 function _releasePanel(panel, pointerId) {
     delete panel.dataset.tfSwipeDragging;
     panel.style.removeProperty("--_tf-swipe-drag");
@@ -34,20 +13,8 @@ function _releasePanel(panel, pointerId) {
 }
 export function useSwipeDismiss({ axis, direction, open, enabled = true, onDismiss, handleSelector, }) {
     const drag = useRef(null);
-    // Whether the last gesture ended as a swipe rather than a press — the
-    // one thing the click handler below needs to know.
     const swipedRatherThanTapped = useRef(false);
-    // The panel, remembered from whichever handler last saw it: the open
-    // effect must strip a gesture's decoration with no event to read.
     const panelRef = useRef(null);
-    // Every change of open state ends whatever gesture was in flight. The
-    // flag clears on OPEN only: the exit is a CSS transition (allow-discrete
-    // on display/overlay), so the panel stays hit-testable through the slide
-    // out and a dismissing swipe's compatibility click still lands on the
-    // row under the thumb — the flag must survive the close to swallow it,
-    // and must be gone before a reopened, keyboard-driven panel's Enter
-    // click. The drag releases on every change: a close landing mid-gesture
-    // (Esc, the host) never reaches endDrag or cancelDrag.
     useEffect(() => {
         if (open) {
             swipedRatherThanTapped.current = false;
@@ -58,22 +25,12 @@ export function useSwipeDismiss({ axis, direction, open, enabled = true, onDismi
             _releasePanel(panelRef.current, inFlight.pointerId);
         }
     }, [open, enabled]);
-    // Touch only, and only after the movement proves itself along the axis:
-    // a thumb travelling across it keeps scrolling; a mouse has Esc.
     const beginDrag = useCallback((event) => {
-        // Whatever the last gesture was, it is over. Clearing here — before
-        // every early return — bounds the swallow to a single click: the
-        // flag never waits for the first tap after the surface reopens.
         swipedRatherThanTapped.current = false;
-        // Recorded before every early return: the open effect needs the
-        // element even for a gesture this handler declines to track.
         panelRef.current = event.currentTarget;
         if (!enabled || !_pressBeginsDrag(event, handleSelector)) {
             return;
         }
-        // A second finger doesn't get to retarget a gesture already under way:
-        // overwriting the state would strand the first pointer's cleanup and
-        // leave the marker and offset on the panel for the rest of the session.
         if (drag.current !== null) {
             return;
         }
@@ -88,8 +45,6 @@ export function useSwipeDismiss({ axis, direction, open, enabled = true, onDismi
     }, [axis, direction]);
     const endDrag = useCallback((event) => {
         const state = drag.current;
-        // Only the pointer that owns the gesture ends it — and it always takes
-        // the decoration off on its way out, committed or not.
         if (event.pointerId !== state?.pointerId) {
             return;
         }
@@ -99,19 +54,11 @@ export function useSwipeDismiss({ axis, direction, open, enabled = true, onDismi
         if (!state.committed) {
             return;
         }
-        // A committed swipe moved the panel under the thumb, so the press was
-        // never a tap — yet the touch sequence is about to synthesize a click
-        // where it started, and pointer capture doesn't retarget click on
-        // WebKit: a swipe begun on a conversation row would open it.
         swipedRatherThanTapped.current = true;
         if (_dragDismisses(state, _sampleOf(event, axis), panel, axis, direction)) {
             onDismiss();
         }
     }, [axis, direction, onDismiss]);
-    // The browser taking the gesture away is not a dismissal: a pinch
-    // starting, or the UA claiming the pointer for its own pan, cancels with
-    // the finger still down and no decision made — the panel goes back to
-    // rest. Never shared with endDrag, which would close under the thumb.
     const cancelDrag = useCallback((event) => {
         const state = drag.current;
         if (event.pointerId !== state?.pointerId) {
@@ -120,9 +67,6 @@ export function useSwipeDismiss({ axis, direction, open, enabled = true, onDismi
         drag.current = null;
         _releasePanel(event.currentTarget, event.pointerId);
     }, []);
-    // Capture phase, so the content underneath never sees it. One click only:
-    // the flag is set by a committed swipe and cleared by the next press, the
-    // next open, or this handler — it can never outlive the gesture.
     const swallowTheClickAfterASwipe = useCallback((event) => {
         if (!swipedRatherThanTapped.current) {
             return;
@@ -147,18 +91,10 @@ function _sampleOf(event, axis) {
         timeStamp: event.timeStamp,
     };
 }
-/** Whether a press is a candidate drag at all: touch, not on the panel
- *  element itself, and inside the grab region when one is declared. */
 function _pressBeginsDrag(event, handleSelector) {
-    // A press that lands on the panel element itself belongs to the
-    // surface (the dialog's ::backdrop is the only place that happens),
-    // not to us.
     if (event.pointerType !== "touch" || event.target === event.currentTarget) {
         return false;
     }
-    // The grab-region gate: content that scrolls along the dismissal
-    // axis makes a bare axis test a coin flip, so such surfaces confine
-    // the gesture to a handle and presses elsewhere never dismiss.
     if (handleSelector !== undefined &&
         !(event.target instanceof Element &&
             event.target.closest(handleSelector) !== null)) {
@@ -177,36 +113,24 @@ function _beginDragStateOf(sample) {
         committed: false,
     };
 }
-/** Advances the gesture by one move: an undecided press is either handed
- *  to the content (null) or committed to the panel; a committed drag
- *  records its speed and writes the live offset. */
 function _trackedDragOf(state, sample, panel, direction) {
     const dMain = sample.main - state.startMain;
     const dCross = sample.cross - state.startCross;
-    // Travel toward dismissal counts; the other way is nothing, and the
-    // panel never stretches past its resting place.
     const closing = direction * dMain;
     if (!state.committed) {
         if (Math.abs(dCross) >= DRAG_SLOP_PX &&
             Math.abs(dCross) >= Math.abs(dMain)) {
-            // Decided across the axis: the gesture is the content's, not ours.
             return null;
         }
         if (closing < DRAG_SLOP_PX) {
             return state;
         }
         state.committed = true;
-        // The marker first, and the capture defensively: a pointer that
-        // ended between two moves makes setPointerCapture throw, and losing
-        // the capture only costs the tail of the gesture — losing the marker
-        // would leave the transition running under the thumb.
         panel.dataset.tfSwipeDragging = "";
         try {
             panel.setPointerCapture(sample.pointerId);
         }
         catch {
-            // Capture is an optimisation here; the handlers are on the
-            // panel and the gesture stays inside it either way.
         }
     }
     const elapsed = sample.timeStamp - state.lastT;
@@ -216,28 +140,13 @@ function _trackedDragOf(state, sample, panel, direction) {
         state.lastT = sample.timeStamp;
     }
     const offset = Math.max(0, closing);
-    // A DOM style property, not the banned JSX style prop: the live
-    // offset is a per-frame number and the stylesheet reads it through
-    // the surface's transform variable.
     panel.style.setProperty("--_tf-swipe-drag", `${String(direction * offset)}px`);
     return state;
 }
-/** The release verdict for a committed drag: a flick still fresh at the
- *  lift, or travel past the panel's own quarter, dismisses. */
 function _dragDismisses(state, sample, panel, axis, direction) {
-    // Where the panel actually ended up, not how far the finger went: a
-    // swipe pulled back past rest clamps to rest (the Math.max above) and
-    // must spring back too — |dMain| would count the pull-back as travel
-    // and dismiss the panel the finger just rescued.
     const travelled = Math.max(0, direction * (sample.main - state.startMain));
-    // A speed nobody has measured recently is not a flick: velocity is
-    // sampled on pointermove alone, so a finger that flicked, stopped and
-    // lifted still carries the flick's number. Parking means parking.
     const stillMoving = sample.timeStamp - state.lastT <= FLICK_GOES_STALE_AFTER_MS;
     const flicked = stillMoving && direction * state.velocity > DISMISS_VELOCITY_PX_PER_MS;
-    // The panel's own extent, not the viewport: capped below nominal on
-    // the narrowest phones, a quarter of nominal would be a third on screen.
     const extent = axis === "x" ? panel.offsetWidth : panel.offsetHeight;
     return flicked || travelled > extent * DISMISS_TRAVEL_FRACTION;
 }
-//# sourceMappingURL=use-swipe-dismiss.js.map

package/dist/components/provider-chip.d.ts

@@ -1,25 +1,8 @@
 import type { SubscriptionStatus } from "../contract/subscriptions.js";
-/** The shelf row below the composer slab when no model menu is served.
- *  Renders nothing when there is nothing to connect — the composer
- *  composite then keeps today's geometry. Tolerates a missing provider
- *  like the composer's paperclip does (welcome-branch tests render the
- *  view bare). */
 export declare function ProviderChipShelf(): import("react").JSX.Element | null;
-/** The account chip itself, shelf-row-agnostic and CONTROLLED: the
- *  no-menu shelf above mounts it in its own row, the model picker's
- *  shelf mounts it beside the picker chip in a shared one. The
- *  hosting shelf owns the open state — that is what makes the shared
- *  row's one-menu-at-most invariant structural — and consumes the
- *  parked connect ask; this chip only renders and reports. */
 export declare function ProviderChip({ statuses, open, onOpenChange, fundingNote, }: {
     statuses: SubscriptionStatus[];
     open: boolean;
     onOpenChange: (open: boolean) => void;
-    /** One caller-owned sentence relating the surrounding surface to the
-     *  plan — the model picker's shelf passes "models your plan serves run
-     *  on it…" because a pick can leave the plan's servable set; the
-     *  no-menu shelf passes nothing, since without picks the sections' own
-     *  included-usage copy already answers who pays. */
     fundingNote?: string;
 }): import("react").JSX.Element;
-//# sourceMappingURL=provider-chip.d.ts.map