@exegia/corpora-ui 1.0.0 → 3.0.0

package/dist-lib/components/blocks/sidebar/index.d.ts

@@ -0,0 +1,15 @@
+import { AISidebar } from './ai-sidebar';
+import { MarqueeLabel } from './marquee-label.tsx';
+import { ResourceRow } from './sidebar-row.tsx';
+import { SidebarIcon } from './sidebar-icon.tsx';
+export { useAISidebar, type IUseAISidebarOptions } from './use-ai-sidebar.ts';
+export { useAISidebarActions, useAISidebarState, } from './use-ai-sidebar-state.ts';
+export type * from './type.ts';
+export { aiSidebarActiveIdAtom, aiSidebarAnnouncementAtom, aiSidebarDraggingIdAtom, aiSidebarDropTargetAtom, aiSidebarExpandedIdsAtom, aiSidebarFlatAtom, aiSidebarFocusedIdAtom, aiSidebarHoverActiveAtom, aiSidebarHoveredIdAtom, aiSidebarItemsAtom, aiSidebarMenuOpenIdAtom, aiSidebarMovePendingAtom, aiSidebarRenamingIdAtom, aiSidebarRowDraggingAtom, aiSidebarRowDropAtom, aiSidebarRowExpandedAtom, aiSidebarRowFocusedAtom, aiSidebarRowHoveredAtom, aiSidebarRowMenuOpenAtom, aiSidebarRowRenamingAtom, aiSidebarRowSelectedAtom, aiSidebarStateAtom, cancelAISidebarRenameAtom, clearAISidebarHoverAtom, closeAISidebarMenuAtom, collapseAISidebarRowAtom, collapseAllAISidebarRowsAtom, endAISidebarDragAtom, expandAISidebarRowAtom, expandAllAISidebarRowsAtom, focusAISidebarRowAtom, moveAISidebarRowAtom, openAISidebarMenuAtom, removeAISidebarInstance, renameAISidebarRowAtom, resetAISidebarAtom, revealAISidebarRowAtom, selectAISidebarRowAtom, setAISidebarHoveredAtom, setAISidebarItemsAtom, startAISidebarRenameAtom, toggleAISidebarRowAtom, } from './ai-sidebar-atom.ts';
+export { AISidebar, MarqueeLabel, ResourceRow, SidebarIcon };
+export declare const Sidebar: {
+    Wrapper: typeof AISidebar;
+    MarqueeLabel: typeof MarqueeLabel;
+    Row: import('react').MemoExoticComponent<({ row }: import('./type.ts').IResourceRowProps) => import("react").JSX.Element>;
+    Icon: typeof SidebarIcon;
+};

package/dist-lib/components/blocks/sidebar/sidebar-context.d.ts

@@ -0,0 +1,3 @@
+import { IAISidebarContextValue } from './type.ts';
+export declare const AISidebarContext: import('react').Context<IAISidebarContextValue | null>;
+export declare function useAISidebarContext(): IAISidebarContextValue;

package/dist-lib/components/blocks/sidebar/sidebar-icon.d.ts

@@ -0,0 +1,2 @@
+import { ISidebarResource } from './type.ts';
+export declare function SidebarIcon(item: ISidebarResource, expanded: boolean): import("react").JSX.Element;

package/dist-lib/components/blocks/sidebar/sidebar-row.d.ts

@@ -0,0 +1,4 @@
+import { IResourceRowProps } from './type';
+declare function ResourceRowImpl({ row }: IResourceRowProps): import("react").JSX.Element;
+export declare const ResourceRow: import('react').MemoExoticComponent<typeof ResourceRowImpl>;
+export {};

package/dist-lib/components/blocks/sidebar/type.d.ts

@@ -0,0 +1,245 @@
+import { ReactElement, ReactNode, DragEvent, KeyboardEvent } from 'react';
+export type TSidebarResourceKind = "folder" | "project" | "file" | "bookmark";
+export interface ISidebarResource {
+    id: string;
+    label: string;
+    kind: TSidebarResourceKind;
+    children?: ISidebarResource[];
+    disabled?: boolean;
+}
+export type TSidebarResourceDropPosition = "before" | "inside" | "after";
+export interface ISidebarResourceMove {
+    itemId: string;
+    targetId: string | null;
+    position: TSidebarResourceDropPosition;
+}
+export interface ISidebarResourceMenuControls {
+    close: () => void;
+    rename: () => void;
+}
+/** Key for one sidebar's state in the store. Any stable string;
+ * `useAISidebar` generates one when you don't pass it. */
+export type TAISidebarInstanceId = string;
+/** Options for `useAISidebar`. `items`, `activeId` and `expandedIds` are
+ * each controlled when passed and hook-owned via their `default*` twin
+ * otherwise. */
+export interface IUseAISidebarOptions {
+    /** Key this sidebar's state under a name your app can address —
+     * `useAISidebarState("app-resources")` / `useAISidebarActions(...)` reach
+     * it from anywhere under `ExegiaProvider`. Without one the hook generates
+     * a key and the state is dropped when the component unmounts. */
+    sidebarId?: TAISidebarInstanceId;
+    items?: ISidebarResource[];
+    defaultItems?: ISidebarResource[];
+    onItemsChange?: (items: ISidebarResource[]) => void;
+    /** Reject the promise to roll the optimistic move back. */
+    onMove?: (move: ISidebarResourceMove) => void | Promise<void>;
+    onMoveError?: (error: unknown, move: ISidebarResourceMove) => void;
+    onRename?: (item: ISidebarResource, label: string) => void | Promise<void>;
+    activeId?: string | null;
+    defaultActiveId?: string | null;
+    onActiveChange?: (id: string) => void;
+    expandedIds?: string[];
+    defaultExpandedIds?: string[];
+    onExpandedChange?: (ids: string[]) => void;
+}
+/** Everything the sidebar can do, callable from outside the block — a
+ * toolbar, a command palette, a route change. Returned by `useAISidebar`
+ * and accepted by `<AISidebar controller={…} />`. */
+export interface IAISidebarController {
+    /** The key this sidebar's state is stored under. */
+    sidebarId: TAISidebarInstanceId;
+    items: ISidebarResource[];
+    /** Visible rows in order, each with its depth and parent id. */
+    flat: IFlatResource[];
+    getItem: (id: string) => ISidebarResource | undefined;
+    selectedId: string | null;
+    select: (id: string) => void;
+    expandedIds: ReadonlySet<string>;
+    isExpanded: (id: string) => boolean;
+    expand: (id: string) => void;
+    collapse: (id: string) => void;
+    toggleExpanded: (id: string) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    /** Open every ancestor of `id`, leaving the rest of the tree alone. */
+    reveal: (id: string) => void;
+    /** Roving-focus target. `focus` also moves DOM focus to the row. */
+    focusedId: string | null;
+    focus: (id: string) => void;
+    renamingId: string | null;
+    startRename: (id: string) => void;
+    cancelRename: () => void;
+    /** Commit a rename and leave rename mode. Applied optimistically and
+     * rolled back if `onRename` rejects. Blank and unchanged labels are
+     * dropped. */
+    rename: (id: string, label: string) => void;
+    menuOpenId: string | null;
+    openMenu: (id: string) => void;
+    closeMenu: () => void;
+    /** Reorder, applied optimistically and rolled back if `onMove` rejects.
+     * Refuses moves the data forbids (into itself, into a non-container). */
+    move: (move: ISidebarResourceMove) => Promise<void>;
+    /** A move is in flight — further moves are refused until it settles. */
+    movePending: boolean;
+    /** Live-region text for the last move or rename outcome. */
+    announcement: string;
+    /** Back to the values the sidebar mounted with. */
+    reset: () => void;
+    /** @internal Row wiring the view threads through — drag state, the
+     * hover pill and roving keyboard nav all belong to the rendering. */
+    dnd: IAISidebarDndState;
+    hover: IAISidebarHoverState;
+    onRowKeyDown: (event: KeyboardEvent<HTMLDivElement>, row: IFlatResource) => void;
+    setRowRef: (id: string, node: HTMLDivElement | null) => void;
+}
+/** @internal */
+export interface IAISidebarDndState extends IAISidebarRowDndHandlers {
+    draggingId: string | null;
+    dropTarget: IDropTarget | null;
+    onRootDragOver: (event: DragEvent<HTMLDivElement>) => void;
+}
+/** @internal The drag handlers a row needs, stable for the life of the
+ * sidebar — they read drag state out of the store when they run instead of
+ * closing over it, so handing them to every row costs no re-renders. */
+export interface IAISidebarRowDndHandlers {
+    onDrop: (event: DragEvent<HTMLDivElement>) => void;
+    onRowDragStart: (event: DragEvent<HTMLDivElement>, id: string) => void;
+    onRowDragEnd: () => void;
+    onRowDragOver: (event: DragEvent<HTMLDivElement>, row: IFlatResource) => void;
+}
+/** @internal */
+export interface IAISidebarHoverState {
+    hoveredId: string | null;
+    /** Shared motion layoutId that lets the pill travel between rows. */
+    layoutId: string;
+    onRowHover: (id: string, hovered: boolean) => void;
+    clear: () => void;
+}
+export interface IAISidebarProps extends IUseAISidebarOptions {
+    /** Never set on the data form — `controller` selects the other one. */
+    controller?: never;
+    renderIcon?: (item: ISidebarResource) => ReactNode;
+    renderMenu?: (item: ISidebarResource, controls: ISidebarResourceMenuControls) => ReactNode;
+    /**
+     * Replaces the default "…" actions button. Must return a single element —
+     * the popover clones it to attach its trigger ref and click handler.
+     */
+    renderActionsTrigger?: (item: ISidebarResource) => ReactElement;
+    ariaLabel?: string;
+    className?: string;
+}
+/** Presentational props, shared by both forms of `<AISidebar>`. */
+export type TAISidebarViewProps = Pick<IAISidebarProps, "renderIcon" | "renderMenu" | "renderActionsTrigger" | "ariaLabel" | "className">;
+/** Drive the block from a `useAISidebar` controller instead of raw props —
+ * the controller carries the data and every handler. */
+export interface IAISidebarControllerProps extends TAISidebarViewProps {
+    controller: IAISidebarController;
+}
+/** Either form: raw props, or a `useAISidebar` controller. */
+export type TAISidebarComponentProps = IAISidebarProps | IAISidebarControllerProps;
+export interface IFlatResource {
+    item: ISidebarResource;
+    depth: number;
+    parentId: string | null;
+}
+export interface IDropTarget {
+    id: string | null;
+    position: TSidebarResourceDropPosition;
+}
+/** A row takes its place in the tree and nothing else: selection,
+ * expansion, focus, rename, drag and hover state all arrive through its own
+ * atoms, and the rendering options through the sidebar context. */
+export interface IResourceRowProps {
+    row: IFlatResource;
+}
+/** @internal What a row needs from the block, threaded through context so
+ * the rows stay prop-light.
+ *
+ * Deliberately free of sidebar state and of the controller. Rows read state
+ * from per-row atoms, so this value keeps its identity for the life of the
+ * sidebar and hovering or expanding one row no longer re-renders every row
+ * through context. */
+export interface IAISidebarContextValue {
+    sidebarId: TAISidebarInstanceId;
+    /** Shared motion layoutId that lets the hover pill travel between rows. */
+    hoverLayoutId: string;
+    renderIcon?: IAISidebarProps["renderIcon"];
+    renderMenu?: IAISidebarProps["renderMenu"];
+    renderActionsTrigger?: IAISidebarProps["renderActionsTrigger"];
+    /** Registers the row's DOM node with the block, which owns the ref map —
+     * DOM nodes never go in the store. */
+    setRowRef: (id: string, node: HTMLDivElement | null) => void;
+    onRowKeyDown: (event: KeyboardEvent<HTMLDivElement>, row: IFlatResource) => void;
+    onRowHover: (id: string, hovered: boolean) => void;
+    /** Closing returns DOM focus to the row that owned the menu, so it goes
+     * through the block rather than the store. */
+    closeMenu: () => void;
+    dnd: IAISidebarRowDndHandlers;
+}
+/** Everything observable about one sidebar, for consumers reading it by id. */
+export interface IAISidebarState {
+    items: ISidebarResource[];
+    /** Visible rows in order, each with its depth and parent id. */
+    flat: IFlatResource[];
+    selectedId: string | null;
+    expandedIds: ReadonlySet<string>;
+    focusedId: string | null;
+    renamingId: string | null;
+    menuOpenId: string | null;
+    draggingId: string | null;
+    dropTarget: IDropTarget | null;
+    hoveredId: string | null;
+    /** A move is in flight — further moves are refused until it settles. */
+    movePending: boolean;
+    /** Live-region text for the last move or rename outcome. */
+    announcement: string;
+}
+/** Everything doable to one sidebar from outside its component. */
+export interface IAISidebarActions {
+    select: (id: string) => void;
+    expand: (id: string) => void;
+    collapse: (id: string) => void;
+    toggleExpanded: (id: string) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    reveal: (id: string) => void;
+    /** Moves the roving-focus target. DOM focus follows only for callers that
+     * hold the controller — the ref map lives in the block, not the store. */
+    focus: (id: string) => void;
+    startRename: (id: string) => void;
+    cancelRename: () => void;
+    rename: (id: string, label: string) => void;
+    openMenu: (id: string) => void;
+    closeMenu: () => void;
+    move: (move: ISidebarResourceMove) => Promise<void>;
+    setItems: (items: ISidebarResource[]) => void;
+    reset: () => void;
+}
+/** @internal Projection of `useAISidebar`'s options — primitives only, so
+ * the store write runs once per real change instead of once per render. */
+export interface IAISidebarConfig {
+    controlsItems: boolean;
+    controlsActiveId: boolean;
+    controlsExpandedIds: boolean;
+}
+/** @internal Latest option callbacks. Only write atoms read this, so it can
+ * be refreshed every commit without re-rendering anything. */
+export interface IAISidebarHandlers {
+    onItemsChange?: (items: ISidebarResource[]) => void;
+    onMove?: (move: ISidebarResourceMove) => void | Promise<void>;
+    onMoveError?: (error: unknown, move: ISidebarResourceMove) => void;
+    onRename?: (item: ISidebarResource, label: string) => void | Promise<void>;
+    onActiveChange?: (id: string) => void;
+    onExpandedChange?: (ids: string[]) => void;
+}
+/** @internal What an instance starts from, replayed by
+ * `resetAISidebarAtom`. */
+export interface IAISidebarSeed {
+    items: ISidebarResource[];
+    /** Hook-owned selection — the `defaultActiveId`, never the controlled
+     * `activeId`. */
+    activeId: string | null;
+    focusedId: string | null;
+    expandedIds: string[];
+}

package/dist-lib/components/blocks/sidebar/use-ai-sidebar-state.d.ts

@@ -0,0 +1,29 @@
+import { IAISidebarActions, TAISidebarInstanceId, IAISidebarState } from './type.ts';
+/**
+ * Read the sidebar registered under `sidebarId` from anywhere below
+ * `ExegiaProvider` — no controller, no props, no provider of its own.
+ *
+ * ```tsx
+ * const { selectedId, movePending } = useAISidebarState("app-resources")
+ * ```
+ *
+ * This returns the whole state object, so the caller re-renders on any
+ * change. A component that reads one field should subscribe to that field's
+ * atom instead: `useAtomValue(aiSidebarActiveIdAtom("app-resources"))`.
+ */
+export declare function useAISidebarState(sidebarId: TAISidebarInstanceId): IAISidebarState;
+/**
+ * Drive the sidebar registered under `sidebarId` from anywhere. Writes only —
+ * the caller never re-renders when the sidebar changes, so this is what a
+ * command palette, a keyboard shortcut or a route guard should reach for.
+ *
+ * `focus` and `closeMenu` move the store's roving target; DOM focus follows
+ * only for callers that hold the controller, because the row refs live in
+ * the block rather than the store.
+ *
+ * ```tsx
+ * const resources = useAISidebarActions("app-resources")
+ * <Button onClick={resources.collapseAll}>Collapse all</Button>
+ * ```
+ */
+export declare function useAISidebarActions(sidebarId: TAISidebarInstanceId): IAISidebarActions;

package/dist-lib/components/blocks/sidebar/use-ai-sidebar.d.ts

@@ -0,0 +1,27 @@
+import { IAISidebarController, IUseAISidebarOptions } from './type.ts';
+export type { IUseAISidebarOptions };
+/**
+ * The AI sidebar's headless controller — every behaviour the block
+ * performs, callable from outside it: select, expand/collapse (one row,
+ * every row, or just the ancestors of one), move focus, rename, open a
+ * row's action menu, reorder.
+ *
+ * `items`, `activeId` and `expandedIds` are each controlled when passed
+ * and hook-owned via their `default*` twin otherwise. Reorder and rename
+ * are applied to the data optimistically and rolled back if
+ * `onMove`/`onRename` rejects, so a consumer never reduces the tree
+ * itself — `moveResource` and `renameResource` are exported for the ones
+ * who keep their data elsewhere.
+ *
+ * ```tsx
+ * const sidebar = useAISidebar({ defaultItems: resources })
+ * <AISidebar controller={sidebar} />
+ * <Button onClick={sidebar.collapseAll}>Collapse all</Button>
+ * ```
+ *
+ * State lives in Jotai atoms keyed by `sidebarId`, so anything under
+ * `ExegiaProvider` can drive this sidebar without the controller — name it
+ * and reach for `useAISidebarState(sidebarId)` /
+ * `useAISidebarActions(sidebarId)` elsewhere.
+ */
+export declare function useAISidebar(options: IUseAISidebarOptions): IAISidebarController;

package/dist-lib/components/blocks/sidebar/utils.d.ts

@@ -0,0 +1,21 @@
+import { IFlatResource, ISidebarResource, TSidebarResourceDropPosition, ISidebarResourceMove } from './type.ts';
+export declare const ROW_REVEAL: {
+    readonly duration: 0.16;
+    readonly ease: readonly [0.16, 1, 0.3, 1];
+};
+export declare function canContain(item: ISidebarResource): boolean;
+export declare function flattenResources(items: ISidebarResource[], expanded: ReadonlySet<string>, depth?: number, parentId?: string | null): IFlatResource[];
+export declare function findResource(items: ISidebarResource[], id: string): ISidebarResource | undefined;
+/** Ids of every ancestor of `id` (nearest last); empty when absent. */
+export declare function ancestorIdsOf(items: ISidebarResource[], id: string): string[];
+/** Ids of every row that can hold children and has some — the set
+ * `expandAll` opens. */
+export declare function expandableIdsOf(items: ISidebarResource[]): string[];
+export declare function containsResource(item: ISidebarResource, id: string): boolean;
+export declare function removeResource(items: ISidebarResource[], id: string): {
+    items: ISidebarResource[];
+    removed?: ISidebarResource;
+};
+export declare function insertResource(items: ISidebarResource[], resource: ISidebarResource, targetId: string | null, position: TSidebarResourceDropPosition): ISidebarResource[];
+export declare function moveResource(items: ISidebarResource[], move: ISidebarResourceMove): ISidebarResource[] | null;
+export declare function renameResource(items: ISidebarResource[], id: string, label: string): ISidebarResource[];

package/dist-lib/components/blocks/types.d.ts

@@ -0,0 +1,6 @@
+export type * from './auth/type';
+export type * from './chat/type';
+export type * from './sidebar/type';
+export type * from './profile/type';
+export type * from './scaffold/type';
+export type * from './shell/type';

package/dist-lib/components/composed/action-bar/action.d.ts

@@ -0,0 +1,18 @@
+import { IActionButtonProps } from './types';
+import { ToolbarSeparatorProps } from '@base-ui/react';
+export declare function Action({ tooltip, action, Icon, }: Omit<IActionButtonProps<string>, "children">): import("react").JSX.Element;
+/**
+ * Group boundary. Pass it under a `separator-*` key in `actions` and the bar
+ * wraps the runs of actions either side of it in their own `ToolbarGroup`.
+ */
+export declare function Separator(props: ToolbarSeparatorProps): import("react").JSX.Element;
+/**
+ * An action labelled by an emoji glyph rather than a Lucide icon. The glyph is
+ * `aria-hidden` — `label` is the accessible name, so a screen reader reads
+ * "thumbs up" rather than announcing the character.
+ */
+export declare function EmojiAction({ emoji, label, action, }: {
+    emoji: string;
+    label: string;
+    action: () => void;
+}): import("react").JSX.Element;

package/dist-lib/components/composed/action-bar/emojis.d.ts

@@ -0,0 +1,10 @@
+import { IEmojiActionBarProps } from './types';
+import type * as React from "react";
+/**
+ * Compact reaction picker: a toolbar of quick emoji, then a "More" action that
+ * swaps the surface for the full frimousse picker. Meant to sit inside a
+ * `PopoverGlass variant="glass"` — swapping the two surfaces resizes the popup,
+ * which is why the popup's viewport padding variable has to be zeroed rather
+ * than only its padding (see `BubbleReactionsButton`).
+ */
+export declare function EmojiActionBar({ onEmojiSelect, reactions, hideMore, }: IEmojiActionBarProps): React.ReactElement;

package/dist-lib/components/composed/action-bar/index.d.ts

@@ -0,0 +1,12 @@
+import { EmojiActionBar } from './emojis';
+import { Action, EmojiAction, Separator } from './action';
+import { default as Toolbar } from './toolbar';
+export { useActionBar, useEmojiPicker, QUICK_REACTIONS } from './utils';
+export type { IActionBarProps, TActionBarSegment, IActionButtonProps, IEmojiActionBarProps, TActionEntry, TActionItemsByGroup, TActionKey, TActionMap, } from './types';
+export declare const ActionBar: {
+    Emoji: typeof EmojiActionBar;
+    Separator: typeof Separator;
+    EmojiAction: typeof EmojiAction;
+    Action: typeof Action;
+};
+export default Toolbar;

package/dist-lib/components/composed/action-bar/toolbar.d.ts

@@ -0,0 +1,2 @@
+import { IActionBarProps } from './types';
+export default function Toolbar({ id, actions, variant, className, }: IActionBarProps): import("react").JSX.Element;

package/dist-lib/components/composed/action-bar/types.d.ts

@@ -0,0 +1,55 @@
+import { TButtonProps } from '../../ui/button';
+import { TPopoverGlassProps } from '../../ui/popover-glass';
+import { ToolbarSeparatorProps } from '@base-ui/react';
+import { Emoji } from 'frimousse';
+import { LucideIcon } from 'lucide-react';
+import { FunctionComponent } from 'react';
+export interface IActionButtonProps<T extends string> extends Omit<TButtonProps, "variant" | "glassVariant" | "size"> {
+    action: () => void;
+    tooltip?: string;
+    Icon: LucideIcon | Emoji;
+    id: T;
+}
+type TActionBarItemType = "action" | "separator";
+export type TActionKey<T extends string = string, Type extends TActionBarItemType = "action"> = `${Type}-${T}`;
+/**
+ * Insertion order is the contract: the bar groups positionally, so the order
+ * keys are written is the order they render. Safe because every `ActionKey`
+ * is a non-numeric `${type}-${name}` string, which `Object.entries` preserves
+ * — but a map built by spreading or `Object.fromEntries` must keep that order.
+ */
+export type TActionMap<T extends TActionKey> = Record<T, FunctionComponent<IActionButtonProps<T> | ToolbarSeparatorProps>>;
+export type TActionEntry = readonly [
+    key: string,
+    Item: FunctionComponent<IActionButtonProps<string> | ToolbarSeparatorProps>
+];
+/** Actions between two separators, rendered inside one `ToolbarGroup`. */
+export type TActionItemsByGroup = Record<string, TActionEntry[]>;
+/**
+ * The bar as an ordered, render-ready list. A "group" is a run of consecutive
+ * actions; a "separator" is whatever component the map supplied for that key.
+ * Empty groups (leading, trailing or back-to-back separators) are dropped.
+ */
+export type TActionBarSegment = {
+    type: "group";
+    key: string;
+    items: TActionEntry[];
+} | {
+    type: "separator";
+    key: string;
+    Separator: FunctionComponent<ToolbarSeparatorProps>;
+};
+export interface IActionBarProps extends Omit<TPopoverGlassProps, "variant" | "children"> {
+    id: string;
+    variant: "default" | "ghost" | "glass";
+    actions: TActionMap<TActionKey>;
+}
+export interface IEmojiActionBarProps {
+    /** Fires for both a quick reaction and a pick from the full picker. */
+    onEmojiSelect?: (emoji: Emoji) => void;
+    /** Quick row contents. Defaults to {@link QUICK_REACTIONS}. */
+    reactions?: readonly Emoji[];
+    /** Hides the trailing "More" action, leaving the quick row only. */
+    hideMore?: boolean;
+}
+export {};

package/dist-lib/components/composed/action-bar/utils.d.ts

@@ -0,0 +1,56 @@
+import { Tooltip } from '@base-ui/react/tooltip';
+import { TActionBarSegment, TActionEntry, TActionItemsByGroup, TActionKey, TActionMap, IEmojiActionBarProps } from './types';
+import { Emoji } from 'frimousse';
+export declare const ActionTooltipContext: import('react').Context<Tooltip.Handle<string> | undefined>;
+export declare const isSeparator: (key: string) => boolean;
+/**
+ * Splits `actions` into render-ready segments at every `separator-*` key.
+ *
+ * Order comes from the map's insertion order (see `ActionMap`) — the grouping
+ * is positional, so actions written before a separator group ahead of it.
+ * Empty groups are dropped, which is what keeps a leading, trailing or
+ * doubled separator from rendering a `ToolbarGroup` with nothing in it.
+ */
+export declare const useActionBar: ({ actions, }: {
+    actions: TActionMap<TActionKey>;
+}) => {
+    segments: TActionBarSegment[];
+    entries: TActionEntry[];
+    hasGroups: boolean;
+    groupsCount: number;
+    separatorCount: number;
+    actionItemsByGroup: TActionItemsByGroup;
+};
+/**
+ * The quick row. frimousse has no way to render a subset — `EmojiPicker.Root`
+ * takes `columns`/`skinTone`/`locale`/`emojiVersion`/`emojibaseUrl`/`sticky`
+ * and nothing else, and its list is virtualized on fixed-height rows, so a
+ * custom `Emoji` component that returns null leaves holes rather than a short
+ * row. A fixed list is the only way to show just these, and it costs no
+ * network request — the CDN fetch only happens if "More" is opened.
+ */
+export declare const QUICK_REACTIONS: readonly Emoji[];
+/**
+ * Hook for managing the emoji picker state and actions.
+ *
+ * @param props - The emoji picker props.
+ * @returns The emoji picker state and actions.
+ *
+ * @example
+ * ```tsx
+ * const { isFullPicker, quickReactions, actions, togglePicker, selectEmoji } = useEmojiPicker({ onEmojiSelect });
+ * ```
+ */
+export declare const useEmojiPicker: ({ onEmojiSelect, reactions, hideMore, }: IEmojiActionBarProps) => {
+    isFullPicker: boolean;
+    quickReactions: readonly {
+        emoji: string;
+        label: string;
+    }[];
+    actions: readonly {
+        emoji: string;
+        label: string;
+    }[];
+    togglePicker: () => void;
+    selectEmoji: (emoji: Emoji) => void;
+};

package/dist-lib/components/composed/ai/index.d.ts

@@ -0,0 +1,17 @@
+import { Message } from './message';
+import { StreamingText } from './streaming-text';
+import { ResearchAnswer } from './research-answer';
+import { SuggestedPrompt } from './suggested-prompt';
+export type { ISuggestedPromptProps } from './suggested-prompt';
+export { accentRing, accentSolid, accentText, agentText, ghostMuted, glassCard, mutedText, surface, } from './shared';
+export { type IStreamingTextProps, type TStreamingToken } from './streaming-text';
+export type { IResearchAnswerProps } from './research-answer';
+export type { IAISuggestionBase, IDiffRow, IReferenceBase, TSuggestionState, } from './types';
+declare const AI: {
+    Message: typeof Message;
+    Avatar: () => import("react").JSX.Element;
+    StreamingText: typeof StreamingText;
+    SuggestedPrompt: typeof SuggestedPrompt;
+    ResearchAnswer: typeof ResearchAnswer;
+};
+export default AI;

package/dist-lib/components/composed/ai/message.d.ts

@@ -0,0 +1,7 @@
+import { IAIMessageProps, TAIMessageType } from './types';
+/**
+ * An agent turn: author row, prose body and — when the model proposed
+ * changes — a "Suggestions" disclosure that fans the cards out below with a
+ * staggered spring.
+ */
+export declare function Message<T extends TAIMessageType>({ children, isStreaming, className, AttachedContent, type, contentProps, ...props }: IAIMessageProps<T>): React.ReactElement;

package/dist-lib/components/composed/ai/research-answer.d.ts

@@ -0,0 +1,30 @@
+import type * as React from "react";
+export interface IResearchReference {
+    /** Pill label, e.g. "Iliad · Homer corpus". */
+    label: React.ReactNode;
+    /** Preview-card content shown on hover. */
+    favicon?: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    href?: string;
+}
+export interface IResearchAnswerProps extends Omit<React.ComponentPropsWithoutRef<"div">, "content"> {
+    kicker?: React.ReactNode;
+    /** "Answered from 3 passages · 0.8 s" */
+    kickerSub?: React.ReactNode;
+    content: React.ReactNode;
+    source?: React.ReactNode | IResearchReference;
+    date?: React.ReactNode;
+    authors?: React.ReactNode | IResearchReference;
+    onCopyCitation?: () => void;
+    onShare?: () => void;
+    /** TODO(spec 003): the design shows the control only; behaviour is the caller's. */
+    onAddToList?: () => void;
+    bare?: boolean;
+}
+/**
+ * Research answer card: kicker, content, Source / Date / Author(s) meta, actions.
+ *
+ * @sketch "Component / Research Answer"
+ */
+export declare function ResearchAnswer({ kicker, kickerSub, content, source, date, authors, onCopyCitation, onShare, onAddToList, bare, className, ...props }: IResearchAnswerProps): React.ReactElement;

package/dist-lib/components/composed/ai/streaming-text.d.ts

@@ -0,0 +1,26 @@
+import * as React from "react";
+/** A word, or an inline citation; extra fields turn the chip into a hover preview. */
+export type TStreamingToken = {
+    text: string;
+} | {
+    cite: string;
+    favicon?: string;
+    title?: string;
+    description?: string;
+    href?: string;
+};
+export interface IStreamingTextProps extends React.ComponentPropsWithoutRef<"div"> {
+    /** Paragraphs, each a token list; a string is split on spaces. */
+    paragraphs: (string | TStreamingToken[])[];
+    /** Reveal words over time and show the caret. */
+    streaming?: boolean;
+    /** Reveal gap in ms; defaults to the --stream-gap token (60ms). */
+    wordMs?: number;
+}
+/**
+ * Streamed answer: paragraphs with inline source previews and a caret.
+ * Actions, sources and follow-ups belong to the host.
+ *
+ * @sketch "Component / Streaming Text"
+ */
+export declare function StreamingText({ paragraphs, streaming, wordMs, className, ...props }: IStreamingTextProps): React.ReactElement;

package/dist-lib/components/composed/ai/suggested-prompt.d.ts

@@ -0,0 +1,35 @@
+import { HTMLMotionProps } from 'motion/react';
+import type * as React from "react";
+export interface ISuggestedPromptProps extends Omit<HTMLMotionProps<"button">, "children" | "onSelect"> {
+    /** The prompt itself — what the person would have typed. */
+    children: React.ReactNode;
+    onSelect?: () => void;
+    /**
+     * Shared-layout id. Give the resulting message bubble the same id and the
+     * row flies into it when this one unmounts.
+     */
+    layoutId?: string;
+}
+/**
+ * One suggested prompt: a violet spark, the prompt, and a `+` marking that
+ * picking it drops the prompt into the thread. The whole row is the control —
+ * the `+` is an affordance, not a second action.
+ */
+export declare function SuggestedPrompt({ children, onSelect, layoutId, className, ...props }: ISuggestedPromptProps): React.ReactElement;
+export interface ISuggestedPromptsProps extends Omit<HTMLMotionProps<"div">, "children"> {
+    /** The `SuggestedPrompt` rows. */
+    children: React.ReactNode;
+    /** Overrides the count derived from `children`. */
+    count?: number;
+    /** Names the disclosure. `Suggestions (n)` by default. */
+    label?: (count: number) => React.ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+/**
+ * The "Suggestions (n)" disclosure above the composer: a chevron that swings
+ * from left (folded) to down (open) and a panel of prompts that fans out
+ * beneath it, its bottom edge tucked behind the composer pill.
+ */
+export declare function SuggestedPrompts({ children, count, label, defaultOpen, open: openProp, onOpenChange, className, ...props }: ISuggestedPromptsProps): React.ReactElement | null;