@moldable-ai/ui 0.2.19 → 0.2.21

package/dist/components/ui/message-scroller-layout-stability.d.ts

@@ -0,0 +1,33 @@
+import { type RefObject } from 'react';
+type ScrollToEnd = (options?: {
+    behavior?: ScrollBehavior;
+}) => boolean;
+type AnchorPosition = {
+    element: HTMLElement;
+    top: number;
+    bottom: number;
+};
+export type MessageScrollerLayoutSnapshot = {
+    anchors: AnchorPosition[];
+    atEnd: boolean;
+    scrollHeight: number;
+};
+export declare function isMessageScrollerAtEnd(viewport: HTMLElement): boolean;
+export declare function captureMessageScrollerLayout(viewport: HTMLElement): MessageScrollerLayoutSnapshot;
+/**
+ * Preserve the first previously visible stable leaf when content above it
+ * changes height. Native scroll anchoring may already have done this; in that
+ * case the measured delta is zero and this is deliberately a no-op.
+ */
+export declare function restoreMessageScrollerAnchor(viewport: HTMLElement, snapshot: MessageScrollerLayoutSnapshot): boolean;
+/**
+ * Complements shadcn's message scroller for mutable chat rows. The upstream
+ * primitive handles appends, prepends, and explicit jumps well, but a nested
+ * disclosure shrinking inside an existing row can look like user scroll
+ * intent. We remember whether the viewport was following the end before the
+ * resize and restore that mode, or preserve a visible content leaf when the
+ * user is reading higher in the transcript.
+ */
+export declare function useMessageScrollerLayoutStability(viewportRef: RefObject<HTMLElement | null>, scrollToEnd: ScrollToEnd): void;
+export {};
+//# sourceMappingURL=message-scroller-layout-stability.d.ts.map

package/dist/components/ui/message-scroller-layout-stability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-scroller-layout-stability.d.ts","sourceRoot":"","sources":["../../../src/components/ui/message-scroller-layout-stability.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAA;AAQzD,KAAK,WAAW,GAAG,CAAC,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,cAAc,CAAA;CAAE,KAAK,OAAO,CAAA;AAEvE,KAAK,cAAc,GAAG;IACpB,OAAO,EAAE,WAAW,CAAA;IACpB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG;IAC1C,OAAO,EAAE,cAAc,EAAE,CAAA;IACzB,KAAK,EAAE,OAAO,CAAA;IACd,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAWD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAKrE;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,WAAW,GACpB,6BAA6B,CAoB/B;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,WAAW,EACrB,QAAQ,EAAE,6BAA6B,GACtC,OAAO,CAcT;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAC/C,WAAW,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EAC1C,WAAW,EAAE,WAAW,QAqGzB"}

package/dist/components/ui/message-scroller-layout-stability.js

@@ -0,0 +1,153 @@
+import { useEffect, useRef } from 'react';
+const END_THRESHOLD_PX = 8;
+const POSITION_EPSILON_PX = 0.5;
+const USER_SCROLL_GRACE_MS = 300;
+const CONTENT_ANCHOR_SELECTOR = '[data-message-scroll-anchor]';
+const MESSAGE_ANCHOR_SELECTOR = '[data-message-id]';
+function relativePosition(element, viewport) {
+    const elementRect = element.getBoundingClientRect();
+    const viewportRect = viewport.getBoundingClientRect();
+    return {
+        top: elementRect.top - viewportRect.top,
+        bottom: elementRect.bottom - viewportRect.top,
+    };
+}
+export function isMessageScrollerAtEnd(viewport) {
+    return (viewport.scrollHeight - viewport.scrollTop - viewport.clientHeight <=
+        END_THRESHOLD_PX);
+}
+export function captureMessageScrollerLayout(viewport) {
+    // Prefer stable leaves within a message. A top-level message's own top does
+    // not move when content collapses inside it, so it is only a fallback when
+    // the visible leaf itself was removed by the disclosure transition.
+    const contentAnchors = Array.from(viewport.querySelectorAll(CONTENT_ANCHOR_SELECTOR));
+    const messageAnchors = Array.from(viewport.querySelectorAll(MESSAGE_ANCHOR_SELECTOR));
+    const anchors = [...contentAnchors, ...messageAnchors].map((element) => ({
+        element,
+        ...relativePosition(element, viewport),
+    }));
+    return {
+        anchors,
+        atEnd: isMessageScrollerAtEnd(viewport),
+        scrollHeight: viewport.scrollHeight,
+    };
+}
+/**
+ * Preserve the first previously visible stable leaf when content above it
+ * changes height. Native scroll anchoring may already have done this; in that
+ * case the measured delta is zero and this is deliberately a no-op.
+ */
+export function restoreMessageScrollerAnchor(viewport, snapshot) {
+    const anchor = snapshot.anchors.find(({ element, top, bottom }) => {
+        if (!element.isConnected)
+            return false;
+        const current = element.getBoundingClientRect();
+        return current.height > 0 && bottom > 0 && top < viewport.clientHeight;
+    });
+    if (!anchor)
+        return false;
+    const current = relativePosition(anchor.element, viewport);
+    const delta = current.top - anchor.top;
+    if (Math.abs(delta) <= POSITION_EPSILON_PX)
+        return false;
+    viewport.scrollTop += delta;
+    return true;
+}
+/**
+ * Complements shadcn's message scroller for mutable chat rows. The upstream
+ * primitive handles appends, prepends, and explicit jumps well, but a nested
+ * disclosure shrinking inside an existing row can look like user scroll
+ * intent. We remember whether the viewport was following the end before the
+ * resize and restore that mode, or preserve a visible content leaf when the
+ * user is reading higher in the transcript.
+ */
+export function useMessageScrollerLayoutStability(viewportRef, scrollToEnd) {
+    const snapshotRef = useRef(null);
+    const followEndRef = useRef(true);
+    const userInteractingRef = useRef(false);
+    const suspendStabilityUntilRef = useRef(0);
+    useEffect(() => {
+        const viewport = viewportRef.current;
+        if (!viewport || typeof ResizeObserver === 'undefined')
+            return;
+        snapshotRef.current = captureMessageScrollerLayout(viewport);
+        followEndRef.current = snapshotRef.current.atEnd;
+        let frame = 0;
+        const suspendForUserScroll = () => {
+            suspendStabilityUntilRef.current = Date.now() + USER_SCROLL_GRACE_MS;
+        };
+        const isUserScrolling = () => userInteractingRef.current ||
+            Date.now() < suspendStabilityUntilRef.current;
+        const handleWheel = (event) => {
+            suspendForUserScroll();
+            if (event.deltaY < 0)
+                followEndRef.current = false;
+            snapshotRef.current = captureMessageScrollerLayout(viewport);
+        };
+        const handlePointerDown = () => {
+            userInteractingRef.current = true;
+            suspendForUserScroll();
+            snapshotRef.current = captureMessageScrollerLayout(viewport);
+        };
+        const handlePointerUp = () => {
+            userInteractingRef.current = false;
+            suspendForUserScroll();
+        };
+        const captureAfterIntentionalScroll = () => {
+            const previous = snapshotRef.current;
+            const heightChanged = previous &&
+                Math.abs(previous.scrollHeight - viewport.scrollHeight) >
+                    POSITION_EPSILON_PX;
+            // A browser clamp caused by content shrinking is layout, not user intent.
+            // Explicit wheel or scrollbar interaction always wins over that heuristic.
+            if (isUserScrolling() || !heightChanged) {
+                if (isUserScrolling())
+                    suspendForUserScroll();
+                followEndRef.current = isMessageScrollerAtEnd(viewport);
+                snapshotRef.current = captureMessageScrollerLayout(viewport);
+            }
+        };
+        const resizeObserver = new ResizeObserver(() => {
+            window.cancelAnimationFrame(frame);
+            frame = window.requestAnimationFrame(() => {
+                const previous = snapshotRef.current;
+                if (isUserScrolling()) {
+                    snapshotRef.current = captureMessageScrollerLayout(viewport);
+                    return;
+                }
+                if (previous) {
+                    if (followEndRef.current) {
+                        // Public API resets the primitive's internal mode as well as the
+                        // DOM position after a shrink was mistaken for an upward scroll.
+                        scrollToEnd({ behavior: 'auto' });
+                    }
+                    else {
+                        restoreMessageScrollerAnchor(viewport, previous);
+                    }
+                }
+                snapshotRef.current = captureMessageScrollerLayout(viewport);
+            });
+        });
+        const content = viewport.querySelector('[data-slot="message-scroller-content"]');
+        if (content)
+            resizeObserver.observe(content);
+        viewport.addEventListener('wheel', handleWheel, { passive: true });
+        viewport.addEventListener('pointerdown', handlePointerDown, {
+            passive: true,
+        });
+        window.addEventListener('pointerup', handlePointerUp, { passive: true });
+        window.addEventListener('pointercancel', handlePointerUp, { passive: true });
+        viewport.addEventListener('scroll', captureAfterIntentionalScroll, {
+            passive: true,
+        });
+        return () => {
+            window.cancelAnimationFrame(frame);
+            resizeObserver.disconnect();
+            viewport.removeEventListener('wheel', handleWheel);
+            viewport.removeEventListener('pointerdown', handlePointerDown);
+            window.removeEventListener('pointerup', handlePointerUp);
+            window.removeEventListener('pointercancel', handlePointerUp);
+            viewport.removeEventListener('scroll', captureAfterIntentionalScroll);
+        };
+    }, [scrollToEnd, viewportRef]);
+}

package/dist/components/ui/message-scroller-policy.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Pure scroll-ownership policy for the chat transcript.
+ *
+ * One rule outranks everything: the reader's scroll intent wins instantly.
+ * Programmatic motion is explicit — every scroll the primitive itself starts
+ * declares a target — so any viewport movement that was not commanded is, by
+ * definition, the user. That includes native scrollbar drags, which emit no
+ * wheel, pointer, or key events at all.
+ *
+ * The previous stack (upstream shadcn primitive + a local layout-stability
+ * patch) ran two competing controllers with grace timers and an
+ * "autoscrolling" veto window; a scrollbar drag during streaming could not
+ * release follow mode, so the next content growth yanked the viewport back
+ * down. This module replaces both with a single mode machine, mirroring the
+ * MessageScrollerPolicy used by the iOS transcript.
+ */
+export type MessageScrollerMode = 
+/** Pinned to the newest output; content growth keeps the end in view. */
+'following-end'
+/** The reader owns the position; the scroller never moves it. */
+ | 'free'
+/** A turn anchor is pinned near the viewport top while output streams. */
+ | 'anchored'
+/** A commanded jump is in flight; resolves on arrival or user motion. */
+ | 'settling-jump';
+export type MessageScrollerResizeAction = 'stick-to-end' | 'reanchor' | 'preserve-reading-position' | 'none';
+export interface MessageScrollerScrollEvent {
+    scrollTop: number;
+    lastScrollTop: number;
+    atEnd: boolean;
+}
+export declare class MessageScrollerPolicy {
+    mode: MessageScrollerMode;
+    autoScroll: boolean;
+    /**
+     * The destination of the programmatic scroll currently in flight, if any.
+     * Smooth scrolls pass through many intermediate positions; they count as
+     * our own motion only while they keep approaching this target.
+     */
+    programmaticTarget: number | null;
+    private lastDistanceToTarget;
+    constructor(autoScroll: boolean);
+    get followsEnd(): boolean;
+    /** Declares a programmatic scroll about to start toward `target`. */
+    beginProgrammaticScroll(target: number): void;
+    /**
+     * Abandons an in-flight programmatic scroll that will never arrive (the
+     * animation was dropped or its target became unreachable). Subsequent
+     * movement is classified as the reader's.
+     */
+    cancelProgrammaticScroll(): void;
+    /**
+     * Classifies a scroll event and returns true when it was the reader's own
+     * motion. Programmatic motion is recognized by monotonic approach to the
+     * declared target; everything else — wheel, trackpad, keyboard, scrollbar
+     * drag, momentum — is user motion and takes ownership immediately.
+     */
+    handleScrollEvent(event: MessageScrollerScrollEvent): boolean;
+    /**
+     * Explicit input intent (wheel, touch, scroll keys). Upward intent releases
+     * immediately — before the scroll event lands — so a resize racing the
+     * same frame cannot pull the viewport down first.
+     */
+    handleUserIntent(direction: 'up' | 'down' | 'unknown'): void;
+    /** How a content size change may move the viewport in the current mode. */
+    resizeAction(): MessageScrollerResizeAction;
+    /** A new turn anchor was appended and commanded into view. */
+    anchorToTurn(): void;
+    beginJump(): void;
+    jumpToEnd(): void;
+    jumpToStart(): void;
+    release(): void;
+}
+//# sourceMappingURL=message-scroller-policy.d.ts.map

package/dist/components/ui/message-scroller-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-scroller-policy.d.ts","sourceRoot":"","sources":["../../../src/components/ui/message-scroller-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,MAAM,mBAAmB;AAC7B,yEAAyE;AACvE,eAAe;AACjB,iEAAiE;GAC/D,MAAM;AACR,0EAA0E;GACxE,UAAU;AACZ,yEAAyE;GACvE,eAAe,CAAA;AAEnB,MAAM,MAAM,2BAA2B,GACnC,cAAc,GACd,UAAU,GACV,2BAA2B,GAC3B,MAAM,CAAA;AAKV,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,OAAO,CAAA;CACf;AAED,qBAAa,qBAAqB;IAChC,IAAI,EAAE,mBAAmB,CAAA;IACzB,UAAU,EAAE,OAAO,CAAA;IACnB;;;;OAIG;IACH,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAO;IACxC,OAAO,CAAC,oBAAoB,CAA2B;gBAE3C,UAAU,EAAE,OAAO;IAK/B,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,qEAAqE;IACrE,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK7C;;;;OAIG;IACH,wBAAwB,IAAI,IAAI;IAOhC;;;;;OAKG;IACH,iBAAiB,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO;IA6B7D;;;;OAIG;IACH,gBAAgB,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI;IAK5D,2EAA2E;IAC3E,YAAY,IAAI,2BAA2B;IAgB3C,8DAA8D;IAC9D,YAAY,IAAI,IAAI;IAIpB,SAAS,IAAI,IAAI;IAIjB,SAAS,IAAI,IAAI;IAIjB,WAAW,IAAI,IAAI;IAInB,OAAO,IAAI,IAAI;CAGhB"}

package/dist/components/ui/message-scroller-policy.js

@@ -0,0 +1,129 @@
+/**
+ * Pure scroll-ownership policy for the chat transcript.
+ *
+ * One rule outranks everything: the reader's scroll intent wins instantly.
+ * Programmatic motion is explicit — every scroll the primitive itself starts
+ * declares a target — so any viewport movement that was not commanded is, by
+ * definition, the user. That includes native scrollbar drags, which emit no
+ * wheel, pointer, or key events at all.
+ *
+ * The previous stack (upstream shadcn primitive + a local layout-stability
+ * patch) ran two competing controllers with grace timers and an
+ * "autoscrolling" veto window; a scrollbar drag during streaming could not
+ * release follow mode, so the next content growth yanked the viewport back
+ * down. This module replaces both with a single mode machine, mirroring the
+ * MessageScrollerPolicy used by the iOS transcript.
+ */
+const SCROLL_EPSILON_PX = 0.5;
+const TARGET_ARRIVAL_PX = 1;
+export class MessageScrollerPolicy {
+    mode;
+    autoScroll;
+    /**
+     * The destination of the programmatic scroll currently in flight, if any.
+     * Smooth scrolls pass through many intermediate positions; they count as
+     * our own motion only while they keep approaching this target.
+     */
+    programmaticTarget = null;
+    lastDistanceToTarget = Number.POSITIVE_INFINITY;
+    constructor(autoScroll) {
+        this.autoScroll = autoScroll;
+        this.mode = autoScroll ? 'following-end' : 'free';
+    }
+    get followsEnd() {
+        return this.mode === 'following-end';
+    }
+    /** Declares a programmatic scroll about to start toward `target`. */
+    beginProgrammaticScroll(target) {
+        this.programmaticTarget = target;
+        this.lastDistanceToTarget = Number.POSITIVE_INFINITY;
+    }
+    /**
+     * Abandons an in-flight programmatic scroll that will never arrive (the
+     * animation was dropped or its target became unreachable). Subsequent
+     * movement is classified as the reader's.
+     */
+    cancelProgrammaticScroll() {
+        if (this.programmaticTarget === null)
+            return;
+        this.programmaticTarget = null;
+        this.lastDistanceToTarget = Number.POSITIVE_INFINITY;
+        if (this.mode === 'settling-jump')
+            this.mode = 'free';
+    }
+    /**
+     * Classifies a scroll event and returns true when it was the reader's own
+     * motion. Programmatic motion is recognized by monotonic approach to the
+     * declared target; everything else — wheel, trackpad, keyboard, scrollbar
+     * drag, momentum — is user motion and takes ownership immediately.
+     */
+    handleScrollEvent(event) {
+        if (this.programmaticTarget !== null) {
+            const distance = Math.abs(event.scrollTop - this.programmaticTarget);
+            if (distance <= TARGET_ARRIVAL_PX) {
+                this.programmaticTarget = null;
+                this.lastDistanceToTarget = Number.POSITIVE_INFINITY;
+                if (this.mode === 'settling-jump') {
+                    this.mode = event.atEnd && this.autoScroll ? 'following-end' : 'free';
+                }
+                return false;
+            }
+            if (distance <= this.lastDistanceToTarget + SCROLL_EPSILON_PX) {
+                this.lastDistanceToTarget = distance;
+                return false;
+            }
+            // Motion away from our own target: the reader grabbed the viewport
+            // mid-flight. The jump loses.
+            this.programmaticTarget = null;
+            this.lastDistanceToTarget = Number.POSITIVE_INFINITY;
+        }
+        const movedUp = event.scrollTop < event.lastScrollTop - SCROLL_EPSILON_PX;
+        const movedDown = event.scrollTop > event.lastScrollTop + SCROLL_EPSILON_PX;
+        if (!movedUp && !movedDown)
+            return false;
+        this.mode = event.atEnd && this.autoScroll ? 'following-end' : 'free';
+        return true;
+    }
+    /**
+     * Explicit input intent (wheel, touch, scroll keys). Upward intent releases
+     * immediately — before the scroll event lands — so a resize racing the
+     * same frame cannot pull the viewport down first.
+     */
+    handleUserIntent(direction) {
+        if (this.mode === 'following-end' && direction === 'down')
+            return;
+        this.mode = 'free';
+    }
+    /** How a content size change may move the viewport in the current mode. */
+    resizeAction() {
+        switch (this.mode) {
+            case 'following-end':
+                return 'stick-to-end';
+            case 'anchored':
+                return 'reanchor';
+            case 'settling-jump':
+                return 'none';
+            case 'free':
+                // A collapsing disclosure above the reader must not shift what they
+                // are looking at. Native scroll anchoring usually handles it; the
+                // caller re-pins the first visible stable leaf when it does not.
+                return 'preserve-reading-position';
+        }
+    }
+    /** A new turn anchor was appended and commanded into view. */
+    anchorToTurn() {
+        this.mode = 'anchored';
+    }
+    beginJump() {
+        this.mode = 'settling-jump';
+    }
+    jumpToEnd() {
+        this.mode = this.autoScroll ? 'following-end' : 'free';
+    }
+    jumpToStart() {
+        this.mode = 'free';
+    }
+    release() {
+        this.mode = 'free';
+    }
+}

package/dist/components/ui/message-scroller-primitive.d.ts

@@ -0,0 +1,55 @@
+import * as React from 'react';
+import { type MessageScrollerDefaultScrollPosition, type MessageScrollerScrollAlign, type MessageScrollerScrollOptions, type MessageScrollerScrollable, type MessageScrollerVisibilityState } from './message-scroller-controller';
+type MessageScrollerProviderProps = {
+    children?: React.ReactNode;
+    autoScroll?: boolean;
+    defaultScrollPosition?: MessageScrollerDefaultScrollPosition;
+    scrollEdgeThreshold?: number;
+    scrollPreviousItemPeek?: number;
+    scrollMargin?: number;
+};
+declare function MessageScrollerProvider({ autoScroll, children, defaultScrollPosition, scrollEdgeThreshold, scrollPreviousItemPeek, scrollMargin, }: MessageScrollerProviderProps): import("react/jsx-runtime").JSX.Element;
+type MessageScrollerProps = React.ComponentProps<'div'>;
+declare function MessageScrollerRoot({ children, ...props }: MessageScrollerProps): import("react/jsx-runtime").JSX.Element;
+type MessageScrollerViewportProps = React.ComponentProps<'div'> & {
+    preserveScrollOnPrepend?: boolean;
+};
+declare function MessageScrollerViewport({ 'aria-label': ariaLabel, children, onKeyDown, onScroll, onTouchMove, onWheel, preserveScrollOnPrepend, ref, role, tabIndex, ...props }: MessageScrollerViewportProps): import("react/jsx-runtime").JSX.Element;
+type MessageScrollerContentProps = React.ComponentProps<'div'> & {
+    spacerClassName?: string;
+};
+declare function MessageScrollerContent({ 'aria-relevant': ariaRelevant, children, ref, role, spacerClassName, ...props }: MessageScrollerContentProps): import("react/jsx-runtime").JSX.Element;
+type MessageScrollerItemProps = React.ComponentProps<'div'> & {
+    messageId?: string;
+    scrollAnchor?: boolean;
+};
+declare function MessageScrollerItem({ messageId, ref, scrollAnchor, ...props }: MessageScrollerItemProps): import("react/jsx-runtime").JSX.Element;
+type MessageScrollerButtonDirection = 'start' | 'end';
+type MessageScrollerButtonRenderState = {
+    active: boolean;
+    direction: MessageScrollerButtonDirection;
+};
+type MessageScrollerButtonProps = Omit<React.ComponentProps<'button'>, 'children'> & {
+    behavior?: ScrollBehavior;
+    children?: React.ReactNode;
+    direction?: MessageScrollerButtonDirection;
+    render?: React.ReactElement<Record<string, unknown>> | ((props: Record<string, unknown>, state: MessageScrollerButtonRenderState) => React.ReactElement | null);
+};
+declare function MessageScrollerButton({ behavior, children, className, direction, onClick, render, tabIndex, type, ...props }: MessageScrollerButtonProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+declare function useMessageScroller(): {
+    scrollToEnd: (options?: MessageScrollerScrollOptions) => boolean;
+    scrollToMessage: (messageId: string, options?: MessageScrollerScrollOptions) => boolean;
+    scrollToStart: (options?: MessageScrollerScrollOptions) => boolean;
+};
+declare function useMessageScrollerScrollable(): MessageScrollerScrollable;
+declare function useMessageScrollerVisibility(): MessageScrollerVisibilityState;
+declare const MessageScroller: {
+    Provider: typeof MessageScrollerProvider;
+    Root: typeof MessageScrollerRoot;
+    Viewport: typeof MessageScrollerViewport;
+    Content: typeof MessageScrollerContent;
+    Item: typeof MessageScrollerItem;
+    Button: typeof MessageScrollerButton;
+};
+export { MessageScroller, useMessageScroller, useMessageScrollerScrollable, useMessageScrollerVisibility, type MessageScrollerDefaultScrollPosition, type MessageScrollerScrollAlign, type MessageScrollerScrollOptions, type MessageScrollerScrollable, type MessageScrollerVisibilityState, };
+//# sourceMappingURL=message-scroller-primitive.d.ts.map

package/dist/components/ui/message-scroller-primitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-scroller-primitive.d.ts","sourceRoot":"","sources":["../../../src/components/ui/message-scroller-primitive.tsx"],"names":[],"mappings":"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"}