@exegia/corpora-ui 1.0.0 → 3.0.0

package/dist-lib/components/composed/chat/recommendation/types.d.ts

@@ -0,0 +1,62 @@
+import { TSignalLevel } from '../../../ui/chat';
+import { AccordionPrimitive } from '../../../ui/accordion';
+import { IReferenceProps } from '../../../atoms/types';
+import type * as React from "react";
+export interface IRecommendationOption {
+    label: React.ReactNode;
+    status?: React.ReactNode;
+    signal?: TSignalLevel;
+}
+export interface IRecommendationEntity {
+    name: React.ReactNode;
+    initials?: string;
+    src?: string;
+}
+export type TRecommendationState = "accepted" | "rejected" | "pending"
+/** The proposal was approved and the agent is working on it. */
+ | "running";
+/** Shared fields of a human-in-the-loop proposal. */
+export interface IRecommendationFields {
+    title: React.ReactNode;
+    /** Collapsible body text around the entity and lead-time pills. */
+    description: React.ReactNode;
+    entity?: IRecommendationEntity;
+    reference?: IReferenceProps;
+    leadTime?: React.ReactNode;
+    options?: IRecommendationOption[];
+    optionsLabel?: React.ReactNode;
+    confidence?: TSignalLevel;
+    confidenceLabel?: React.ReactNode;
+    acceptLabel?: React.ReactNode;
+    rejectLabel?: React.ReactNode;
+    alternativesLabel?: React.ReactNode;
+    state?: TRecommendationState;
+    /** Number inside the pending ring, e.g. the item's position in its group. */
+    step?: number;
+    onAccept?: () => void;
+    /** Skip / ignore. Wins over `onAlternatives` when both are passed. */
+    onReject?: () => void;
+    onAlternatives?: () => void;
+    /** Takes the card back to `pending`. Without it no Undo is offered. */
+    onUndo?: () => void;
+    onSelectOption?: (index: number) => void;
+    children?: React.ReactNode;
+}
+export interface IRecommendationItemProps extends IRecommendationFields, Omit<React.ComponentPropsWithoutRef<"div">, "title" | "children"> {
+    /** Accordion item identity. Required inside `Recommendation.Group`. */
+    value: string;
+}
+export interface IRecommendationCardProps extends IRecommendationFields {
+    /** Accordion item identity. Auto-generated when omitted. */
+    value?: string;
+    /** Uncontrolled initial open state. Default true — Accept lives in the body. */
+    defaultOpen?: boolean;
+    className?: string;
+}
+export type TRecommendationGroupProps = AccordionPrimitive.Root.Props;
+export interface IRecommendationCheckboxProps {
+    state: TRecommendationState;
+    /** Number shown inside the pending ring (its position in the group). */
+    step?: number;
+    className?: string;
+}

package/dist-lib/components/composed/chat/records-table.d.ts

@@ -0,0 +1,40 @@
+import { TTagTone } from '../../ui/chat';
+import * as React from "react";
+/** Selected row ids, keyed by `tableId`. */
+export declare const recordsTableSelectionAtom: import('../../../lib/keyed-atom').TFamily<import('jotai').PrimitiveAtom<ReadonlySet<string>> & {
+    init: ReadonlySet<string>;
+}>;
+export declare const removeRecordsTableInstance: (id: string) => void;
+export interface IRecordsRow {
+    id: string;
+    name: React.ReactNode;
+    initial?: string;
+    avatarSrc?: string;
+    tags?: {
+        label: React.ReactNode;
+        tone?: TTagTone;
+    }[];
+    /** Max tags shown inline; the rest collapse to "+N". */
+    lastInteraction?: React.ReactNode;
+    strength?: React.ReactNode;
+}
+export type TRecordsColumnKey = "name" | "tags" | "lastInteraction" | "strength";
+export interface IRecordsTableProps extends React.ComponentPropsWithoutRef<"div"> {
+    tableId?: string;
+    rows: IRecordsRow[];
+    headers?: Partial<Record<TRecordsColumnKey, React.ReactNode>>;
+    /** Pin the header inside a height-constrained scroll container. */
+    stickyHeader?: boolean;
+    maxTags?: number;
+    selected?: ReadonlySet<string>;
+    onSelectionChange?: (selected: ReadonlySet<string>) => void;
+    /** Sort is the caller's: the design shows the control only. */
+    onSortChange?: (column: TRecordsColumnKey) => void;
+}
+/**
+ * Selectable records table: index, initial avatar, name, tag row with
+ * overflow, relative date, connection strength; sortable headers.
+ *
+ * @sketch "Component / Records Table"
+ */
+export declare function RecordsTable({ tableId, rows, headers, stickyHeader, maxTags, selected, onSelectionChange, onSortChange, className, ...props }: IRecordsTableProps): React.ReactElement;

package/dist-lib/components/composed/chat/type.d.ts

@@ -0,0 +1,117 @@
+import { IMenuCommandItem } from '../../ui/menu-command';
+import { TAttachmentProps } from './attachment';
+import { HTMLMotionProps } from 'motion/react';
+import { TAtomSize } from '../../atoms/types';
+import type * as React from "react";
+export type TComposerMode = "answer" | "fix" | "ask";
+/** A tray chip: any Attachment kind plus a stable id. */
+type ComposerAttachment<T> = T extends TAttachmentProps ? Omit<T, "variant" | "onRemove" | "removable"> & {
+    id: string;
+} : never;
+export type TComposerAttachment = ComposerAttachment<TAttachmentProps>;
+export interface IComposerModel {
+    id: string;
+    label: string;
+    description?: string;
+}
+export interface IComposerOption {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: React.ReactNode;
+    /** Text to insert instead of @label or /id. */
+    insertText?: string;
+    onSelect?: () => void;
+}
+export interface IComposerMenuProps {
+    disabled?: boolean;
+    items?: IMenuCommandItem[];
+    onCommand?: (item: IMenuCommandItem) => void;
+    onAttach?: () => void;
+}
+export interface IComposerSuggestionsProps {
+    prompts?: React.ReactNode;
+    label?: (count: number) => React.ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export interface IComposerSubmitButtonProps<S extends boolean = boolean, E extends boolean = boolean> {
+    onStop?: () => void;
+    disabled?: boolean;
+    isStreaming: S;
+    isExpanded: E;
+}
+export interface IComposerModeProps {
+    mode: TComposerMode;
+    onModeChange?: (mode: TComposerMode) => void;
+}
+export interface IComposerBaseProps<S extends boolean = boolean, E extends boolean = boolean, M extends TComposerMode = TComposerMode, A extends TComposerAttachment = TComposerAttachment> {
+    shape?: "rounded" | "pill";
+    sources?: IComposerOption[];
+    commands?: IComposerOption[];
+    models?: IComposerModel[];
+    model?: string;
+    defaultModel?: string;
+    onModelChange?: (model: string) => void;
+    onSourceSelect?: (source: IComposerOption) => void;
+    onCommand?: (command: IComposerOption) => void;
+    /** Receives local files; uploading remains the consuming app's responsibility. */
+    onFilesChange?: (files: File[]) => void;
+    accept?: string;
+    /** Hide the microphone. Unsupported browsers show it disabled otherwise. */
+    dictation?: boolean;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    composerId?: string;
+    /** Seeds the tray once on mount; the atoms own it from then on. */
+    attachments?: A[];
+    /** Keep the text above the controls even for a short message. */
+    expanded?: E;
+    isStreaming?: S;
+    disabled?: boolean;
+    safetyNote?: React.ReactNode;
+    placeholder?: string;
+    onSubmit?: (value: string, mode: M, attachments: A[]) => void;
+    /** Fires from the streaming Stop button and the Escape key. */
+    onStop?: () => void;
+    className?: string;
+    defaultValue?: string;
+}
+export interface IComposerProps<IMode extends IComposerModeProps = IComposerModeProps, S extends boolean = boolean, E extends boolean = boolean> extends IComposerBaseProps<S, E> {
+    /** Replaces the default `SendButton`. Receives the streaming/expanded state. */
+    SubmitButton?: React.FC<IComposerSubmitButtonProps<S, E>>;
+    ModeComponent?: React.FC<IMode>;
+    Suggestions?: React.FC<IComposerSuggestionsProps>;
+    ComposerMenu?: React.FC<IComposerMenuProps>;
+}
+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;
+}
+export type TBubbleActionPayload = string | number | Record<string, unknown> | undefined;
+export type TBubbleActionSize = Extract<TAtomSize, "sm" | "default" | "lg">;
+export type TBubbleActionKey = "copy" | "edit" | "delete" | "share" | "retry" | "more" | "download";
+export interface IBubbleActionBaseProps<S extends TBubbleActionSize = TBubbleActionSize, K extends TBubbleActionKey = TBubbleActionKey, P extends TBubbleActionPayload = TBubbleActionPayload> {
+    key: K;
+    onClick?: (key: K, payload: P) => void;
+    icon?: React.ReactNode;
+    tooltip?: string;
+    size?: S;
+}
+export type TIBubbleActionProps<K extends TBubbleActionKey = TBubbleActionKey, S extends TBubbleActionSize = TBubbleActionSize, P extends TBubbleActionPayload = TBubbleActionPayload> = IBubbleActionBaseProps<S, K, P>;
+export interface IBubbleActionsProps<K extends TBubbleActionKey = TBubbleActionKey, S extends TBubbleActionSize = TBubbleActionSize, P extends TBubbleActionPayload = TBubbleActionPayload> {
+    size?: S;
+    onClick?: (key: K, payload: P) => void;
+    actions: {
+        [key in K]?: TIBubbleActionProps<K, S, P>;
+    };
+}
+export {};

package/dist-lib/components/composed/logo.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+/** `full` shows mark + wordmark; `mark` folds the wordmark away — an icon
+ * rail, a favicon-sized corner. */
+export type TLogoVariant = "full" | "mark";
+export interface ILogoProps extends Omit<React.HTMLAttributes<HTMLElement>, "children"> {
+    /**
+     * Brand name. Labels the logo for AT (and the link, when `href` renders
+     * one), drives the default wordmark, and the monogram tile when no mark
+     * is given.
+     */
+    name: string;
+    /** Custom mark — an inline SVG sized to fill its box. Wins over `src`. */
+    mark?: React.ReactNode;
+    /** Image URL for the mark. Decorative — `name` labels the logo. */
+    src?: string;
+    /** Wordmark content. Defaults to `name`. */
+    wordmark?: React.ReactNode;
+    /** `full` (default) or `mark` — the wordmark folds away, animated. */
+    variant?: TLogoVariant;
+    /** Renders the logo as a link — the usual "mark goes home" affordance. */
+    href?: string;
+}
+/**
+ * Brand lockup: a mark beside a wordmark. The mark is whatever the brand
+ * has — an SVG (`mark`), an image (`src`), or, given neither, a monogram
+ * tile derived from `name`. `variant="mark"` folds the wordmark away with
+ * the same motion a collapsing rail uses, so the lockup can sit in one and
+ * follow its fold. With `href` the whole lockup is a link named by `name`.
+ *
+ * Sizing rides on the mark: it defaults to `size-8`; restyle via
+ * `[&_[data-slot=logo-mark]]:size-*` or wrap in a text-size context for the
+ * wordmark, which inherits.
+ */
+export declare function Logo({ name, mark, src, wordmark, variant, href, className, ...props }: ILogoProps): React.ReactElement;

package/dist-lib/components/composed/password-input.d.ts

@@ -0,0 +1,30 @@
+import { InputGroupInput } from '../ui/input-group';
+import * as React from "react";
+export declare const passwordRequirements: readonly [{
+    readonly regex: RegExp;
+    readonly text: "At least 8 characters";
+}, {
+    readonly regex: RegExp;
+    readonly text: "At least 1 number";
+}, {
+    readonly regex: RegExp;
+    readonly text: "At least 1 lowercase letter";
+}, {
+    readonly regex: RegExp;
+    readonly text: "At least 1 uppercase letter";
+}];
+export declare function getPasswordStrength(password: string): number;
+export interface IPasswordInputProps extends Omit<React.ComponentProps<typeof InputGroupInput>, "type" | "size"> {
+    /** Render the eye toggle button. */
+    visibilityToggle?: boolean;
+    /** Render the animated strength meter and requirement checklist. */
+    showStrength?: boolean;
+    /** Play reveal/hide cues on the visibility toggle. Inert until bindSounds(). */
+    sound?: boolean;
+}
+/**
+ * Password field with visibility toggle and optional strength meter.
+ * Composition of InputGroup + Button (coss particles p-input-9 and
+ * p-input-group-26).
+ */
+export declare function PasswordInput({ visibilityToggle, showStrength, sound, className, value: valueProp, defaultValue, onChange, ...props }: IPasswordInputProps): React.JSX.Element;

package/dist-lib/components/composed/reader/applied-mark.d.ts

@@ -0,0 +1,3 @@
+import { IAppliedMarkProps } from './type';
+import type * as React from "react";
+export declare function AppliedMark({ nodeId, className, children, ...props }: IAppliedMarkProps): React.ReactElement;

package/dist-lib/components/composed/reader/apply-toast.d.ts

@@ -0,0 +1,3 @@
+import { IApplyToastProps } from './type';
+import type * as React from "react";
+export declare function ApplyToast({ open, message, onUndo, className, }: IApplyToastProps): React.ReactElement | null;

package/dist-lib/components/composed/reader/selection-highlight.d.ts

@@ -0,0 +1,3 @@
+import { ISelectionHighlightProps } from './type';
+import type * as React from "react";
+export declare function SelectionHighlight({ range, className, children, ...props }: ISelectionHighlightProps): React.ReactElement;

package/dist-lib/components/composed/reader/selection-popover.d.ts

@@ -0,0 +1,9 @@
+import { ISelectionPopoverProps } from './type';
+import type * as React from "react";
+/**
+ * The reader entry point, built on the preview-card atom: hovering or
+ * focusing the selection reveals the card. The word and node variants
+ * deliberately share one shell so there is one, and only one, AI action for
+ * every kind of selection.
+ */
+export declare function SelectionPopover({ open, defaultOpen, onOpenChange, variant, word, node, onAddToChat, onClose, children, className, }: ISelectionPopoverProps): React.ReactElement;

package/dist-lib/components/composed/reader/type.d.ts

@@ -0,0 +1,40 @@
+import type * as React from "react";
+/** A single selected word in the reader. */
+export interface IWordSelection {
+    lemma: string;
+    partOfSpeech?: string;
+    pos?: string;
+    frequency?: number | string;
+    onViewDetails?: () => void;
+}
+/** A selected run of reader nodes. */
+export interface INodeSelection {
+    range: string;
+    nodeIds: string[];
+    wordCount: number;
+}
+export interface ISelectionPopoverProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    variant: "word" | "node";
+    word?: IWordSelection;
+    node?: INodeSelection;
+    onAddToChat?: () => void;
+    onClose?: () => void;
+    /** The selected reader content — rendered as the hover/focus trigger. */
+    children?: React.ReactNode;
+    className?: string;
+}
+export interface ISelectionHighlightProps extends React.ComponentPropsWithoutRef<"span"> {
+    range?: string;
+}
+export interface IAppliedMarkProps extends React.ComponentPropsWithoutRef<"span"> {
+    nodeId?: string;
+}
+export interface IApplyToastProps {
+    open?: boolean;
+    message?: React.ReactNode;
+    onUndo?: () => void;
+    className?: string;
+}

package/dist-lib/components/composed/social-providers.d.ts

@@ -0,0 +1,39 @@
+import { TSocialProvider } from './types';
+import type * as React from "react";
+/**
+ * Label + brand mark per provider, shared with the auth blocks. `Icon` is the
+ * monochrome mark that inherits the current text color; `BrandIcon` +
+ * `brandClassName` render it in the provider's own colors.
+ */
+export declare const SOCIAL_PROVIDERS: Record<TSocialProvider, {
+    label: string;
+    Icon: React.ComponentType<{
+        className?: string;
+    }>;
+    BrandIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    brandClassName?: string;
+    buttonClassName?: string;
+    labelClassName?: string;
+}>;
+declare const ACTION_LABELS: {
+    readonly login: "Login with";
+    readonly signup: "Sign up with";
+    readonly continue: "Continue with";
+};
+export interface ISocialProvidersProps {
+    providers?: TSocialProvider[];
+    /** Verb used in the stacked layout labels. */
+    action?: keyof typeof ACTION_LABELS;
+    /** "stack" = full-width labeled buttons; "row" = icon-only buttons. */
+    layout?: "stack" | "row";
+    /** Shows the matching button in its loading state and disables the rest. */
+    loadingProvider?: TSocialProvider | null;
+    disabled?: boolean;
+    onSelect?: (provider: TSocialProvider) => void;
+    className?: string;
+}
+/** Social auth buttons (coss particle p-button-38). UI only — wire onSelect. */
+export declare function SocialProviders({ providers, action, layout, loadingProvider, disabled, onSelect, className, }: ISocialProvidersProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+export { Tree } from './tree';
+export { useTree } from './use-tree';
+export { useTreeActions, useTreeState } from './use-tree-state';
+export { moveNode, renameNode } from './utils';
+export { cancelTreeRenameAtom, collapseAllTreeNodesAtom, collapseTreeNodeAtom, expandAllTreeNodesAtom, expandTreeNodeAtom, moveTreeNodeAtom, removeTreeInstance, renameTreeNodeAtom, resetTreeAtom, revealTreeNodeAtom, selectTreeNodeAtom, setTreeCollapsedAtom, setTreeItemsAtom, startTreeRenameAtom, toggleTreeCollapsedAtom, toggleTreeNodeAtom, treeActiveIdAtom, treeCanMoveAtom, treeCanRenameAtom, treeCollapsedAtom, treeDraggedIdAtom, treeDropTargetAtom, treeExpandedIdsAtom, treeItemsAtom, treeRenamingIdAtom, treeSectionedAtom, treeSectionIdsAtom, treeStateAtom, } from './tree-atom';
+export type { ITreeActions, ITreeController, ITreeControllerProps, TTreeDataProps, TTreeDropPosition, ITreeDropTarget, TTreeInstanceId, ITreeNode, TTreeProps, ITreeState, TTreeVariant, IUseTreeOptions, } from './type';

package/dist-lib/components/composed/tree/tree-atom.d.ts

@@ -0,0 +1,160 @@
+import { Atom } from 'jotai';
+import { ITreeConfig, TTreeDropPosition, ITreeDropTarget, ITreeHandlers, TTreeInstanceId, ITreeNode, ITreeSeed, ITreeState, TTreeVariant } from './type';
+/** What a tree reads as before `useTree` publishes its options. */
+export declare const DEFAULT_TREE_CONFIG: ITreeConfig;
+/**
+ * A string-keyed atom family.
+ *
+ * `jotai/utils`' `atomFamily` is deprecated for Jotai v3, and we need only
+ * the string-keyed case with a `remove` — so this stays in-house rather than
+ * adding `jotai-family` as a second Jotai package to keep version-aligned.
+ * Dropping a key lets the store's WeakMap release that instance's state.
+ */
+type TFamily<AtomType> = ((id: TTreeInstanceId) => AtomType) & {
+    remove: (id: TTreeInstanceId) => void;
+};
+/** @internal */
+export declare const treeConfigAtom: TFamily<import('jotai').PrimitiveAtom<ITreeConfig> & {
+    init: ITreeConfig;
+}>;
+/** @internal Refreshed every commit; nothing subscribes, so it is free. */
+export declare const treeHandlersAtom: TFamily<import('jotai').PrimitiveAtom<ITreeHandlers> & {
+    init: ITreeHandlers;
+}>;
+/** The tree's current data — hook-owned, or the projection of a controlled
+ * `items` prop. */
+export declare const treeItemsAtom: TFamily<import('jotai').PrimitiveAtom<ITreeNode[]> & {
+    init: ITreeNode[];
+}>;
+export declare const treeActiveIdAtom: TFamily<import('jotai').PrimitiveAtom<string | undefined> & {
+    init: string | undefined;
+}>;
+export declare const treeExpandedIdsAtom: TFamily<import('jotai').PrimitiveAtom<ReadonlySet<string>> & {
+    init: ReadonlySet<string>;
+}>;
+/** Raw rail fold. Read `treeCollapsedAtom` for the variant-masked value. */
+export declare const treeRailCollapsedAtom: TFamily<import('jotai').PrimitiveAtom<boolean> & {
+    init: boolean;
+}>;
+export declare const treeRenamingIdAtom: TFamily<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+export declare const treeDraggedIdAtom: TFamily<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+export declare const treeDropTargetAtom: TFamily<import('jotai').PrimitiveAtom<ITreeDropTarget | null> & {
+    init: ITreeDropTarget | null;
+}>;
+/** @internal The only items atom `useTree` may subscribe to: empty while a
+ * controlled `items` prop owns the data, so the projection write never feeds
+ * back into the render that produced it. An inline `items={[…]}` array is a
+ * new reference every render, and a subscribed round-trip would loop. */
+export declare const treeOwnedItemsAtom: TFamily<Atom<ITreeNode[]>>;
+/** Rail folded to icons — always `false` outside `sidebar`. */
+export declare const treeCollapsedAtom: TFamily<Atom<boolean>>;
+export declare const treeSectionedAtom: TFamily<Atom<boolean>>;
+export declare const treeSectionIdsAtom: TFamily<Atom<string[]>>;
+export declare const treeCanRenameAtom: TFamily<Atom<boolean>>;
+export declare const treeCanMoveAtom: TFamily<Atom<boolean>>;
+export declare const treeVariantAtom: TFamily<Atom<TTreeVariant>>;
+export declare const treeSoundAtom: TFamily<Atom<boolean>>;
+/** Whether this one node's branch is open. */
+export declare const treeNodeExpandedAtom: (id: TTreeInstanceId, nodeId: string) => Atom<boolean>;
+/** Whether this one node is the current entry. */
+export declare const treeNodeActiveAtom: (id: TTreeInstanceId, nodeId: string) => Atom<boolean>;
+/** Whether this one node is in rename mode. */
+export declare const treeNodeRenamingAtom: (id: TTreeInstanceId, nodeId: string) => Atom<boolean>;
+/** Whether this one node is the row in flight. */
+export declare const treeNodeDraggingAtom: (id: TTreeInstanceId, nodeId: string) => Atom<boolean>;
+/** Where a drop on this one node would land, `null` when it is not hovered. */
+export declare const treeNodeDropAtom: (id: TTreeInstanceId, nodeId: string) => Atom<TTreeDropPosition | null>;
+/** The whole state of one tree. Components reading a single field should
+ * subscribe to that field's atom instead — this one changes on every edit. */
+export declare const treeStateAtom: TFamily<Atom<ITreeState>>;
+export declare const expandTreeNodeAtom: TFamily<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const collapseTreeNodeAtom: TFamily<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const toggleTreeNodeAtom: TFamily<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const expandAllTreeNodesAtom: TFamily<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+export declare const collapseAllTreeNodesAtom: TFamily<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Open every ancestor of `nodeId` without touching the rest of the tree. */
+export declare const revealTreeNodeAtom: TFamily<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+/** @internal The same, silent. `useTree` runs it whenever the active id
+ * changes so a nested entry is never folded away — the hook has never
+ * reported that implicit reveal through `onExpandedChange`. */
+export declare const revealTreeAncestorsAtom: TFamily<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const setTreeCollapsedAtom: TFamily<import('jotai').WritableAtom<null, [collapsed: boolean], void> & {
+    init: null;
+}>;
+export declare const toggleTreeCollapsedAtom: TFamily<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Runs the node's own `onSelect` first, then `onNavigate` — the order a row
+ * press follows. Disabled and unknown nodes are inert. */
+export declare const selectTreeNodeAtom: TFamily<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const startTreeRenameAtom: TFamily<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const cancelTreeRenameAtom: TFamily<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Commit a rename and leave rename mode. Blank or unchanged labels are
+ * dropped. */
+export declare const renameTreeNodeAtom: TFamily<import('jotai').WritableAtom<null, [nodeId: string, label: string], void> & {
+    init: null;
+}>;
+export declare const moveTreeNodeAtom: TFamily<import('jotai').WritableAtom<null, [nodeId: string, parentId: string | null, index: number], void> & {
+    init: null;
+}>;
+/** Replace the data. Reports through `onItemsChange`; writes the atom only
+ * when no controlled `items` prop owns it. */
+export declare const setTreeItemsAtom: TFamily<import('jotai').WritableAtom<null, [items: ITreeNode[]], void> & {
+    init: null;
+}>;
+export declare const endTreeDragAtom: TFamily<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** @internal Publish the latest options; seed the instance once. */
+export declare const mountTreeAtom: TFamily<import('jotai').WritableAtom<null, [config: ITreeConfig, seed: ITreeSeed], void> & {
+    init: null;
+}>;
+/** @internal */
+export declare const setTreeHandlersAtom: TFamily<import('jotai').WritableAtom<null, [handlers: ITreeHandlers], void> & {
+    init: null;
+}>;
+/** @internal One-way projections of controlled props — no callbacks fire. */
+export declare const projectTreeItemsAtom: TFamily<import('jotai').WritableAtom<null, [items: ITreeNode[]], void> & {
+    init: null;
+}>;
+/** @internal */
+export declare const projectTreeActiveIdAtom: TFamily<import('jotai').WritableAtom<null, [activeId: string | undefined], void> & {
+    init: null;
+}>;
+/** @internal */
+export declare const projectTreeCollapsedAtom: TFamily<import('jotai').WritableAtom<null, [collapsed: boolean], void> & {
+    init: null;
+}>;
+/** Back to the values the instance mounted with. */
+export declare const resetTreeAtom: TFamily<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Drop every atom for `id`. `useTree` calls this on unmount for trees it
+ * keyed itself; an explicit `treeId` outlives its component, so a rail's fold
+ * survives a route change. */
+export declare function removeTreeInstance(id: TTreeInstanceId): void;
+export {};

package/dist-lib/components/composed/tree/tree-context.d.ts

@@ -0,0 +1,4 @@
+import { ITreeContextValue } from './type';
+import * as React from "react";
+export declare const TreeContext: React.Context<ITreeContextValue | null>;
+export declare function useTreeContext(): ITreeContextValue;

package/dist-lib/components/composed/tree/tree-node.d.ts

@@ -0,0 +1,12 @@
+import { ITreeNode } from './type';
+import * as React from "react";
+export interface ITreeRowProps {
+    node: ITreeNode;
+    depth: number;
+}
+declare function TreeRowImpl({ node, depth }: ITreeRowProps): React.ReactElement;
+/** Rows are memoized so a re-render of the root — a rail measurement, a new
+ * `renderTrailing` — does not walk the whole tree. Each row's own state
+ * reaches it through its atoms instead. */
+export declare const TreeRow: React.MemoExoticComponent<typeof TreeRowImpl>;
+export {};

package/dist-lib/components/composed/tree/tree.d.ts

@@ -0,0 +1,19 @@
+import { TTreeProps } from './type';
+import * as React from "react";
+/**
+ * A nested item tree with four shapes: `navigation` (app nav — 3-level
+ * data promotes the top level to collapsible section names), `toc`
+ * (routes on top, in-page `#` anchors at the leaves), `sidebar` (a
+ * single-level rail that collapses to icons) and `files` (a compact file
+ * explorer with rename, drag-and-drop and trailing row actions).
+ *
+ * Two ways to drive it. Data-driven like the sidebar block: pass `items`,
+ * wire `onNavigate` into your router. Or hold a `useTree` controller and
+ * pass it as `tree` — same rendering, but expand, collapse, select, rename
+ * and reorder are then callable from anywhere in your app.
+ *
+ * Branches expand with a soft height morph and row stagger; the rail's
+ * labels fold away when `collapsed` flips. Arrow keys walk visible rows,
+ * expand and collapse; F2 renames in `files`.
+ */
+export declare function Tree(props: TTreeProps): React.ReactElement;