@notis_ai/cli 0.2.17 → 0.2.19

package/dist/space-sdk/src/ui/keycap/index.d.ts

@@ -0,0 +1,2 @@
+export { Keycap, KeycapSurface, useKeyLabel } from './Keycap';
+export type { KeycapOn, KeycapProps } from './Keycap';

package/dist/space-sdk/src/ui/layout/Panels.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `Panels`: a list and the item open from it, side by side while both fit (toolkit spec 2.10).
+ *
+ * The Manager chat rule, applied inside a Space: when the list minimum plus the reader
+ * minimum (320 + 360) no longer fits the Panels container, it shows one pane, the list or
+ * the open item, as navigation decides. The open item then slides over the list and comes
+ * back with Back (and Esc when `onBack` is given).
+ *
+ * The switch is a container query on the Panels element (`nui-panels`, 680px for the
+ * defaults), not a viewport query and not the host's `data-chat-narrowed` flag: a Space
+ * renders in a shadow root, where ancestor attribute variants never reach, and its width is
+ * whatever the chat leaves it. JS mirrors the same threshold through a ResizeObserver for
+ * `usePanels().mode` (Back, `inert`) and for the drag clamp.
+ */
+import { type ReactNode } from 'react';
+export type PanelsMode = 'split' | 'stacked';
+export interface PanelsState {
+    /** `split`: list and reader side by side. `stacked`: one pane, the reader over the list. */
+    mode: PanelsMode;
+    /** The reader width on screen in split mode, inside the container. */
+    readerWidth: number;
+    /** Choose a reader width (clamped to the container, stored under `storageKey`). */
+    setReaderWidth(px: number): void;
+    /** A reader is open. */
+    readerOpen: boolean;
+    /** `mode` is known: the container was measured, or a frame passed without a width (a hidden Space keeps split). */
+    settled: boolean;
+}
+export interface PanelsProps {
+    list: ReactNode;
+    /** The open item; null shows the list alone. */
+    reader: ReactNode | null;
+    listMin?: number;
+    readerMin?: number;
+    /** The reader width wanted without a stored choice. Default `readerWantWidth(window)`: 420 under 1280, 480 from 1280. */
+    defaultReaderWidth?: number;
+    /** A drag handle on the reader's left edge (split mode only). */
+    resizable?: boolean;
+    /** Keeps the chosen reader width across visits (localStorage `notis:panels:<key>`). */
+    storageKey?: string;
+    /**
+     * Given: in stacked mode Panels shows its own Back bar above the reader and Esc goes back.
+     * Leave it out when the reader draws its own Back (read `usePanels().mode`).
+     */
+    onBack?: () => void;
+    className?: string;
+}
+/** The enclosing Panels' state. Outside one: split, no reader, the default width. */
+export declare function usePanels(): PanelsState;
+export declare function Panels({ list, reader, listMin, readerMin, defaultReaderWidth, resizable, storageKey, onBack, className, }: PanelsProps): import("react").JSX.Element;

package/dist/space-sdk/src/ui/layout/chatPanelEdge.d.ts

@@ -0,0 +1,77 @@
+/** The page column (the Manager, a Space, any page) is marked with this attribute. */
+export declare const PAGE_VIEWPORT_ATTRIBUTE = "data-notis-view-viewport";
+export type ChatPanelEdgeMethod = 'drag' | 'keyboard' | 'reset';
+export type ChatPanelEdgeTrigger = 'hover' | 'keyboard';
+export type ChatPanelEdgeOutcome<Page extends string = string> = {
+    method: ChatPanelEdgeMethod;
+    width: number | null;
+    coversPage: boolean;
+    page: Page;
+    managerPhoneLayout: boolean;
+};
+/** What the edge reports. Structural, so the host's own recorder fits as is. */
+export interface ChatPanelEdgeAnalytics<Page extends string = string> {
+    available(page: Page): void;
+    resized(outcome: ChatPanelEdgeOutcome<Page>): void;
+    pageExtended(trigger: ChatPanelEdgeTrigger, page: Page): void;
+}
+export type ChatPanelEdgeAria = {
+    now: number;
+    max: number | undefined;
+};
+export interface ChatPanelEdgeAdapters<Page extends string = string> {
+    /** The separator element; its parent is the panel. Read lazily: hosts attach refs late. */
+    handle(): HTMLElement | null;
+    /** The page kind analytics name, read whenever something is reported. */
+    page(): Page;
+    /** The recorder, read whenever something is reported (a host may swap it). */
+    analytics(): ChatPanelEdgeAnalytics<Page>;
+    /** The separator's ARIA value changed. */
+    onDescribe(aria: ChatPanelEdgeAria): void;
+    /**
+     * Root custom property where the host publishes its resting sidebar inset (px or rem).
+     * Without one the whole window is the resting row.
+     */
+    sidebarInsetProperty?: string;
+}
+/** The pointer fields the edge reads; a DOM or React pointer event fits. */
+export type EdgePointerEvent = {
+    button: number;
+    pointerId: number;
+    clientX: number;
+    currentTarget: EventTarget | null;
+    preventDefault(): void;
+};
+/** The key fields the edge reads; a DOM or React keyboard event fits. */
+export type EdgeKeyboardEvent = {
+    key: string;
+    preventDefault(): void;
+    stopPropagation(): void;
+};
+export interface ChatPanelEdge {
+    /** Before paint: read the stored width and apply it. */
+    mount(): void;
+    /** The panel opened or closed. */
+    setHidden(hidden: boolean): void;
+    /** The desktop layout (the panel beside the page) turned on or off. */
+    setDesktop(desktop: boolean): void;
+    /** Report the reached denominator: an open desktop panel that shows its edge. */
+    reportAvailable(): void;
+    /** Track whether the last input was a key press; returns the detach. */
+    trackInput(): () => void;
+    /** Follow the page viewport (size, sidebar, pointer rest, focus); returns the detach. */
+    attach(): () => void;
+    pointerDown(event: EdgePointerEvent): void;
+    pointerMove(event: EdgePointerEvent): void;
+    endDrag(): void;
+    keyDown(event: EdgeKeyboardEvent): void;
+    doubleClick(): void;
+    focus(): void;
+    blur(): void;
+}
+/** The page column the panel splits its row with in the host shell. */
+export declare function pageViewport(panel: HTMLElement): HTMLElement | null;
+export declare function createChatPanelEdge<Page extends string = string>(adapters: ChatPanelEdgeAdapters<Page>, initial: {
+    hidden: boolean;
+    desktop: boolean;
+}): ChatPanelEdge;

package/dist/space-sdk/src/ui/layout/index.d.ts

@@ -0,0 +1,5 @@
+/** Layout: Panels (list plus open item) and the chat width rule it shares with the Manager. */
+export { Panels, usePanels, type PanelsMode, type PanelsProps, type PanelsState } from './Panels';
+export * as panelMath from './panelMath';
+export * from './panelMath';
+export { PAGE_VIEWPORT_ATTRIBUTE, createChatPanelEdge, pageViewport, type ChatPanelEdge, type ChatPanelEdgeAdapters, type ChatPanelEdgeAnalytics, type ChatPanelEdgeAria, type ChatPanelEdgeMethod, type ChatPanelEdgeOutcome, type ChatPanelEdgeTrigger, type EdgeKeyboardEvent, type EdgePointerEvent, } from './chatPanelEdge';

package/dist/space-sdk/src/ui/layout/panelMath.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The width rule shared by the Manager chat panel and Space `Panels`. Pure: no React, no DOM.
+ *
+ * Two panes share a row. The side pane (the chat, or a Space's reader) pushes the main pane
+ * (the page, or a Space's list) until the main pane reaches its minimum width. Past that the
+ * chat slides over the page, as it does on mobile, but stops short of covering it: mobile
+ * brings the page back with a swipe, the desktop has no swipe. Resting the pointer on the
+ * uncovered strip extends the page back to its minimum width and shrinks the chat, until the
+ * pointer returns to the chat. A Space's `Panels` never overlaps: when its two minimums no
+ * longer fit, it shows one pane.
+ *
+ * One chat width serves every page: the protected shell mounts a single panel, so the
+ * Manager, Spaces and the floating chat open at the same width. Without a stored preference
+ * the chat is 420px at every window width; a Space reader wants 420px under a 1280px window
+ * and 480px from 1280px (`readerWantWidth`).
+ */
+/** CSS custom property the chat panel reads its width from on lg+. */
+export declare const CHAT_PANEL_WIDTH_PROPERTY = "--notis-chat-panel-width";
+/** CSS custom property for how far the chat panel slides over the page on lg+. */
+export declare const CHAT_PANEL_OVERLAP_PROPERTY = "--notis-chat-panel-overlap";
+export declare const CHAT_PANEL_WIDTH_STORAGE_KEY = "notis:chat-panel-width";
+/** The chat panel width without a stored preference, at every window width (mirrors its `lg:w-[...,420px]` fallback). */
+export declare const CHAT_PANEL_DEFAULT_WIDTH_PX = 420;
+/** The panel sits beside the page, with its edge, from Tailwind's `lg` up. */
+export declare const CHAT_PANEL_DESKTOP_MEDIA_QUERY = "(min-width: 64rem)";
+/**
+ * A chosen panel width that leaves the page narrower than this switches the Manager to its
+ * phone layout (the `manager-md:`/`manager-lg:` variants in the Portal's globals.css read the
+ * flag). Spaces switch on their own container width instead (see `Panels`).
+ */
+export declare const MANAGER_PHONE_LAYOUT_BELOW_PX = 576;
+/** Set on the page viewport while the chosen panel width narrows the page. */
+export declare const CHAT_NARROWED_ATTRIBUTE = "data-chat-narrowed";
+/** The phone layout already renders the panel this narrow, so the composer fits it. */
+export declare const CHAT_PANEL_MIN_WIDTH_PX = 360;
+/** The panel never squeezes the page narrower than this; it slides over the page instead. */
+export declare const CHAT_PANEL_MIN_CONTENT_WIDTH_PX = 320;
+/** At its widest the panel still leaves this much of the page visible and clickable. */
+export declare const CHAT_PANEL_PAGE_PEEK_PX = 80;
+export declare const CHAT_PANEL_KEYBOARD_STEP_PX = 24;
+/** How long the pointer rests on the page strip before the page extends; a pass is not a rest. */
+export declare const CHAT_PANEL_PAGE_HOVER_DELAY_MS = 200;
+/** `Panels` defaults: the same two minimums and the same page peek as the chat rule. */
+export declare const PANELS_LIST_MIN_PX = 320;
+export declare const PANELS_READER_MIN_PX = 360;
+export declare const PANELS_READER_PEEK_PX = 80;
+export declare const PANELS_KEYBOARD_STEP_PX = 24;
+export declare const PANELS_HOVER_DELAY_MS = 200;
+/** The reader width a Space wants under a 1280px window. */
+export declare const PANELS_READER_WANT_PX = 420;
+/** The reader width a Space wants from a 1280px window. */
+export declare const PANELS_READER_WANT_WIDE_PX = 480;
+/** The window width from which a Space reader wants `PANELS_READER_WANT_WIDE_PX`. */
+export declare const PANELS_READER_WIDE_FROM_PX = 1280;
+/** The reader width a Space wants in a window `windowWidth` px wide: 420 under 1280, 480 from 1280. */
+export declare function readerWantWidth(windowWidth: number): number;
+/**
+ * Widest a side pane may get in a row of `container` px (null when unknown) while `keep` px
+ * of the main pane stay visible. A row too narrow for both still gives the side pane its
+ * own minimum.
+ */
+export declare function readerMaxWidth(container: number | null, keep?: number, readerMin?: number): number;
+/** Widest a side pane gets without covering any of a main pane of minimum `listMin`. */
+export declare function pushLimit(container: number | null, listMin?: number, readerMin?: number): number;
+/** How far a side pane this wide slides over the main pane rather than squeezing it further. */
+export declare function overlap(width: number, container: number | null, listMin?: number): number;
+/** Both panes fit side by side at their minimums; otherwise `Panels` shows one pane. */
+export declare function splitFits(container: number | null, listMin?: number, readerMin?: number): boolean;
+/** The container width at which `Panels` switches between one pane and two. */
+export declare function splitBreakpoint(listMin?: number, readerMin?: number): number;
+/**
+ * A `Panels` reader width in a Space `container` px wide (null when unknown):
+ * `clamp(min(want, S - listMin), readerMin, S - peek)`. The list keeps its minimum first; a
+ * row too narrow for both gives the reader its own minimum, but always leaves the peek.
+ */
+export declare function clampReaderWidth(want: number, container: number | null, listMin?: number, readerMin?: number, peek?: number): number;
+/** A stored width is a preference only when it is a positive finite number. */
+export declare function parseStoredWidth(raw: string | null): number | null;
+/**
+ * Widest the chat panel may get. `sharedWidth` is the room the panel shares with the page
+ * (null when unknown). A row too narrow for both still gives the panel its own minimum.
+ */
+export declare function chatPanelMaxWidth(sharedWidth: number | null): number;
+/** Widest the chat panel gets without covering any of the page. */
+export declare function chatPanelPushLimit(sharedWidth: number | null): number;
+export declare function clampChatPanelWidth(width: number, sharedWidth: number | null): number;
+/** The page width a chosen panel width leaves in a row of `sharedWidth`. */
+export declare function chatPanelPageWidth(chosenWidth: number, sharedWidth: number): number;
+/** How far a chat panel this wide slides over the page rather than squeezing it further. */
+export declare function chatPanelOverlap(width: number, sharedWidth: number | null): number;
+export declare function parseStoredChatPanelWidth(raw: string | null): number | null;

package/dist/space-sdk/src/ui/list/ListReader.d.ts

@@ -0,0 +1,380 @@
+/**
+ * ListReader (toolkit spec 2.3): a list beside a reader, with the Manager's keys, selection, actions and open modes.
+ *
+ * It composes `useListKeys`, `useSelection`, `useActions`, `useSelectionBar`, `useOpenMode` and `Panels`:
+ * - J/K move the cursor (wrapping on a fresh press), Enter or a click opens the item in the current open mode.
+ * - X, Shift+J/K, Mod+A, Mod/Shift-click and press and hold select; the selection bar shows the bulk actions.
+ * - Esc closes the open item first, then clears the selection.
+ * - After an action takes the cursor row off the list, the cursor (and an open item) moves to the next row, else the
+ *   previous one. An E action (Complete, Archive) whose items stay in the list moves on to the row after them.
+ * - Side: the reader sits beside the list (Panels; below the Panels minimum it slides over the list with Back).
+ *   Center: a dialog over the list (max 880px), J/K still step through items. Full: the reader replaces the list.
+ * - The open id lives in the URL (`openParam`, default `open`): the Space URL inside a Space, the page URL (history)
+ *   on a Notis page, so reload and links restore it. An open id missing from the list shows "Item not found".
+ * - `onOpenChange` may keep the open item (unsaved edits): the list then says why in its toast. An open item that
+ *   leaves the list (a search, a refresh, a delete) stays in the reader while the page keeps it, so a page that
+ *   deletes the open item drops its unsaved edits first and the list moves on.
+ * - Toolbar: one 44px line (a status title, the tabs, "+" and the view menu), then an optional 44px info line. The
+ *   search lives in the top bar (`search`), and the open item's label joins the top bar title (`crumbLabel`).
+ * - Reader bar (48px): close or back, open as, previous, next, the item's label, its actions, More, then Open as full
+ *   page (center) or a second close (one pane). Actions past the bar's room fold into More.
+ * - Sizing: the list fills its parent (height 100%, flex 1); the page gives it a set height.
+ * - Reorder (`reorder`, off by default): drag a row, or Alt and an arrow key, to move it one item at a time; the new
+ *   order shows at once and goes back if `onReorder` rejects (`useReorder`). Off while a local search filters the list
+ *   or `groupBy` groups it.
+ */
+import { type DragEvent as ReactDragEvent, type ReactNode, type Ref } from 'react';
+import { type ActionOption, type ActionRef, type KeySpec, type Words } from '../../words';
+import { type ActionHandlers, type ActionOutcome, type ResolvedAction } from '../actions/useActions';
+import type { ToastOptions } from '../actions/useToast';
+import { type TabRowProps } from '../blocks/Tabs';
+import type { OpenMode } from '../open/openModeStore';
+import { type ListBoard } from '../board/boardModel';
+import { type RowState } from './rowState';
+import { type ReorderChange } from './useReorder';
+/** What the reader slot and the header get besides their item. */
+export interface ReaderCtx<T = unknown> {
+    /** Closes the item. Returns false when `onOpenChange` kept it open (the list then says why). */
+    close(): boolean;
+    /** Opens the next item (wraps from the last to the first when the list wraps). */
+    next(): void;
+    /** Opens the previous item (wraps from the first to the last when the list wraps). */
+    prev(): void;
+    hasNext: boolean;
+    hasPrev: boolean;
+    mode: OpenMode;
+    setMode(mode: OpenMode): void;
+    /**
+     * The section the item was opened at (`apiRef.current.open(id, { section })`), else null. The reader scrolls the
+     * element with `data-section="<section>"` into view once it renders.
+     */
+    section: string | null;
+    /** Shows words in the list's toast, the one its actions use (`useToast`). */
+    notify(words: Words | string, options?: ToastOptions): void;
+    /** The list's actions that apply to the open item, in list order (a toggle pair shows the half that fits it). */
+    actions: ResolvedAction<T>[];
+    /** Ids of the list's actions running now: a reader bar button for one shows busy. */
+    busy: ReadonlySet<string>;
+    /**
+     * Runs one of the list's actions on the open item, as its key does: busy while it runs, the list's toast after it
+     * (Undo and Z when it returned an UndoFn), and an E action moves the reader on to the next item. An action with
+     * options and no `option` opens its picker in the reader bar, at the bar button that has focus; the promise
+     * then settles with the run of the option chosen, or cancelled when the picker closes. An id the list does not have,
+     * or an action that does not apply to the item, settles cancelled.
+     */
+    run(action: ResolvedAction<T> | string, option?: ActionOption): Promise<ActionOutcome<T>>;
+    /**
+     * The open item's actions in a More menu, the menu its row has (null when none applies or it is pending). The reader
+     * bar already draws it; this places the same menu in the reader body too.
+     */
+    actionsMenu: ReactNode;
+}
+/** One button of the reader bar (`readerActions`): an icon, and its label and key when `labelled` or keyed. */
+export interface ReaderAction {
+    id: string;
+    label: Words | string;
+    /** An icon name. */
+    icon: string;
+    /** Its key: shown on the button, and it runs the action while the item is open. */
+    key?: KeySpec;
+    /** Shows the label beside the icon. Default true when `key` is set; an unlabelled button shows it in a tooltip. */
+    labelled?: boolean;
+    /** Shows the button disabled: neither a click, its key nor the More menu runs it. Every action is disabled while the open item is pending (`isPending`). */
+    disabled?: boolean;
+    run(): void | Promise<void>;
+}
+/** The parts of one tile (`renderTile`): a mark, a title and subtitle, a body, then a figure and a trailing node. */
+export interface TileParts {
+    /** A 36px mark (logo, monogram) beside the title and subtitle. */
+    mark?: ReactNode;
+    title: ReactNode;
+    subtitle?: ReactNode;
+    body?: ReactNode;
+    /** A figure at the bottom start (a count, a price). */
+    figure?: ReactNode;
+    /** At the bottom end (a status, a date, an avatar). */
+    trailing?: ReactNode;
+}
+/** One choice of the view menu's Sort or Group part, or one of its `actions`. */
+export interface ViewMenuItem {
+    id: string;
+    label: Words | string;
+    icon?: string;
+    checked?: boolean;
+    onSelect(): void;
+}
+/** The view menu (`viewMenu`): sort and group choices, a layout switch, view actions and a description, in one "..." button. */
+export interface ViewMenuProps {
+    sort?: readonly ViewMenuItem[];
+    group?: readonly ViewMenuItem[];
+    layout?: {
+        value: string;
+        options: ReadonlyArray<{
+            value: string;
+            label: Words | string;
+            icon?: string;
+        }>;
+        onChange(value: string): void;
+    };
+    /** Commands on the whole view ("Refresh research"), after the choices; `checked` is ignored. */
+    actions?: readonly ViewMenuItem[];
+    /** A muted line at the end of the menu (what the view shows). */
+    description?: Words | string;
+}
+/** The top bar search of a list (`search`). Without `onChange` the list keeps the query and filters with `match`. */
+export interface ListSearchProps<T> {
+    placeholder?: Words | string;
+    value?: string;
+    onChange?(value: string): void;
+    onSubmit?(): void | Promise<void>;
+    /** Whether an item matches the query (local query only). Default: its title or name holds the query. */
+    match?(item: T, query: string): boolean;
+}
+/** Imperative control of a ListReader (`apiRef`). */
+export interface ListReaderApi {
+    /**
+     * Opens an item, optionally at a section of its reader (see `ReaderCtx.section`). Returns false when it did not
+     * open: the item is disabled, or `onOpenChange` kept the open item (the list then says why).
+     */
+    open(id: string, options?: {
+        section?: string;
+    }): boolean;
+    /** Closes the open item. Returns false when `onOpenChange` kept it open (the list then says why). */
+    close(): boolean;
+    /** Moves the cursor without opening. */
+    focus(id: string): void;
+    /** Shows words in the list's toast, the one its actions use (`useToast`). */
+    notify(words: Words | string, options?: ToastOptions): void;
+}
+/** What `onOpenChange` returns: false, words or a string keep the open item; anything else lets the change happen. */
+export type OpenChangeVerdict = void | boolean | Words | string;
+/** Why an open change happens: a click, a key or the API (`user`), a move the list makes itself (`auto`: autoOpen, the open item left the list, an E action moved on), or the URL (`url`: load, Back and Forward, a Space link). */
+export type OpenChangeReason = 'user' | 'auto' | 'url';
+/** One group heading of a ListReader (`groupBy`). */
+export interface ListGroup {
+    id: string;
+    label: Words | string;
+}
+/** The props of `ListReader`. */
+export interface ListReaderProps<T> {
+    items: readonly T[];
+    /** Default `item.id`. */
+    getId?: (item: T) => string;
+    /** One row, usually `<Row />`; the list draws the row element and its states around it. */
+    row: (item: T, state: RowState) => ReactNode;
+    /** The open item. Leave out for a list without a reader (Enter then only calls `onOpen`). */
+    reader?: (item: T, ctx: ReaderCtx<T>) => ReactNode;
+    /** Standard action ids or custom actions, in order. */
+    actions?: readonly ActionRef<T>[];
+    /** The Space's runs for the standard ids it lists (a standard id without one is hidden). */
+    handlers?: ActionHandlers<T>;
+    /** Modes offered, the first is the default. Default side, center and full. */
+    openAs?: OpenMode | readonly OpenMode[];
+    /** 48px (default) or 40px rows. */
+    density?: 'comfortable' | 'compact';
+    /**
+     * 'table': `row` returns the cells; `columns` gives the header cells. 'board': one column per stage of `board`
+     * (BoardView sets it), each drawing its tiles with `renderTile`.
+     */
+    layout?: 'list' | 'table' | 'tiles' | 'board';
+    /** Board layout: the columns, each item's column and how tiles move. Ignored by the other layouts. */
+    board?: ListBoard<T>;
+    /** Tiles layout: draws each tile from its parts instead of `row`. */
+    renderTile?: (item: T) => TileParts;
+    /** Tiles layout: 'manager' tiles keep a 152px minimum height. */
+    tileVariant?: 'default' | 'manager';
+    /** 'two-tone' tints the list beside the reader at all times; 'plain' (default) only while an item is open. */
+    look?: 'two-tone' | 'plain';
+    /** Header cells of the table layout. */
+    columns?: ReactNode;
+    /** Consecutive items with the same group id share a heading. */
+    groupBy?: (item: T) => ListGroup;
+    /** Default true when an action is bulk. */
+    selectable?: boolean;
+    /**
+     * Drag from empty space in the list to select the rows under the rectangle (the Manager's marquee), whenever the
+     * list allows multiple selection. Pending and disabled rows are skipped. Default true; false turns it off.
+     */
+    dragSelect?: boolean;
+    /** J on the last row goes to the first. Default true. */
+    wrap?: boolean;
+    /** Shown when `items` is empty. Default `<EmptyState />`. */
+    empty?: ReactNode;
+    /** At the toolbar start: what the list shows now (a status, "Inbox"), never the page or view name. */
+    title?: {
+        text: Words | string;
+        count?: number;
+    };
+    /** Pills in the toolbar line (TabRow); the title leads them unless `tabs.lead` is set. */
+    tabs?: Omit<TabRowProps<string>, 'end'>;
+    /** Icon buttons at the toolbar end, before "+" (a refresh). Keep them few; the rest go in `actions`. */
+    toolbarActions?: ReactNode;
+    /** A "+" at the toolbar end, its label in a tooltip; `key` also runs it. */
+    create?: {
+        label: Words | string;
+        onCreate(): void;
+        key?: KeySpec;
+    };
+    /** A "..." at the toolbar end with the view's sort, group and layout choices. */
+    viewMenu?: ViewMenuProps;
+    /** One 44px line under the toolbar (a sync state, a notice). */
+    infoLine?: ReactNode;
+    /** The top bar search for this list. Leave out for a list with no search. */
+    search?: ListSearchProps<T>;
+    /**
+     * Below the list, outside its scroll (page numbers, a count): one 48px line, at the end of the row. It belongs to
+     * the list: beside an open reader it stays under the list, a reader over the list covers it, and it keeps clear of
+     * the floating Notis button. The selection bar and the undo toast sit above it.
+     */
+    footer?: ReactNode;
+    /** The open item's label in the reader bar (an id, "PRO-002"). */
+    readerLabel?: (item: T) => ReactNode;
+    /**
+     * The open item's buttons in the reader bar, before its More menu. `ctx.run` runs one of the list's actions with
+     * the list's toast. Buttons past the bar's room (more than three) fold into More.
+     */
+    readerActions?: (item: T, ctx: ReaderCtx<T>) => readonly ReaderAction[];
+    /**
+     * The open item's leaf in the top bar title ("Tickets / PRO-002"), in every open mode; null for none. Default the
+     * item's `title`, else its `name`, when it is a string.
+     */
+    crumbLabel?: (item: T) => string | null;
+    /**
+     * Side mode beside the list: open the first item once the list loads (no history step), and with nothing open
+     * show "Pick something from the list to read it." in the reader. Default false.
+     */
+    autoOpen?: boolean;
+    /** The URL param holding the open id. Default 'open'. Declare it in the Space's `params` (type text). */
+    openParam?: string;
+    /**
+     * Outside a Space: keep the open id in the page URL (`?open=`, history push on open and close). Default true.
+     * Ignored when `open` is controlled.
+     */
+    openInUrl?: boolean;
+    /** Controlled selection (ids); pair with `onSelectedChange`. */
+    selected?: readonly string[];
+    onSelectedChange?: (ids: string[]) => void;
+    /**
+     * After an action ran on the selection: 'clear' (default) empties it and keeps only the items that failed;
+     * 'keep' leaves it as it was. A cancelled run never changes it.
+     */
+    afterAction?: 'clear' | 'keep';
+    /**
+     * Rows can be dragged (all, or the ones this returns true for). Dragging a selected row carries the whole
+     * selection in list order. The drag data holds the ids as JSON under `LIST_DRAG_TYPE` and one per line as text.
+     */
+    draggable?: boolean | ((item: T) => boolean);
+    onDragStart?: (items: T[], event: ReactDragEvent<HTMLElement>) => void;
+    /**
+     * Rows can be put in a new order (off when left out): drag one, or press Alt and an arrow key (all four in tiles),
+     * Alt+Home or Alt+End. One item moves at a time. The new order shows at once; `onReorder` saves it, and when its
+     * promise rejects the list goes back to `items` and says it could not save (an `ActionError` reason shows under it).
+     * Off while a local search filters the list or `groupBy` groups it. Pending and disabled rows do not move.
+     */
+    reorder?: ListReorder<T>;
+    /** The first page is loading: skeleton rows while `items` is empty, a thin bar above the list otherwise. */
+    loading?: boolean;
+    /** More items can be loaded: a Load more button at the end, loaded as it scrolls into view and by J on the last row. */
+    hasMore?: boolean;
+    onLoadMore?: () => void | Promise<void>;
+    /** The next page is loading. */
+    loadingMore?: boolean;
+    /**
+     * A change on this item is being saved: it shows busy, cannot be selected, dragged or acted on (it still opens).
+     * A run may mark its own items pending: they leave the selection while it lasts, and once it ends `afterAction`
+     * applies to the selection the run started on (the failed items come back even before the marks clear).
+     */
+    isPending?: (item: T) => boolean;
+    /** This item cannot be opened, selected, dragged or acted on. */
+    isDisabled?: (item: T) => boolean;
+    /** Group headings fold their rows away. Default false. */
+    collapsible?: boolean;
+    /** Controlled folded group ids; pair with `onCollapsedChange`. */
+    collapsed?: readonly string[];
+    onCollapsedChange?: (ids: string[]) => void;
+    /** A muted count after each group heading. Default true. */
+    groupCounts?: boolean;
+    /** Imperative control: open an item (at a section), close, move the cursor, show a toast. */
+    apiRef?: Ref<ListReaderApi>;
+    /**
+     * Called with the item the reader shows, null when it closes: after a click, a key or the API, and when the URL
+     * opens one (on load, Back and Forward, a Space link). Without a reader, Enter and a click call it with the item.
+     */
+    onOpen?: (item: T | null) => void;
+    /**
+     * The page an item opens, for the desktop's right-click Open in new tab, Open in browser and Copy link. Default: the
+     * current URL with the open param set, when the open id lives in the URL. Return null for an item with no page.
+     */
+    itemHref?: (item: T) => string | null | undefined;
+    /** Controlled open id; pair with `onOpenChange`. */
+    open?: string | null;
+    /**
+     * Called with the id about to open (null to close): a click, a key, the API, Back and Forward, a Space link.
+     * Return false to keep the current item open, for example while its reader has unsaved edits: the list, the
+     * cursor and the URL stay as they are and the list's toast says "Save or cancel your changes first.". Return words
+     * or a string to say something else. `reason` says why the change happens; a move the list makes on its own
+     * (`auto`) is kept without a toast.
+     */
+    onOpenChange?: (id: string | null, reason: OpenChangeReason) => OpenChangeVerdict;
+    /** Shortcut owner of this list. Default a child of the Space's owner, one per list. */
+    scope?: string;
+    /** The list's id inside the Space: keys the open mode and the reader width. Default 'list'. */
+    listId?: string;
+    /** Accessible name of the list. */
+    label?: Words | string;
+    className?: string;
+}
+/** How a ListReader's rows are put in a new order (see `reorder`). */
+export interface ListReorder<T> {
+    /** Save the move: the item, its index before and after, and every id in the new order. */
+    onReorder: (change: ReorderChange<T>) => void | Promise<unknown>;
+    /** Only these items move (all by default). */
+    canReorder?: (item: T) => boolean;
+}
+/** Every word ListReader shows, in English and French. */
+export declare const LIST_READER_WORDS: Readonly<{
+    list: Words;
+    open: Words;
+    openFull: Words;
+    viewOptions: Words;
+    sort: Words;
+    group: Words;
+    layout: Words;
+    pickOne: Words;
+    pickKeys: Words;
+    rowActions: Words;
+    loadMore: Words;
+    loading: Words;
+    expandGroup: Words;
+    collapseGroup: Words;
+    keptOpen: Words;
+    notMoved: Words;
+    notFound: Words;
+    notFoundBody: Words;
+}>;
+/** The drag data type of list rows: a JSON array of ids. */
+export declare const LIST_DRAG_TYPE = "application/x-notis-items";
+/**
+ * An item's menu order (deck menu rank): the first E action, then the status actions, the others in list order,
+ * and the danger ones last.
+ */
+export declare function rankActions<A extends {
+    id: string;
+    key?: KeySpec;
+    tone?: string;
+}>(actions: readonly A[]): A[];
+/** The id that takes `gone`'s place: the next one still in `now`, else the previous one. */
+export declare function successorOf(previous: readonly string[], now: readonly string[], gone: string): string | null;
+/** A list beside a reader, with the Manager's keys, selection, actions and open modes (see the file header). */
+export interface ListSkeletonProps {
+    /** Draw a group head first, for a list that groups its rows. */
+    grouped?: boolean;
+    rows?: number;
+}
+/**
+ * The list while its first page loads, drawn like the rows it stands for: a group head when the list
+ * groups, then a lead mark and a title over a meta line. Pages use it for their own route fallbacks so
+ * the page does not shift when the real list arrives.
+ */
+export declare function ListSkeleton({ grouped, rows }: ListSkeletonProps): import("react").JSX.Element;
+export declare function ListReader<T>(props: ListReaderProps<T>): import("react").JSX.Element;