@exegia/corpora-ui 0.20.0 → 0.22.0

package/dist-lib/components/blocks/shell/shell-metrics.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The shell's layout arithmetic, as plain functions over px.
+ *
+ * Nothing here touches React or the DOM. This module IS the contract of who
+ * gets which column, which keeps the rule unit-testable on its own and lets
+ * the shell-fit atoms (`shellFitFitsAtom`, `shellFitPanelWidthAtom`) call it
+ * without restating it: `useShellFit` only supplies the measurements.
+ */
+/** The px the shell lays itself out with. Every field is measured from a CSS
+ * variable (see `SHELL_WIDTHS`), never hard-coded, so a consumer's override
+ * flows straight through the rule. */
+export interface ShellMetrics {
+    /** What the left rail occupies right now — its expanded width, its icon
+     * width, or 0 when there is no rail at all (or it is off canvas). */
+    rail: number;
+    /** The floor the body refuses to go below. */
+    insetMin: number;
+    /** The secondary panel's floor, which is also the width it opens at. */
+    panelMin: number;
+    /** The viewport all three columns share. */
+    viewport: number;
+    /** px the shell's own frame eats before any column gets a share: its
+     * padding, plus the gap between columns.
+     *
+     * Deliberately absent from `fitsPanel` — that rule is stated against the raw
+     * viewport — but subtracted from the resize ceiling, where ignoring it lets
+     * a full-width drag push the row past the shell by exactly this much. */
+    chrome: number;
+}
+/** px the shell needs before a secondary panel can exist: the rail as it
+ * stands, plus the body and the panel at their own floors. */
+export declare function requiredWidth({ rail, insetMin, panelMin }: ShellMetrics): number;
+/**
+ * Whether the shell can hold a secondary panel at all. Strictly `<`: a shell
+ * that fits its columns exactly has no room left to give one.
+ *
+ * An unmeasurable shell fails open. A server render, a `display: none` host
+ * or a test environment with no layout engine all report 0, and a panel must
+ * never disappear over a reading the layout could not produce.
+ */
+export declare function fitsPanel(metrics: ShellMetrics): boolean;
+/** How wide the secondary panel may be: never under its own floor, never past
+ * the slack the body holds above its floor. `max` never drops below `min`, so
+ * a shell that does not fit reports a degenerate range instead of an inverted
+ * one — `fitsPanel` is what hides the panel, not a negative bound. */
+export declare function panelBounds(metrics: ShellMetrics): {
+    min: number;
+    max: number;
+};
+export declare function clampPanelWidth(width: number, metrics: ShellMetrics): number;
+/** Resizes fire per pointer move and per resize event, most of them landing
+ * on the same numbers — comparing fields keeps those from re-rendering the
+ * whole shell. */
+export declare function metricsEqual(a: ShellMetrics, b: ShellMetrics): boolean;

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

@@ -1,5 +1,68 @@
-import { ReactNode, ButtonHTMLAttributes, CSSProperties, HTMLAttributes } from 'react';
+import { ReactNode, RefObject, ButtonHTMLAttributes, CSSProperties, HTMLAttributes } from 'react';
 import { HTMLMotionProps } from 'motion/react';
+import { ShellMetrics } from './shell-metrics';
+/** The key a shell's fit state is filed under. Pass your own to reach it from
+ * anywhere (`useShellFitState("app-shell")`); leave it out and the provider
+ * generates one that dies with it. */
+export type ShellFitInstanceId = string;
+/** The range a secondary-panel resize may land in, in px. */
+export interface ShellFitPanelBounds {
+    min: number;
+    max: number;
+}
+/** What the shell measured of itself — readable by id through
+ * `useShellFitState`. */
+export interface ShellFitState {
+    /** The px the shell last measured, or null before its first measurement
+     * (a server render, a host with no layout). */
+    metrics: ShellMetrics | null;
+    /** Whether the shell can hold a secondary panel. True while unmeasured, so
+     * a panel never flickers out over a reading that has not happened yet. */
+    fits: boolean;
+    /** The secondary panel's width in px, already clamped to `bounds` — null
+     * before the first measurement, where the panel falls back to
+     * `--panel-width`. */
+    panelWidth: number | null;
+    /** The range a resize may land in. */
+    bounds: ShellFitPanelBounds;
+}
+/** Writes only — drive a shell's secondary panel by id through
+ * `useShellFitActions` without re-rendering when it moves. */
+export interface ShellFitActions {
+    /** Resize the secondary panel. Clamped on the way in, so a drag past the
+     * gutter parks at the bound instead of banking travel it has to give back. */
+    resizePanel: (width: number) => void;
+    /** Back to the width the shell mounted with — `defaultPanelWidth`, or
+     * `--panel-width` when there was none. */
+    resetPanelWidth: () => void;
+}
+/** What `useShellFit` hands the provider: the state, the actions and the id
+ * they are filed under. */
+export interface ShellFitController extends ShellFitState, ShellFitActions {
+    shellId: ShellFitInstanceId;
+}
+export interface UseShellFitOptions {
+    /** File the fit under this id so it can be read elsewhere and outlive the
+     * shell. Generated (and dropped on unmount) when omitted. */
+    shellId?: ShellFitInstanceId;
+    /** The element the shell's CSS variables live on (the provider wrapper). */
+    hostRef: RefObject<HTMLElement | null>;
+    /** Whether the left rail is expanded right now — a render input, so a fold
+     * counts the moment React commits it rather than a frame later when the
+     * width animation has moved. */
+    railOpen: boolean;
+    /** The width the secondary panel opens at, in px, instead of
+     * `--panel-width`. Read once, on mount. */
+    defaultPanelWidth?: number;
+    /** Fired whenever a measurement lands on "no room": the shell uses it to
+     * retire the panel's open state instead of parking it. */
+    onUnfit?: () => void;
+}
+/** @internal What an instance starts from, restored by `resetShellPanelWidthAtom`. */
+export interface ShellFitSeed {
+    /** The requested panel width at mount — null for `--panel-width`. */
+    panelWidth: number | null;
+}
 export interface ShellAction {
     id: string;
     label: string;
@@ -38,27 +101,53 @@ export type TPanelMap<Side extends TPanelSide = TPanelSide> = Partial<Record<Sid
  * AnimatedPanelProvider — every prop is keyed by side, there are no
  * explicit per-side props. `useShellPanels` produces the controlled subset
  * of these as `providerProps`. */
-export type ShellPanelControlProps = Pick<AnimatedSidebarProviderProps, "open" | "defaultOpen" | "onOpenChange" | "openMobile" | "defaultOpenMobile" | "onOpenMobileChange">;
+export type ShellPanelControlProps = Pick<AnimatedSidebarProviderProps, "open" | "defaultOpen" | "onOpenChange" | "openMobile" | "defaultOpenMobile" | "onOpenMobileChange" | "shellId" | "defaultPanelWidth">;
 export interface UseShellPanelsOptions {
+    /** The id the shell's fit state is filed under. Name it to read the same
+     * shell from elsewhere (`useShellFitState("app-shell")`) and to keep a
+     * dragged panel width across a route change; otherwise the hook generates
+     * one that dies with it. */
+    shellId?: ShellFitInstanceId;
     /** Initial desktop open state per side, merged over
      * `{ left: true, right: false }`. */
     defaultOpen?: AnimatedSidebarProviderProps["defaultOpen"];
     /** Initial mobile overlay state per side — every side starts closed. */
     defaultOpenMobile?: AnimatedSidebarProviderProps["defaultOpenMobile"];
+    /** The width the secondary panel opens at, in px, instead of
+     * `--panel-width`. */
+    defaultPanelWidth?: number;
     /** Panel change event returning both the next open state and the side of
      * the panel the change comes from. Mobile overlay changes report the same
      * side as their desktop counterpart. */
     onPanelChange?: (open: boolean, side: TPanelSide) => void;
 }
 export interface ShellPanelControls {
+    /** The id the shell's fit state is filed under — hand it to
+     * `useShellFitState` / `useShellFitActions` anywhere below `ExegiaProvider`. */
+    shellId: ShellFitInstanceId;
+    /** The viewport cannot hold the secondary panel beside the rail and the
+     * body at their floors, so the shell has dropped the right panel and its
+     * trigger — UI outside the shell should stand down with them. Read straight
+     * out of the shell's fit atoms; it is only ever `true` once the shell is
+     * mounted and measured. */
+    isNarrow: boolean;
+    /** The secondary panel's current width in px, or null until the shell has
+     * measured itself (the panel then sits at `--panel-width`). */
+    panelWidth: number | null;
+    /** Resize the secondary panel from outside the shell — clamped to the room
+     * the shell has. */
+    resizePanel: (width: number) => void;
     /** Live desktop open state, keyed by side. */
     open: Record<SidebarSide, boolean>;
     /** Live mobile overlay state, keyed by side. */
     openMobile: Record<SidebarSide, boolean>;
+    /** Refuses to OPEN the right panel while `isNarrow` — there is nothing on
+     * screen to open. Closing it always goes through. */
     setOpen: (open: boolean, side: SidebarSide) => void;
     setOpenMobile: (open: boolean, side: SidebarSide) => void;
     /** Desktop-only convenience — the in-shell triggers already pick the
-     * mobile state themselves when the viewport is narrow. */
+     * mobile state themselves when the viewport is narrow. Carries the same
+     * `isNarrow` refusal as `setOpen`. */
     toggle: (side: SidebarSide) => void;
     /** Spread onto ShellLayout (or AnimatedPanelProvider directly). */
     providerProps: ShellPanelControlProps;
@@ -80,6 +169,10 @@ export type SidebarVariant = "sidebar" | "floating" | "inset";
 export type SidebarCollapsible = "offcanvas" | "icon" | "none";
 export interface AnimatedSidebarContextValue {
     isMobile: boolean;
+    /** What the shell measured of itself: whether it can hold a secondary panel
+     * at all, how wide that panel is, and the range a resize may land in. The
+     * right panel and its trigger stand down when `fit.fits` is false. */
+    fit: ShellFitController;
     layoutId: string;
     /** Desktop open state, keyed by side. */
     open: Record<SidebarSide, boolean>;
@@ -93,6 +186,14 @@ export interface AnimatedSidebarContextValue {
     triggerRefs: Record<SidebarSide, React.RefObject<HTMLButtonElement | null>>;
 }
 export interface AnimatedSidebarProviderProps extends HTMLAttributes<HTMLDivElement> {
+    /** The id this shell's fit state (whether a secondary panel fits, how wide
+     * it is) is filed under in the store. Name it to read or drive the shell
+     * from elsewhere and to keep a dragged width across a route change; omit it
+     * and the provider generates one that is dropped on unmount. */
+    shellId?: ShellFitInstanceId;
+    /** The width the secondary panel opens at, in px, instead of
+     * `--panel-width`. Read once, on mount. */
+    defaultPanelWidth?: number;
     /** Controlled desktop open state, keyed by the side. A side left undefined
      * stays uncontrolled. */
     open?: SidebarOpenState;
@@ -104,12 +205,23 @@ export interface AnimatedSidebarProviderProps extends HTMLAttributes<HTMLDivElem
     /** Initial mobile overlay state — every side starts closed. */
     defaultOpenMobile?: SidebarOpenState;
     onOpenMobileChange?: (open: boolean, side: SidebarSide) => void;
+    /** Fires when the shell crosses the width a secondary panel needs (rail +
+     * body + panel at their floors). An imperative escape hatch for a consumer
+     * that mounts the provider on its own; anything under `ExegiaProvider` can
+     * subscribe by id instead with `useShellFitState(shellId).fits`. */
+    onNarrowChange?: (isNarrow: boolean) => void;
     style?: SidebarProviderStyle;
 }
 export type SidebarProviderStyle = CSSProperties & {
+    /** Left rail, expanded. */
     "--sidebar-width"?: string;
+    /** Left rail, folded to icons. */
     "--sidebar-width-icon"?: string;
     "--sidebar-width-mobile"?: string;
+    /** The secondary panel's floor, and the width it opens at. */
+    "--panel-width"?: string;
+    /** The body's floor — the secondary panel may never squeeze it past this. */
+    "--inset-min-width"?: string;
 };
 export type AnimatedSidebarInsetProps = HTMLMotionProps<"main">;
 export interface AnimatedSidebarTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {

package/dist-lib/components/blocks/shell/use-shell-fit-state.d.ts

@@ -0,0 +1,25 @@
+import { ShellFitActions, ShellFitInstanceId, ShellFitState } from './type';
+/**
+ * Read the fit of the shell registered under `shellId` from anywhere below
+ * `ExegiaProvider` — no controller, no props, no provider of its own.
+ *
+ * ```tsx
+ * const { fits, panelWidth } = useShellFitState("app-shell")
+ * ```
+ *
+ * This returns the whole state object, so the caller re-renders on every
+ * measurement. A component that reads one field should subscribe to that
+ * field's atom instead: `useAtomValue(shellFitFitsAtom("app-shell"))`.
+ */
+export declare function useShellFitState(shellId: ShellFitInstanceId): ShellFitState;
+/**
+ * Drive the secondary panel of the shell registered under `shellId` from
+ * anywhere. Writes only — the caller never re-renders when the shell moves,
+ * so this is what a command palette or a keyboard shortcut should reach for.
+ *
+ * ```tsx
+ * const shell = useShellFitActions("app-shell")
+ * <Button onClick={() => shell.resizePanel(480)}>Wide inspector</Button>
+ * ```
+ */
+export declare function useShellFitActions(shellId: ShellFitInstanceId): ShellFitActions;

package/dist-lib/components/blocks/shell/use-shell-fit.d.ts

@@ -0,0 +1,14 @@
+import { ShellFitController, UseShellFitOptions } from './type';
+/**
+ * Measures the shell and decides what the secondary panel may do: whether it
+ * exists at all, and how wide it may be dragged.
+ *
+ * The three things that move the answer are all observed here — the viewport
+ * (`resize`), the rail's fold (`railOpen`, a render input) and the user's own
+ * drag (`resizePanel`) — so no caller has to re-derive it. The measurement is
+ * the only thing this hook keeps to itself: the numbers land in the shell-fit
+ * atoms keyed by `shellId`, so anything under `ExegiaProvider` can read the
+ * verdict (`useShellFitState`) or move the panel (`useShellFitActions`)
+ * without holding this controller.
+ */
+export declare function useShellFit({ shellId: explicitId, hostRef, railOpen, defaultPanelWidth, onUnfit, }: UseShellFitOptions): ShellFitController;

package/dist-lib/components/blocks/shell/use-shell-panels.d.ts

@@ -5,5 +5,16 @@ import { ShellPanelControls, UseShellPanelsOptions } from './type';
  * callback. Spread the returned `providerProps` onto ShellLayout; the
  * setters and `toggle` are for UI that lives outside the shell (title-bar
  * buttons, command palette, shortcuts).
+ *
+ * The way back down is the store: `providerProps` carries a `shellId`, the
+ * shell files its measurement under it, and this hook reads `isNarrow` and
+ * `panelWidth` straight out of those atoms — so outside UI stands down with
+ * the panel instead of measuring `--sidebar-width` a second time. Name the
+ * `shellId` and any component below `ExegiaProvider` can do the same with
+ * `useShellFitState(shellId)`.
+ *
+ * Call it under the same `ExegiaProvider` as the shell it drives (or under
+ * none at all, on both sides): mounted above the provider it would read
+ * Jotai's default store while the shell writes to the provider's.
  */
-export declare function useShellPanels({ defaultOpen, defaultOpenMobile, onPanelChange, }?: UseShellPanelsOptions): ShellPanelControls;
+export declare function useShellPanels({ shellId: explicitId, defaultOpen, defaultOpenMobile, defaultPanelWidth, onPanelChange, }?: UseShellPanelsOptions): ShellPanelControls;

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

@@ -29,6 +29,38 @@ export declare const SUBMENU_ITEM_VARIANTS: Variants;
 export declare const FOCUSABLE_SELECTOR: string;
 export declare const MOBILE_QUERY = "(max-width: 767px)";
 export declare const SIDEBAR_KEYBOARD_SHORTCUT = "b";
+/**
+ * The shell's layout contract, in px. Every entry lands on the provider's
+ * wrapper as a CSS variable, so a consumer overrides a column by restyling it
+ * rather than by passing a prop:
+ *
+ * | variable               | column                                    |
+ * | ---------------------- | ----------------------------------------- |
+ * | `--sidebar-width`      | left rail, expanded                       |
+ * | `--sidebar-width-icon` | left rail, folded to icons                |
+ * | `--panel-width`        | secondary panel: its floor AND its default |
+ * | `--inset-min-width`    | the body's floor                          |
+ *
+ * These are only the defaults. Every measurement resolves the live variable,
+ * so an override wins over the value written here.
+ */
+export declare const SHELL_WIDTHS: {
+    readonly "--sidebar-width": "256px";
+    readonly "--sidebar-width-icon": "56px";
+    readonly "--sidebar-width-mobile": "18rem";
+    readonly "--panel-width": "320px";
+    readonly "--inset-min-width": "360px";
+};
+/** The expanded width of a panel docked to `side`: the secondary panel opens
+ * at `--panel-width`, the primary rail at `--sidebar-width`. */
+export declare function expandedWidthVar(side: "left" | "right"): "var(--panel-width)" | "var(--sidebar-width)";
+/** Resolve a CSS length — `var()` included — to px inside `host`'s cascade.
+ * Custom properties inherit, so a throwaway probe mounted in `host` reads the
+ * very `--sidebar-width` the shell lays out with, including a value a
+ * consumer overrode on the provider. Returns 0 when `host` has no layout
+ * (server render, `display: none`), so callers must fail open on 0 rather
+ * than treat it as a real measurement. */
+export declare function resolveLength(host: HTMLElement, value: string): number;
 export declare const AnimatedSidebarContext: import('react').Context<AnimatedSidebarContextValue | null>;
 export declare const AnimatedSidebarPanelContext: import('react').Context<AnimatedSidebarPanelContextValue | null>;
 export declare function useAnimatedSidebar(): AnimatedSidebarContextValue;

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

@@ -0,0 +1 @@
+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 LogoVariant = "full" | "mark";
+export interface LogoProps 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?: LogoVariant;
+    /** 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 }: LogoProps): React.ReactElement;

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

@@ -0,0 +1 @@
+export {};

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

@@ -9,10 +9,10 @@ export declare const TREE_CLOSE_DURATION = 0.15;
 export declare const TREE_MICRO_DURATION = 0.15;
 /** Sidebar rail label reveal/hide when `collapsed` flips. */
 export declare const TREE_COLLAPSE_DURATION = 0.2;
-/** The collapsed rail's width in px — an icon row plus its padding. Kept in
- * sync with the `w-11` resting class the rail falls back to before its
- * expanded width has been measured. */
-export declare const RAIL_COLLAPSED_WIDTH = 44;
+/** The collapsed rail's width in px — one `h-10 rounded-xl` icon row, edge
+ * to edge. Kept in sync with the `w-10` resting class the rail falls back to
+ * before its expanded width has been measured. */
+export declare const RAIL_COLLAPSED_WIDTH = 40;
 /** Rail label text fade — starts as the width growth is finishing, so the
  * label never reads as clipped mid-grow. */
 export declare const TREE_LABEL_REVEAL_DELAY = 0.01;

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

@@ -1,4 +1,6 @@
 export { Tree } from './tree';
 export { useTree } from './use-tree';
+export { useTreeActions, useTreeState } from './use-tree-state';
 export { moveNode, renameNode } from './utils';
-export type { TreeController, TreeControllerProps, TreeDataProps, TreeDropPosition, TreeNode, TreeProps, TreeVariant, UseTreeOptions, } from './type';
+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 { TreeActions, TreeController, TreeControllerProps, TreeDataProps, TreeDropPosition, TreeDropTarget, TreeInstanceId, TreeNode, TreeProps, TreeState, TreeVariant, UseTreeOptions, } from './type';

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

@@ -0,0 +1,160 @@
+import { Atom } from 'jotai';
+import { TreeConfig, TreeDropPosition, TreeDropTarget, TreeHandlers, TreeInstanceId, TreeNode, TreeSeed, TreeState, TreeVariant } from './type';
+/** What a tree reads as before `useTree` publishes its options. */
+export declare const DEFAULT_TREE_CONFIG: TreeConfig;
+/**
+ * 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 Family<AtomType> = ((id: TreeInstanceId) => AtomType) & {
+    remove: (id: TreeInstanceId) => void;
+};
+/** @internal */
+export declare const treeConfigAtom: Family<import('jotai').PrimitiveAtom<TreeConfig> & {
+    init: TreeConfig;
+}>;
+/** @internal Refreshed every commit; nothing subscribes, so it is free. */
+export declare const treeHandlersAtom: Family<import('jotai').PrimitiveAtom<TreeHandlers> & {
+    init: TreeHandlers;
+}>;
+/** The tree's current data — hook-owned, or the projection of a controlled
+ * `items` prop. */
+export declare const treeItemsAtom: Family<import('jotai').PrimitiveAtom<TreeNode[]> & {
+    init: TreeNode[];
+}>;
+export declare const treeActiveIdAtom: Family<import('jotai').PrimitiveAtom<string | undefined> & {
+    init: string | undefined;
+}>;
+export declare const treeExpandedIdsAtom: Family<import('jotai').PrimitiveAtom<ReadonlySet<string>> & {
+    init: ReadonlySet<string>;
+}>;
+/** Raw rail fold. Read `treeCollapsedAtom` for the variant-masked value. */
+export declare const treeRailCollapsedAtom: Family<import('jotai').PrimitiveAtom<boolean> & {
+    init: boolean;
+}>;
+export declare const treeRenamingIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+export declare const treeDraggedIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+export declare const treeDropTargetAtom: Family<import('jotai').PrimitiveAtom<TreeDropTarget | null> & {
+    init: TreeDropTarget | 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: Family<Atom<TreeNode[]>>;
+/** Rail folded to icons — always `false` outside `sidebar`. */
+export declare const treeCollapsedAtom: Family<Atom<boolean>>;
+export declare const treeSectionedAtom: Family<Atom<boolean>>;
+export declare const treeSectionIdsAtom: Family<Atom<string[]>>;
+export declare const treeCanRenameAtom: Family<Atom<boolean>>;
+export declare const treeCanMoveAtom: Family<Atom<boolean>>;
+export declare const treeVariantAtom: Family<Atom<TreeVariant>>;
+export declare const treeSoundAtom: Family<Atom<boolean>>;
+/** Whether this one node's branch is open. */
+export declare const treeNodeExpandedAtom: (id: TreeInstanceId, nodeId: string) => Atom<boolean>;
+/** Whether this one node is the current entry. */
+export declare const treeNodeActiveAtom: (id: TreeInstanceId, nodeId: string) => Atom<boolean>;
+/** Whether this one node is in rename mode. */
+export declare const treeNodeRenamingAtom: (id: TreeInstanceId, nodeId: string) => Atom<boolean>;
+/** Whether this one node is the row in flight. */
+export declare const treeNodeDraggingAtom: (id: TreeInstanceId, nodeId: string) => Atom<boolean>;
+/** Where a drop on this one node would land, `null` when it is not hovered. */
+export declare const treeNodeDropAtom: (id: TreeInstanceId, nodeId: string) => Atom<TreeDropPosition | 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: Family<Atom<TreeState>>;
+export declare const expandTreeNodeAtom: Family<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const collapseTreeNodeAtom: Family<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const toggleTreeNodeAtom: Family<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const expandAllTreeNodesAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+export declare const collapseAllTreeNodesAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Open every ancestor of `nodeId` without touching the rest of the tree. */
+export declare const revealTreeNodeAtom: Family<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: Family<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const setTreeCollapsedAtom: Family<import('jotai').WritableAtom<null, [collapsed: boolean], void> & {
+    init: null;
+}>;
+export declare const toggleTreeCollapsedAtom: Family<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: Family<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const startTreeRenameAtom: Family<import('jotai').WritableAtom<null, [nodeId: string], void> & {
+    init: null;
+}>;
+export declare const cancelTreeRenameAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Commit a rename and leave rename mode. Blank or unchanged labels are
+ * dropped. */
+export declare const renameTreeNodeAtom: Family<import('jotai').WritableAtom<null, [nodeId: string, label: string], void> & {
+    init: null;
+}>;
+export declare const moveTreeNodeAtom: Family<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: Family<import('jotai').WritableAtom<null, [items: TreeNode[]], void> & {
+    init: null;
+}>;
+export declare const endTreeDragAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** @internal Publish the latest options; seed the instance once. */
+export declare const mountTreeAtom: Family<import('jotai').WritableAtom<null, [config: TreeConfig, seed: TreeSeed], void> & {
+    init: null;
+}>;
+/** @internal */
+export declare const setTreeHandlersAtom: Family<import('jotai').WritableAtom<null, [handlers: TreeHandlers], void> & {
+    init: null;
+}>;
+/** @internal One-way projections of controlled props — no callbacks fire. */
+export declare const projectTreeItemsAtom: Family<import('jotai').WritableAtom<null, [items: TreeNode[]], void> & {
+    init: null;
+}>;
+/** @internal */
+export declare const projectTreeActiveIdAtom: Family<import('jotai').WritableAtom<null, [activeId: string | undefined], void> & {
+    init: null;
+}>;
+/** @internal */
+export declare const projectTreeCollapsedAtom: Family<import('jotai').WritableAtom<null, [collapsed: boolean], void> & {
+    init: null;
+}>;
+/** Back to the values the instance mounted with. */
+export declare const resetTreeAtom: Family<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: TreeInstanceId): void;
+export {};

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

@@ -4,4 +4,9 @@ export interface TreeRowProps {
     node: TreeNode;
     depth: number;
 }
-export declare function TreeRow({ node, depth }: TreeRowProps): React.ReactElement;
+declare function TreeRowImpl({ node, depth }: TreeRowProps): 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 {};