@republicroad/seal-appshell 1.1.0

package/dist/components/custom-node/http-request-node.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export declare const HttpRequestTab: React.FC<{
+    id: string;
+}>;
+export declare const httpRequestNode: import('../..').CustomNodeSpec;

package/dist/components/custom-node/key-value-editor.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+export declare const Hint: React.FC<{
+    label: string;
+    children: React.ReactElement;
+}>;
+export interface KeyValueEditorProps {
+    label: string;
+    addLabel: string;
+    deleteLabel: string;
+    valuePlaceholder: string;
+    rawPlaceholder: string;
+    value: string;
+    onChange: (next: string) => void;
+}
+/** `{ k: expr, ... }` 对象字面量 ⇄ 键值行编辑器；无法解析时自动切原始表达式模式 */
+export declare const KeyValueEditor: React.FC<KeyValueEditorProps>;

package/dist/components/custom-node/locked-corner-badge.d.ts

@@ -0,0 +1,2 @@
+/** 画布节点角标：config.locked === true 时显示，标记此节点有专属页面设计 */
+export declare function LockedCornerBadge(): import('react').JSX.Element;

package/dist/components/custom-node/query-list-node.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export declare const QueryListTab: React.FC<{
+    id: string;
+}>;
+export declare const queryListNode: import('../..').CustomNodeSpec;

package/dist/components/custom-node/schema-container-tab.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { CustomFunctionTool } from '../../lib/custom-node-types';
+type SchemaContainerTabProps = {
+    id: string;
+    tools: CustomFunctionTool[];
+};
+/**
+ * schema 驱动集合容器节点的编辑面板（udf-lab 缺陷修复）：
+ * 左列 key 文本框可编辑；右列函数用下拉展示（限定命名空间工具集）；
+ * 参数按位置序渲染表达式输入（字面量参数由调用方自带引号）。
+ */
+export declare const SchemaContainerTab: React.FC<SchemaContainerTabProps>;
+export {};

package/dist/components/icons/code.d.ts

@@ -0,0 +1,3 @@
+export default function CodeIcon({ className }: {
+    className?: string;
+}): import('react').JSX.Element;

package/dist/components/icons/flash-circle.d.ts

@@ -0,0 +1,3 @@
+export default function FlashCircleIcon({ className }: {
+    className?: string;
+}): import('react').JSX.Element;

package/dist/components/reui/alert.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | "success" | "warning" | "info" | "invert" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Alert({ className, variant, ...props }: React.ComponentProps<'div'> & VariantProps<typeof alertVariants>): import('react').JSX.Element;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<'div'>): import('react').JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<'div'>): import('react').JSX.Element;
+declare function AlertAction({ className, ...props }: React.ComponentProps<'div'>): import('react').JSX.Element;
+export { Alert, AlertTitle, AlertDescription, AlertAction };

package/dist/components/reui/autocomplete.d.ts

@@ -0,0 +1,40 @@
+import { Autocomplete as AutocompletePrimitive } from '@base-ui/react/autocomplete';
+import { VariantProps } from 'class-variance-authority';
+declare const inputVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const Autocomplete: typeof AutocompletePrimitive.Root;
+declare function AutocompleteValue({ ...props }: AutocompletePrimitive.Value.Props): import('react').JSX.Element;
+declare function AutocompleteInput({ className, size, showClear, showTrigger, ...props }: Omit<AutocompletePrimitive.Input.Props, 'size'> & VariantProps<typeof inputVariants> & {
+    showClear?: boolean;
+    showTrigger?: boolean;
+}): import('react').JSX.Element;
+declare function AutocompleteStatus({ className, ...props }: AutocompletePrimitive.Status.Props): import('react').JSX.Element;
+declare function AutocompletePortal({ ...props }: AutocompletePrimitive.Portal.Props): import('react').JSX.Element;
+declare function AutocompleteBackdrop({ ...props }: AutocompletePrimitive.Backdrop.Props): import('react').JSX.Element;
+declare function AutocompletePositioner({ className, ...props }: AutocompletePrimitive.Positioner.Props): import('react').JSX.Element;
+declare function AutocompleteList({ className, scrollAreaClassName, ...props }: AutocompletePrimitive.List.Props & {
+    scrollAreaClassName?: string;
+    scrollFade?: boolean;
+    scrollbarGutter?: boolean;
+}): import('react').JSX.Element;
+declare function AutocompleteCollection({ ...props }: React.ComponentProps<typeof AutocompletePrimitive.Collection>): import('react').JSX.Element;
+declare function AutocompleteRow({ className, ...props }: React.ComponentProps<typeof AutocompletePrimitive.Row>): import('react').JSX.Element;
+declare function AutocompleteItem({ className, ...props }: React.ComponentProps<typeof AutocompletePrimitive.Item>): import('react').JSX.Element;
+export interface AutocompleteContentProps extends React.ComponentProps<typeof AutocompletePrimitive.Popup> {
+    align?: AutocompletePrimitive.Positioner.Props['align'];
+    sideOffset?: AutocompletePrimitive.Positioner.Props['sideOffset'];
+    alignOffset?: AutocompletePrimitive.Positioner.Props['alignOffset'];
+    side?: AutocompletePrimitive.Positioner.Props['side'];
+    anchor?: AutocompletePrimitive.Positioner.Props['anchor'];
+    showBackdrop?: boolean;
+}
+declare function AutocompleteContent({ className, children, showBackdrop, align, sideOffset, alignOffset, side, anchor, ...props }: AutocompleteContentProps): import('react').JSX.Element;
+declare function AutocompleteGroup({ ...props }: React.ComponentProps<typeof AutocompletePrimitive.Group>): import('react').JSX.Element;
+declare function AutocompleteGroupLabel({ className, ...props }: React.ComponentProps<typeof AutocompletePrimitive.GroupLabel>): import('react').JSX.Element;
+declare function AutocompleteEmpty({ className, ...props }: React.ComponentProps<typeof AutocompletePrimitive.Empty>): import('react').JSX.Element;
+declare function AutocompleteClear({ className, ...props }: React.ComponentProps<typeof AutocompletePrimitive.Clear>): import('react').JSX.Element;
+declare function AutocompleteTrigger({ className, ...props }: React.ComponentProps<typeof AutocompletePrimitive.Trigger>): import('react').JSX.Element;
+declare function AutocompleteArrow({ ...props }: React.ComponentProps<typeof AutocompletePrimitive.Arrow>): import('react').JSX.Element;
+declare function AutocompleteSeparator({ className, ...props }: React.ComponentProps<typeof AutocompletePrimitive.Separator>): import('react').JSX.Element;
+export { Autocomplete, AutocompleteValue, AutocompleteTrigger, AutocompleteInput, AutocompleteStatus, AutocompletePortal, AutocompleteBackdrop, AutocompletePositioner, AutocompleteContent, AutocompleteList, AutocompleteCollection, AutocompleteRow, AutocompleteItem, AutocompleteGroup, AutocompleteGroupLabel, AutocompleteEmpty, AutocompleteClear, AutocompleteArrow, AutocompleteSeparator, };

package/dist/components/reui/badge.d.ts

@@ -0,0 +1,14 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "focus" | "success" | "warning" | "info" | "invert" | "primary-light" | "warning-light" | "success-light" | "info-light" | "destructive-light" | "invert-light" | "focus-light" | "primary-outline" | "warning-outline" | "success-outline" | "info-outline" | "destructive-outline" | "invert-outline" | "focus-outline" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "xl" | null | undefined;
+    radius?: "default" | "full" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface BadgeProps extends useRender.ComponentProps<'span'> {
+    variant?: VariantProps<typeof badgeVariants>['variant'];
+    size?: VariantProps<typeof badgeVariants>['size'];
+    radius?: VariantProps<typeof badgeVariants>['radius'];
+}
+declare function Badge({ className, variant, size, radius, render, ...props }: BadgeProps): import('react').ReactElement<any, string | import('react').JSXElementConstructor<any>>;
+export { Badge, badgeVariants, type BadgeProps };

package/dist/components/reui/cascader/cascader-async.d.ts

@@ -0,0 +1,86 @@
+import { CascaderIndex, CascaderLoadContext, CascaderLoadReason, CascaderLoadResult, CascaderLoadState, CascaderNode, CascaderSearchContext } from '../../../components/reui/cascader/cascader-types';
+/**
+ * Async data for the cascader. Loaded pages live in their own store and are
+ * MERGED onto the index built from `items`, never folded into that build:
+ * `items` changes identity on any parent re-render, and folding would discard
+ * every level the user drilled into. Map membership is the load discriminator:
+ * no `states` entry means never fetched, while an entry with no `loading`, no
+ * `error` and no children means empty for real.
+ */
+/** Fetches one level. `node` is `null` for the root level. */
+export type CascaderGetChildren<T = unknown> = (node: CascaderNode<T> | null, context: CascaderLoadContext) => CascaderNode<T>[] | CascaderLoadResult<T> | Promise<CascaderNode<T>[] | CascaderLoadResult<T>>;
+/** Server-side search, replacing the local index scan while the query is set. */
+export type CascaderOnSearch<T = unknown> = (query: string, context: CascaderSearchContext) => CascaderNode<T>[] | CascaderLoadResult<T> | Promise<CascaderNode<T>[] | CascaderLoadResult<T>>;
+/** Resolves a selected value to its ancestor chain, root first, node last. */
+export type CascaderResolveValue<T = unknown> = (value: string, context: CascaderLoadContext) => CascaderNode<T>[] | Promise<CascaderNode<T>[]>;
+export interface CascaderLoaderStore<T = unknown> {
+    /** Keyed by LEVEL: a parent's value, or `CASCADER_ROOT_KEY` for the root. */
+    pages: Map<string, CascaderNode<T>[]>;
+    states: Map<string, CascaderLoadState>;
+    /** Keyed by node value: search hits and resolved selections, level-less. */
+    detached: Map<string, CascaderNode<T>>;
+}
+export interface UseCascaderLoaderOptions<T = unknown> {
+    /** The index built from `items`, before any pages are merged in. */
+    base: CascaderIndex<T>;
+    getChildren?: CascaderGetChildren<T>;
+    onSearch?: CascaderOnSearch<T>;
+    resolveValue?: CascaderResolveValue<T>;
+    /** Milliseconds of quiet before `onSearch` fires. */
+    searchDebounce?: number;
+    /** Changing this drops every cached page, state and detached node. */
+    loadKey?: unknown;
+    /** Speculatively fetch a branch's children when it is highlighted. */
+    prefetch?: boolean;
+    /** Called when a request fails. Never for an aborted or superseded one. */
+    onLoadError?: (error: unknown, context: {
+        parent: string | null;
+        reason: string;
+    }) => void;
+    /** Whether the panel is live: the popup is open, or the cascader is inline. */
+    enabled: boolean;
+    query: string;
+    /** Level keys that are currently on screen. Root is `CASCADER_ROOT_KEY`. */
+    levels: string[];
+    /** The navigation path, handed to `onSearch` as its scope. */
+    path: string[];
+    /** Current selection, for `resolveValue`. */
+    values: string[];
+}
+export interface CascaderLoader<T = unknown> {
+    /** Whether a `getChildren` loader is configured at all. */
+    active: boolean;
+    store: CascaderLoaderStore<T>;
+    states: ReadonlyMap<string, CascaderLoadState>;
+    /**
+     * Async search hits, `null` when no `onSearch` is running. EMPTY while the
+     * first request is in flight, so the level behind is not shown as the answer.
+     */
+    searchResults: CascaderNode<T>[] | null;
+    searchState: CascaderLoadState | null;
+    /**
+     * Fetches a level's FIRST page. No-ops on a `states` entry (in flight,
+     * loaded or failed) or when `items` fills the level; pages are never
+     * consulted, so a `resolveValue` chain still fetches. The level effect fires
+     * only for on-screen levels, so a branch merely PRESSED is asked for by hand.
+     */
+    ensureLevel: (parentKey: string, reason: CascaderLoadReason) => void;
+    /** Fetches the next page of a level. No-ops unless one is available. */
+    loadMore: (parentKey: string) => void;
+    /** Refires a failed level. No-ops unless that level is in an error state. */
+    retryLevel: (parentKey: string) => void;
+    /** Schedules a speculative fetch. Safe to call on every highlight move. */
+    prefetchNode: (node: CascaderNode<T> | null | undefined) => void;
+    /**
+     * Evicts ONE level: aborts its request, drops its `states`/`pages` entries
+     * and paging latch, so the level effect refetches it. `null` = root level.
+     */
+    invalidateLevel: (value: string | null) => void;
+}
+/**
+ * The loader. A SIBLING of the `buildCascaderIndex` memo, never inside it: the
+ * build stays pure in `items`, the merge pure in that build plus this store.
+ */
+export declare function useCascaderLoader<T = unknown>({ base, getChildren, onSearch, resolveValue, searchDebounce, loadKey, prefetch, onLoadError, enabled, query, levels, path, values, }: UseCascaderLoaderOptions<T>): CascaderLoader<T>;
+/** One level's load state, `null` when never fetched. Omit for the root. */
+export declare function useCascaderLoadState(parent?: string | null): CascaderLoadState | null;

package/dist/components/reui/cascader/cascader-columns.d.ts

@@ -0,0 +1,26 @@
+import { CascaderColumn } from '../../../components/reui/cascader/cascader-context';
+import * as React from 'react';
+export interface CascaderColumnsProps extends Omit<React.ComponentProps<'div'>, 'children'> {
+    /** Width of each column. */
+    columnWidth?: number | string;
+    /** Height CAP per column. Falls back to the root `maxHeight`, then 24rem. */
+    maxHeight?: number | string;
+    /** Replaces the default panel; the seam a windowed column plugs into. */
+    children?: (column: CascaderColumn) => React.ReactNode;
+}
+/**
+ * Miller columns: the open trail side by side, one panel per level. Only the
+ * DEEPEST column is a real listbox (Base UI owns exactly one list); the trail
+ * behind is plain buttons, which keeps one state machine instead of a second,
+ * 2D one. `CascaderInput` moves between columns with ArrowLeft/ArrowRight.
+ */
+declare function CascaderColumns({ className, columnWidth, maxHeight: maxHeightProp, children, ...props }: CascaderColumnsProps): React.JSX.Element | null;
+export interface CascaderColumnPanelProps {
+    column: CascaderColumn;
+    /** Replaces the panel's rows; the empty state still wins on an empty column. */
+    children?: React.ReactNode;
+    /** Containing block for the windowed column's absolutely positioned rows. */
+    virtualized?: boolean;
+}
+declare function CascaderColumnPanel({ column, children, virtualized }: CascaderColumnPanelProps): React.JSX.Element;
+export { CascaderColumnPanel, CascaderColumns };

package/dist/components/reui/cascader/cascader-context.d.ts

@@ -0,0 +1,190 @@
+import { CascaderActionItem, CascaderChangeReason, CascaderFlatNode, CascaderIndex, CascaderLabels, CascaderLoadState, CascaderMode, CascaderNode, CascaderSearchScope } from '../../../components/reui/cascader/cascader-types';
+import * as React from 'react';
+/**
+ * Four contexts, not one: actions (config and callbacks, near-stable), state
+ * (every keystroke), render (`renderItem` identity) and highlight (every arrow
+ * key and pointer move). One combined context re-rendered every row on every
+ * keystroke, which is what made `React.memo` on the row worth nothing.
+ */
+export interface CascaderColumn<T = unknown> {
+    parent: CascaderNode<T> | null;
+    items: CascaderNode<T>[];
+    depth: number;
+    /** The node in this column that is drilled into, if any. */
+    activeValue: string | null;
+    /** Whether this is the deepest column, the one Base UI owns. */
+    active: boolean;
+}
+export interface CascaderItemState<T = unknown> {
+    branch: boolean;
+    selected: boolean;
+    disabled: boolean;
+    depth: number;
+    count: number;
+    /** Ancestor chain, root first. Populated for deep-search rows. */
+    path: CascaderNode<T>[];
+}
+/**
+ * Everything derived from the query, the path and the selection. One keystroke
+ * rebuilds most of it, so never subscribe to it from a row.
+ */
+export interface CascaderStateContextValue<T = unknown> {
+    /** Same `useMemo` identity as the actions context's `index`. */
+    index: CascaderIndex<T>;
+    path: string[];
+    expanded: ReadonlySet<string>;
+    query: string;
+    currentParent: CascaderNode<T> | null;
+    /** Rows for the current level, already filtered. */
+    levelItems: CascaderNode<T>[];
+    deepResults: CascaderNode<T>[] | null;
+    /** What `Combobox.Root` is currently rendering, in render order. */
+    renderedItems: CascaderNode<T>[];
+    columns: CascaderColumn<T>[];
+    treeRows: CascaderFlatNode<T>[];
+    selectedValues: string[];
+    /** Selected nodes below each value, at any depth. Absent means zero. */
+    selectedDescendants: ReadonlyMap<string, number>;
+    /**
+     * Per level, keyed by parent value or `CASCADER_ROOT_KEY`. MEMBERSHIP is the
+     * discriminator: no entry means never fetched, an entry with no `loading`, no
+     * `error` and no children means fetched and genuinely empty.
+     */
+    loadStates: ReadonlyMap<string, CascaderLoadState>;
+    /** Async search, `null` when idle. Separate: a search belongs to no level. */
+    searchState: CascaderLoadState | null;
+    announcement: string;
+}
+declare const CascaderStateContext: React.Context<CascaderStateContextValue<unknown> | undefined>;
+/**
+ * One provider serves every `T`, so the context holds an erased `unknown` value
+ * and this cast restores it. The primitive never inspects the payload.
+ */
+export declare function useCascaderState<T = unknown>(): CascaderStateContextValue<T>;
+/**
+ * Config and callbacks, slow enough that a memoised row can subscribe: the
+ * mutators are `[]`-dep callbacks over a latest-props ref. The three predicates
+ * are the exception, read DURING RENDER where a ref written in an effect would
+ * return the previous commit's answer, so each is memoised on its own input.
+ */
+export interface CascaderActionsContextValue<T = unknown> {
+    index: CascaderIndex<T>;
+    mode: CascaderMode;
+    multiple: boolean;
+    /** Multi-select only: a commit propagates over the LOADED subtree. */
+    cascade: boolean;
+    /** Whether a BRANCH is committable. Per-LIST: the check gutter is a COLUMN. */
+    branchesSelectable: boolean;
+    /** Draws the SINGLE-SELECT check and its gutter. Ignored in multi-select. */
+    indicator: boolean;
+    expandTrigger?: 'click' | 'hover';
+    actions: CascaderActionItem[];
+    searchScope: CascaderSearchScope;
+    maxHeight?: number | string;
+    inline: boolean;
+    invalid: boolean;
+    /**
+     * Id prefix; columns are `${baseId}-column-${depth}`. The SCHEME is contract:
+     * the filters primitive's `FilterMenuPinKeeper` restores its highlight across
+     * a live re-pin through `${baseId}-column-0` and the `cascader-item` slot.
+     */
+    baseId: string;
+    labels: CascaderLabels;
+    /**
+     * Whether rows are WINDOWED. Also handed to `Combobox.Root`, which is what
+     * makes an explicit row `index` legal: forwarding one while this is false
+     * makes `aria-activedescendant` resolve to nothing. Latched per level.
+     */
+    virtualized: boolean;
+    /** Mounts a windowing renderer, returns its unregister. LAYOUT effect only. */
+    registerVirtualRenderer: () => () => void;
+    /** The root's `virtualize` prop. `undefined` means "decide by count". */
+    virtualize?: boolean;
+    virtualizeThreshold: number;
+    estimateRowSize: number;
+    overscan: number;
+    /** Tells "this level is empty" from "not fetched yet" before a load state. */
+    hasLoader: boolean;
+    /** Next page of a level. Latched: a page with nothing new is not re-asked. */
+    loadMore: (parentKey: string) => void;
+    retryLevel: (parentKey: string) => void;
+    /**
+     * Evicts one level's async cache, `null` for the root, so membership reads
+     * never-loaded. A level that is on screen when evicted refetches at once.
+     */
+    invalidateLevel: (value: string | null) => void;
+    /** Index as of the last commit. Use in the stable callbacks, not `index`. */
+    getIndex: () => CascaderIndex<T>;
+    getState: () => CascaderStateContextValue<T>;
+    /** Highlighted row or null. A getter: the highlight moves per arrow key. */
+    getHighlighted: () => CascaderNode<T> | null;
+    setPath: (next: string[] | ((prev: string[]) => string[])) => void;
+    pushLevel: (value: string) => void;
+    popLevel: () => void;
+    goToDepth: (depth: number) => void;
+    toggleExpanded: (value: string) => void;
+    /**
+     * Registers a footer submenu as open or closed. `Combobox` has no
+     * `FloatingTree`, so one Escape would dismiss the flyout AND the cascader;
+     * the root's `onOpenChange` guard cancels the close while any is open, from a
+     * ref so it reads as of that event without re-rendering the root.
+     */
+    setFlyoutOpen: (key: string, open: boolean) => void;
+    hasOpenFlyout: () => boolean;
+    setQuery: (next: string) => void;
+    /**
+     * Replaces the selection. `onValueChange` diffs it against the current one
+     * for its node and reason; pass `reason` only when the caller knows better.
+     */
+    setSelection: (values: string[], reason?: CascaderChangeReason) => void;
+    /** Commits a node, for rows outside the listbox such as ancestor columns. */
+    commit: (node: CascaderNode<T>) => void;
+    navigate: (node: CascaderNode<T>) => void;
+    /** Into `node` as a child of `depth`, replacing anything deeper. */
+    navigateAt: (node: CascaderNode<T>, depth: number) => void;
+    /** Never undefined: falls back to a remembered label, then a synthetic node. */
+    resolveNode: (value: string) => CascaderNode<T>;
+    isBranch: (node: CascaderNode<T>) => boolean;
+    isSelectable: (node: CascaderNode<T>) => boolean;
+    isSelected: (node: CascaderNode<T>) => boolean;
+    /** Always `false` without `cascade`: partial selection needs propagation. */
+    isIndeterminate: (node: CascaderNode<T>) => boolean;
+    /**
+     * O(1) read of `selectedDescendants`; a memoised row may not subscribe.
+     * Unlike `isIndeterminate` this answers in every mode.
+     */
+    selectedDescendantCount: (node: CascaderNode<T>) => number;
+}
+declare const CascaderActionsContext: React.Context<CascaderActionsContextValue<unknown> | undefined>;
+export declare function useCascaderActions<T = unknown>(): CascaderActionsContextValue<T>;
+/**
+ * Their own context, republished every render. They cannot ride on the actions
+ * context: an inline closure read off a memoised object is whichever closure
+ * that object captured, so the row would call a stale prop over stale state.
+ */
+export interface CascaderRenderContextValue<T = unknown> {
+    renderItem?: (node: CascaderNode<T>, state: CascaderItemState<T>) => React.ReactNode;
+    renderLabel?: (node: CascaderNode<T>, state: CascaderItemState<T>) => React.ReactNode;
+}
+declare const CascaderRenderContext: React.Context<CascaderRenderContextValue<unknown>>;
+export declare function useCascaderRender<T = unknown>(): CascaderRenderContextValue<T>;
+export interface CascaderHighlight {
+    index: number;
+    value: string | null;
+}
+/**
+ * An external store, deliberately NOT React state: `onItemHighlighted` fires on
+ * every arrow key AND every pointer move over the list, so `setState` would
+ * re-render the whole root at mousemove rate. A store re-renders subscribers
+ * only, which inside the primitive is the virtualizer.
+ */
+export interface CascaderHighlightStore {
+    subscribe: (onStoreChange: () => void) => () => void;
+    getSnapshot: () => CascaderHighlight;
+    set: (next: CascaderHighlight) => void;
+}
+export declare function createCascaderHighlightStore(): CascaderHighlightStore;
+declare const CascaderHighlightContext: React.Context<CascaderHighlightStore>;
+/** Subscribes to the highlight. Re-renders ONLY the calling component. */
+export declare function useCascaderHighlight(): CascaderHighlight;
+export { CascaderActionsContext, CascaderHighlightContext, CascaderRenderContext, CascaderStateContext };

package/dist/components/reui/cascader/cascader-footer.d.ts

@@ -0,0 +1,83 @@
+import { Popover as PopoverPrimitive } from '@base-ui/react';
+import * as React from 'react';
+export type CascaderFooterProps = React.ComponentProps<'div'>;
+/**
+ * Actions pinned below the list, a SIBLING of `CascaderList`. Children win
+ * over the root's `actions` prop; with neither it renders nothing.
+ */
+declare function CascaderFooter({ className, children, onKeyDown, ...props }: CascaderFooterProps): React.JSX.Element | null;
+export interface CascaderActionProps extends Omit<React.ComponentProps<'button'>, 'onSelect'> {
+    icon?: React.ReactNode;
+    /** Fires on press, after `onClick`, and not at all when disabled. */
+    onSelect?: () => void;
+}
+/**
+ * One footer command, shaped like a row and deliberately NOT one. A real
+ * `<button>`, never a `Combobox.Item`: an item would join the arrow-key ring,
+ * appear in `filteredItems`, and vanish the moment a query matched nothing -
+ * exactly when "Create new attribute" is most useful. Disabled is
+ * `aria-disabled`, never the native attribute: that one is not a tab stop and
+ * the panel's Tab order reads `button:not([disabled])`, so a footer whose ONLY
+ * row is a disabled command had no stop after the search field (measured on
+ * `c-cascader-8`). Staying focusable costs the guards below, plus the
+ * greyed-out look: `CASCADER_ACTION_CLASS` keys that off `aria-disabled`
+ * instead of `:disabled`.
+ */
+declare function CascaderAction({ className, icon, children, onSelect, onClick, onKeyDown, disabled, ...props }: CascaderActionProps): React.JSX.Element;
+interface CascaderSubmenuContextValue {
+    rowRef: React.MutableRefObject<HTMLButtonElement | null>;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    close: () => void;
+    /** Names the flyout: a menu is labelled by the control that opens it. */
+    triggerId: string;
+    /**
+     * Whether the pending open came from the KEYBOARD. Base UI's own `openType`
+     * calls the opening arrow a POINTER open, because the trigger intercepts it
+     * and calls `setOpen` (measured: focus landed on the popup, not the first
+     * entry). A ref, so reading it in the focus phase cannot render.
+     */
+    keyboardRef: React.MutableRefObject<boolean>;
+}
+/** The flyout's own state. `close()` is the one a custom entry usually wants. */
+export declare function useCascaderSubmenu(): CascaderSubmenuContextValue;
+export interface CascaderSubmenuProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+/**
+ * A footer row plus the flyout it opens. Registers with the cascader root
+ * while open, which turns one Escape into two. Cleared in an EFFECT, so the
+ * flyout still reads as open during the event that closed it.
+ */
+declare function CascaderSubmenu({ open: openProp, defaultOpen, onOpenChange, children }: CascaderSubmenuProps): React.JSX.Element;
+export interface CascaderSubmenuTriggerProps extends Omit<React.ComponentProps<'button'>, 'onSelect'> {
+    icon?: React.ReactNode;
+}
+/**
+ * The footer row that opens the flyout, and its anchor. `aria-haspopup="menu"`
+ * rather than the `dialog` Base UI would announce: what opens is a list of
+ * commands with roving focus. `disabled` is intercepted, not forwarded:
+ * `Popover.Trigger` runs it through `useButton`, which writes the NATIVE
+ * attribute for a native `<button>` and takes the row out of the panel's Tab
+ * ring, the defect `CascaderAction` documents, and this component exposes no
+ * `focusableWhenDisabled` to opt out. Published as `aria-disabled`, with the
+ * arrow keys, Enter and Space, and the click closed by hand (`useClick`
+ * ignores `defaultPrevented`).
+ */
+declare function CascaderSubmenuTrigger({ className, icon, children, onKeyDown, onClick, disabled, ...props }: CascaderSubmenuTriggerProps): React.JSX.Element;
+export interface CascaderSubmenuContentProps extends PopoverPrimitive.Popup.Props, Pick<PopoverPrimitive.Positioner.Props, 'side' | 'align' | 'sideOffset' | 'alignOffset'> {
+}
+/**
+ * The flyout itself. `Portal` with NO `container`: a nested portal resolves to
+ * the parent portal node, the mechanism the file header describes.
+ */
+declare function CascaderSubmenuContent({ className, children, onKeyDown, side, align, sideOffset, alignOffset, ...props }: CascaderSubmenuContentProps): React.JSX.Element;
+/**
+ * Whether the footer would render anything, for a wrapper (a separator, a grid
+ * row) that has to make the same call `CascaderFooter` already makes.
+ */
+export declare function useCascaderHasActions(): boolean;
+export { CascaderAction, CascaderFooter, CascaderSubmenu, CascaderSubmenuContent, CascaderSubmenuTrigger };

package/dist/components/reui/cascader/cascader-i18n.d.ts

@@ -0,0 +1,13 @@
+import { CascaderLabels } from '../../../components/reui/cascader/cascader-types';
+/**
+ * English defaults. Every string the primitive can render lives here, so a
+ * consumer can translate the whole surface by passing `labels`.
+ */
+export declare const CASCADER_LABELS: CascaderLabels;
+/**
+ * Shallow-merges consumer overrides over the defaults, so `labels` can carry a
+ * single key without restating the rest.
+ */
+export declare function resolveCascaderLabels(labels?: Partial<CascaderLabels>): CascaderLabels;
+/** Resolves the search placeholder, which may be a string or a function. */
+export declare function resolveCascaderSearchLabel(labels: CascaderLabels, parentLabel?: string): string;

package/dist/components/reui/cascader/cascader-item.d.ts

@@ -0,0 +1,112 @@
+import { Combobox as ComboboxPrimitive } from '@base-ui/react';
+import { CascaderLoadState, CascaderNode } from '../../../components/reui/cascader/cascader-types';
+import * as React from 'react';
+type VetoableEvent = {
+    preventBaseUIHandler?: () => void;
+};
+/** A row press. The veto hook is optional: an `as="button"` row is outside Base
+ *  UI's listbox and gets a plain React event. */
+export type CascaderRowEvent = React.MouseEvent<HTMLElement> & VetoableEvent;
+/** A footer COMMAND: the row theme, so it cannot drift from the list, plus the
+ *  hover and `focus-visible` fills a plain button never gets. Fills, never a
+ *  ring: a ring under rows that all paint with a fill read as a different
+ *  widget bolted on. `focus-visible`, not `focus`, so a pointer press does not
+ *  leave a command painted as if it were still hovered. Disabled keys off
+ *  `aria-disabled`, not `:disabled`, to keep it FOCUSABLE: a footer whose only
+ *  row is disabled has no tab stop. */
+export declare const CASCADER_ACTION_CLASS = "data-highlighted:bg-accent data-highlighted:text-accent-foreground not-data-[variant=destructive]:data-highlighted:**:text-accent-foreground [&_svg:not([class*='size-'])]:size-4 rounded-md py-1 relative flex w-full cursor-default items-center outline-hidden select-none data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [--cascader-row-inset:6px] text-sm ps-[var(--cascader-row-inset,8px)]! pe-[var(--cascader-row-inset,8px)]! hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground cursor-pointer gap-2 transition-colors aria-disabled:pointer-events-none aria-disabled:opacity-50";
+export interface CascaderItemProps extends Omit<ComboboxPrimitive.Item.Props, 'value' | 'children' | 'className' | 'style' | 'onClick' | 'onMouseUp'> {
+    /** No state callback: the row merges `className` and `style` itself. */
+    className?: string;
+    style?: React.CSSProperties;
+    onClick?: (event: CascaderRowEvent) => void;
+    onMouseUp?: (event: CascaderRowEvent) => void;
+    node: CascaderNode;
+    /** Explicit render index. Required while virtualized and DELIBERATELY IGNORED
+     *  otherwise: it self-registers the row and breaks `aria-activedescendant`. */
+    index?: number;
+    /** Indentation depth. Drives `--cascader-indent` in tree mode. */
+    depth?: number;
+    /** Renders the ancestor chain under the label, for deep-search results. */
+    showPath?: boolean;
+    /** `option` renders a real `Combobox.Item`; `button` renders identical markup
+     *  outside the listbox, for the ancestor columns in columns mode. */
+    as?: 'option' | 'button';
+    /** Tree mode: this row is an expanded branch. */
+    expanded?: boolean;
+    /** Indent each depth by this many pixels. Tree mode only. */
+    indent?: number;
+    /** Whether the node has children. Defaults to the cascader's own answer, as do
+     *  the three below: callers pass them because they already hold the level,
+     *  which keeps a memoised row off the volatile context. */
+    branch?: boolean;
+    /** Whether the node may be committed. Defaults to the cascader's own answer. */
+    selectable?: boolean;
+    /** Whether the node is currently selected. Defaults to the cascader's answer. */
+    selected?: boolean;
+    /** Some but not all of the loaded subtree selected. `cascade` only. */
+    indeterminate?: boolean;
+    /** Selected nodes below this one, at any depth. Drives the trailing count. */
+    selectedCount?: number;
+    /** Paging row only: a request for this level is in flight. */
+    loading?: boolean;
+    /** Paging row only: this level's last request failed. */
+    error?: boolean;
+    /** Branch row only: this node's OWN children are being fetched. The chevron
+     *  (or, in tree mode, the expander) becomes a spinner IN PLACE, in the same
+     *  16px box: no skeleton row appears below, nothing reflows. */
+    childrenLoading?: boolean;
+    /** Branch row only: the last fetch of this node's children failed. The same
+     *  box becomes the retry. The press path is unchanged: it goes through
+     *  `navigate`, which refires the failed level rather than moving. */
+    childrenError?: boolean;
+    children?: React.ReactNode;
+}
+/** One row. Branch presses navigate instead of selecting, vetoed here with
+ *  `preventBaseUIHandler()` on `onClick` (Enter too) and on `onMouseUp`. */
+declare const CascaderItem: React.NamedExoticComponent<CascaderItemProps>;
+/** Every load-derived prop a row needs. A PAGING row reports the level it
+ *  belongs to, a BRANCH row the level it OWNS; mutually exclusive, so one call
+ *  answers both. Exported because a memoised row cannot read them itself. */
+export declare function getCascaderMoreProps(node: CascaderNode, loadStates: ReadonlyMap<string, CascaderLoadState>): {
+    loading: boolean;
+    error: boolean;
+    childrenLoading: boolean;
+    childrenError: boolean;
+};
+export interface CascaderItemsProps {
+    /** Replaces the default row for every item. */
+    children?: (node: CascaderNode, index: number) => React.ReactNode;
+}
+/** Whatever the active view is: the current level, the deepest column, or the
+ *  flattened tree rows. Lives here so `cascader.tsx` never imports a row
+ *  component, which would cycle with the context. `index` is deliberately not
+ *  passed; see `CascaderItemProps`. */
+declare function CascaderItems({ children }: CascaderItemsProps): React.JSX.Element;
+export interface CascaderGroupProps extends Omit<ComboboxPrimitive.Group.Props, 'className'> {
+    /** Base UI also accepts a state callback here; the group has no state. */
+    className?: string;
+}
+/** A run of related rows, named by the `CascaderLabel` inside it: the group is
+ *  `role="group"` and Base UI points its `aria-labelledby` at the label, where a
+ *  heading alone inside a listbox is dropped from the accessibility tree.
+ *  Grouping is composition, not data: `CascaderItems` renders one flat run per
+ *  level, so its indices line up with `listRef`. */
+declare function CascaderGroup({ className, ...props }: CascaderGroupProps): React.JSX.Element;
+export interface CascaderLabelProps extends Omit<ComboboxPrimitive.GroupLabel.Props, 'className' | 'style'> {
+    /** No state callback; outside a group this is not a Base UI part at all. */
+    className?: string;
+    style?: React.CSSProperties;
+}
+/** A heading. Inside `CascaderGroup` it is the group's accessible name; outside
+ *  one (the footer flyout is a menu, not a listbox) it is decoration only. */
+declare function CascaderLabel(props: CascaderLabelProps): React.JSX.Element;
+export interface CascaderSeparatorProps extends Omit<ComboboxPrimitive.Separator.Props, 'className'> {
+    /** Base UI also accepts a state callback here; only the orientation varies. */
+    className?: string;
+}
+/** Decorative on purpose: Base UI's separator is `role="separator"`, which a
+ *  `listbox` may not own, and a run that needs separating for a screen reader
+ *  needs a `CascaderGroup`, not a line. A consumer can pass the role back. */
+declare function CascaderSeparator({ className, ...props }: CascaderSeparatorProps): React.JSX.Element;
+export { CascaderGroup, CascaderItem, CascaderItems, CascaderLabel, CascaderSeparator };