@notis_ai/cli 0.2.18 → 0.2.19

package/dist/space-sdk/src/tailwind.ts

@@ -0,0 +1,66 @@
+/** Build-only SDK content discovery. Author configuration and PostCSS plugins stay intact. */
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export function notisTailwindContent() {
+  let root = process.cwd();
+  let temporary: string | undefined;
+  const wrappers = new Map<string, string>();
+  const cleanup = () => {
+    if (temporary) rmSync(temporary, { recursive: true, force: true });
+    temporary = undefined;
+    wrappers.clear();
+  };
+  return {
+    name: 'notis-sdk-tailwind-content',
+    enforce: 'pre' as const,
+    configResolved(config: { root: string }) { root = config.root; },
+    transform(source: string, id: string) {
+      const stylesheet = id.split('?')[0];
+      if (!stylesheet.endsWith('.css')) return null;
+      // Tailwind 4 discovers dependency sources through CSS, not config.content.
+      // Keep the author's imports, configuration and PostCSS pipeline untouched.
+      if (/@import\s+(?:url\(\s*)?(['"])tailwindcss(?:\/[^'"]*)?\1/.test(source)) {
+        const sdkSource = dirname(fileURLToPath(import.meta.url));
+        const relativeSource = './' + relative(dirname(stylesheet), sdkSource).replaceAll('\\', '/');
+        const directive = `@source ${JSON.stringify(relativeSource)};`;
+        return source.includes(directive) ? null : { code: `${source}\n${directive}\n`, map: null };
+      }
+      if (!/@tailwind\s/.test(source)) return null;
+      const explicit = source.match(/@config\s+(['"])(.*?)\1\s*;/);
+      const config = explicit
+        ? resolve(dirname(id.split('?')[0]), explicit[2])
+        : ['ts', 'js', 'cjs', 'mjs'].map(ext => join(root, `tailwind.config.${ext}`)).find(existsSync);
+      if (!config) return null;
+      let wrapper = wrappers.get(config);
+      if (!wrapper) {
+        temporary ||= mkdtempSync(join(tmpdir(), 'notis-tailwind-'));
+        wrapper = join(temporary, `config-${wrappers.size}.ts`);
+        const sdkGlob = join(dirname(fileURLToPath(import.meta.url)), '**/*.{ts,tsx}').replaceAll('\\', '/');
+        writeFileSync(wrapper, `import config from ${JSON.stringify(config)};
+import { resolve } from 'node:path';
+const content = config.content || [];
+const files = Array.isArray(content) ? content : (content.files || []);
+const base = ${JSON.stringify(root)};
+const relativeBase = ${JSON.stringify(dirname(config))};
+export default { ...config, content: {
+  ...(Array.isArray(content) ? {} : content),
+  relative: false,
+  files: [...files.map(file => typeof file !== 'string' ? file :
+    (file.startsWith('!') ? '!' : '') + resolve(content.relative ? relativeBase : base, file.replace(/^!/, ''))),
+    ${JSON.stringify(sdkGlob)}],
+} };
+`);
+        wrappers.set(config, wrapper);
+      }
+      const directive = `@config ${JSON.stringify('./' + relative(dirname(id.split('?')[0]), wrapper).replaceAll('\\', '/'))};`;
+      // Imports must remain before @config. Vite resolves them before PostCSS.
+      const code = explicit ? source.replace(explicit[0], directive) : `${source}\n${directive}\n`;
+      return { code, map: null };
+    },
+    closeBundle: cleanup,
+    closeWatcher: cleanup,
+  };
+}

package/dist/space-sdk/src/ui/actions/ActionToast.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ActionToast (toolkit spec 2.7): the words after an action, a muted reason line when there is one, Undo when the
+ * action returned an UndoFn, and a Dismiss button when `onDismiss` is given. While Undo is offered, Z (and Mod+Z)
+ * undo at route scope; while the Undo runs its button says so and Z does nothing.
+ */
+import type { ActionToastState } from './useToast';
+export interface ActionToastProps {
+    toast: ActionToastState | null;
+    onUndo(): void;
+    /** Draws a Dismiss button that hides the toast (hidden while an Undo runs). */
+    onDismiss?(): void;
+    /** Owner override for the Z key (default the nearest ShortcutScope). */
+    owner?: string;
+}
+export declare function ActionToast({ toast, onUndo, onDismiss, owner }: ActionToastProps): import("react").JSX.Element | null;

package/dist/space-sdk/src/ui/actions/actionWords.d.ts

@@ -0,0 +1,16 @@
+/** The words and timing of the toast after an action (toolkit spec 2.7). */
+import { type Words } from '../../words';
+/** How long a toast stays (the Manager's undo toast). An Undo that is running keeps it until it ends. */
+export declare const ACTION_TOAST_MS = 6000;
+export declare const ACTION_WORDS: Readonly<{
+    failed: Words;
+    resultUnknown: Words;
+    undone: Words;
+    undoing: Words;
+    undoFailed: Words;
+    dismiss: Words;
+    failedOne: Words;
+    failedMany: Words;
+}>;
+/** The toast words after `n` items failed in a run that changed others. */
+export declare function failedItemsWords(n: number): Words;

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

@@ -0,0 +1,7 @@
+export { ACTION_TOAST_MS, ACTION_WORDS, failedItemsWords } from './actionWords';
+export { availableActions, resolveActions, useActions } from './useActions';
+export type { ActionHandlers, ActionOutcome, ActionsController, ResolvedAction, UseActionsOptions, } from './useActions';
+export { useToast } from './useToast';
+export type { ActionToastState, ToastController, ToastOptions, UseToastOptions } from './useToast';
+export { ActionToast } from './ActionToast';
+export type { ActionToastProps } from './ActionToast';

package/dist/space-sdk/src/ui/actions/useActions.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `useActions` (toolkit spec 2.7): binds the standard action catalogue to a Space's handlers. Notis owns the words,
+ * icons, keys and toasts; the Space supplies only `run`. A standard id without a `run` is hidden.
+ *
+ * Actions resolve live: labels, tones, icons and toggles follow the refs on every render (a locale change or a new
+ * label shows at once), and `run`, `appliesTo`, `toast`, `options` and `value` are read when used.
+ */
+import { type ActionDef, type ActionIcon, type ActionOption, type ActionRef, type ActionTone, type KeySpec, type StandardActionId, type Words } from '../../words';
+import { type ActionToastState, type ToastOptions } from './useToast';
+export interface ResolvedAction<T> {
+    id: string;
+    label: Words;
+    icon?: ActionIcon;
+    key?: KeySpec;
+    tone: ActionTone;
+    bulk: boolean;
+    appliesTo?: (item: T) => boolean;
+    run: ActionDef<T>['run'];
+    /** Null when the toast is turned off. */
+    toast?: ((n: number) => Words | string | null) | null;
+    /** The other half of a toggle (star/unstar, read/unread, pause/resume, enable/disable). */
+    toggle?: string;
+    /** Opens a picker instead of acting at once (move, assign, or any action with `options`). */
+    picker: boolean;
+    /** The picker choices for `items` (empty when the action has none). */
+    options?: (items: T[]) => readonly ActionOption[];
+    /** The value the items share (checked in the picker). */
+    value?: (items: T[]) => string | null | undefined;
+}
+export type ActionHandlers<T> = Partial<Record<StandardActionId, ActionDef<T>['run']>>;
+export interface UseActionsOptions {
+    /** A run or its Undo threw or rejected (the toast already says so); an Undo reports `{ id: 'undo' }`. */
+    onError?: (error: unknown, action: {
+        id: string;
+    }) => void;
+}
+/**
+ * What a run did. `done`: it ran (`failed` lists the items that did not change). `cancelled`: the run said so, or
+ * nothing applied. `failed`: it threw. `busy`: the same action was still running, so this call was ignored.
+ */
+export interface ActionOutcome<T> {
+    status: 'done' | 'cancelled' | 'failed' | 'busy';
+    done: T[];
+    failed: T[];
+}
+export interface ActionsController<T> {
+    /** Every action that has a run, in the given order. */
+    actions: ResolvedAction<T>[];
+    /**
+     * The actions that apply to `items`. Toggle pairs show one half: the first listed half that fits every item,
+     * else (a mixed selection) the first listed half that fits some, which then runs on those only. Any other
+     * action needs at least one item it applies to.
+     */
+    available(items: readonly T[]): ResolvedAction<T>[];
+    /** Runs `action` on the items it applies to, then shows its toast (with Undo when it returned one). */
+    run(action: ResolvedAction<T> | string, items: readonly T[], choice?: ActionOption): Promise<ActionOutcome<T>>;
+    /** Ids of the actions running now (the selection bar shows them busy and ignores a second press). */
+    busy: ReadonlySet<string>;
+    isBusy(id: string): boolean;
+    toast: ActionToastState | null;
+    /** Shows other words in the same toast (a note, a refusal), replacing the one on screen. */
+    notify(words: Words | string, options?: ToastOptions): void;
+    undo(): Promise<void>;
+    dismiss(): void;
+}
+export declare function resolveActions<T>(refs: readonly ActionRef<T>[], handlers?: ActionHandlers<T>): ResolvedAction<T>[];
+/** The actions of `actions` that apply to `items` (see `ActionsController.available`). */
+export declare function availableActions<T>(actions: readonly ResolvedAction<T>[], items: readonly T[]): ResolvedAction<T>[];
+export declare function useActions<T>(refs: readonly ActionRef<T>[], handlers?: ActionHandlers<T>, options?: UseActionsOptions): ActionsController<T>;

package/dist/space-sdk/src/ui/actions/useToast.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `useToast` (toolkit spec 2.7): the toast a page shows after something it did, the same toast the actions show.
+ * One at a time: a new one replaces the one on screen. It stays ACTION_TOAST_MS; an Undo that is running keeps it,
+ * busy, until the Undo ends. Draw it with `<ActionToast toast={toaster.toast} onUndo={toaster.undo}
+ * onDismiss={toaster.dismiss} />`. `useActions` and ListReader use it, so a ListReader page reaches it through its
+ * controller or ReaderCtx.notify.
+ */
+import { type UndoFn, type Words } from '../../words';
+export interface ActionToastState {
+    id: number;
+    words: Words;
+    /** A muted second line: why it failed, or a note on what happened. */
+    reason: Words | null;
+    tone: 'default' | 'danger';
+    /** Present when the toast offers Undo: the button shows and Z undoes. */
+    undo: UndoFn | null;
+    /** The Undo is running: its button says so, and a second press does nothing. */
+    undoing: boolean;
+}
+export interface ToastOptions {
+    /** `danger` for a failure. */
+    tone?: 'default' | 'danger';
+    /** Offers Undo (the button, and Z). An UndoFn that throws shows "Could not undo that." with an ActionError's reason. */
+    undo?: UndoFn | null;
+    /** A muted second line under the words. */
+    reason?: Words | string | null;
+}
+export interface UseToastOptions {
+    /** An Undo threw or rejected (the toast already says so). */
+    onError?: (error: unknown) => void;
+}
+export interface ToastController {
+    toast: ActionToastState | null;
+    /** Shows `words`, replacing the toast on screen. */
+    notify(words: Words | string, options?: ToastOptions): void;
+    /** Runs the toast's Undo. The toast stays, busy, until it ends, then says whether it worked. */
+    undo(): Promise<void>;
+    /** Hides the toast (not while its Undo runs: the outcome still shows). */
+    dismiss(): void;
+}
+export declare function useToast(options?: UseToastOptions): ToastController;

package/dist/space-sdk/src/ui/blocks/Tabs.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Tabs and TabRow: strips of pills (one look for both, Flo 5b). SegmentedControl stays for mode switches inside a
+ * section (a chart's Bars, Line, Area).
+ *
+ * Tabs: a strip of views where the choice switches the whole content below it (a page's sections, a record's panes),
+ * with its panel. TabRow: the 44px row over a list or a page (TLB1, TLB2). Role 'tabs' when the choice switches the
+ * content (tablist), role 'filter' when it narrows one list (radiogroup). It never wraps: `lead` sits before the
+ * pills, `end` is pinned at the row's end and `maxVisible` moves the rest of the pills into a More menu.
+ *
+ * The active pill is tinted (never a line or an edge on one side). Each pill can show a count. [ and ] switch to the
+ * previous or next view from anywhere on the page (route scope, listed in the ? sheet), the arrow keys move between
+ * pills while one has focus, Home and End jump to the ends. A calendar or timeline in the content takes [ and ] only
+ * while focus is inside it. On narrow widths the Tabs strip scrolls sideways; a TabRow folds the pills its row has no
+ * room for into the More menu.
+ */
+import { type ReactNode } from 'react';
+import { type Words } from '../../words';
+type Text = Words | string;
+/** The words of Tabs and TabRow: a strip's default name and its [ and ] shortcuts. */
+export declare const TABS_WORDS: Readonly<{
+    views: {
+        en: string;
+        fr: string;
+    };
+    previousView: {
+        en: string;
+        fr: string;
+    };
+    nextView: {
+        en: string;
+        fr: string;
+    };
+}>;
+/** The words of a TabRow: its default name as a filter and its More menu. */
+export declare const TABROW_WORDS: Readonly<{
+    filters: {
+        en: string;
+        fr: string;
+    };
+    more: {
+        en: string;
+        fr: string;
+    };
+    showMore: {
+        en: string;
+        fr: string;
+    };
+}>;
+/** One tab of `Tabs`. */
+export interface TabItem<V extends string> {
+    value: V;
+    label: Text;
+    icon?: ReactNode | string;
+    /** Shown after the label in a muted tone (0 included). */
+    count?: number;
+    disabled?: boolean;
+}
+/** The props of `Tabs`. */
+export interface TabsProps<V extends string> {
+    tabs: readonly TabItem<V>[];
+    value: NoInfer<V>;
+    onChange(value: NoInfer<V>): void;
+    /** The strip's accessible name. Default "Views". */
+    label?: Text;
+    /**
+     * [ and ] switch views (default true). One strip per page carries them: set false on a second or nested strip.
+     * The strip owns them: a calendar or timeline inside the content steps its period with [ and ] only while focus is
+     * inside it (after a click on it, or once a key moved focus into it).
+     */
+    keys?: boolean;
+    /**
+     * 'auto' (default): an arrow key moves to the tab and shows it. 'manual': arrows move focus only, Enter or Space
+     * shows the focused tab (for views that are slow to show).
+     */
+    activation?: 'auto' | 'manual';
+    /** When given, rendered as the tab panel of the active tab (labelled by it). Omit to render the panel yourself
+     *  with `tabPanelProps`. */
+    children?: ReactNode;
+    /** Stable prefix for tab and panel ids. Default a generated one. */
+    id?: string;
+    className?: string;
+    panelClassName?: string;
+}
+/** One pill of a TabRow. */
+export interface TabRowItem<V extends string = string> {
+    id: V;
+    label: Text;
+    /** Shown after the label in a muted tone (0 included). */
+    count?: number;
+    icon?: ReactNode | string;
+    disabled?: boolean;
+}
+/** The props of `TabRow`. */
+export interface TabRowProps<V extends string = string> {
+    /** 'tabs': the choice switches the content below (tablist). 'filter': it narrows one list (radiogroup). */
+    role: 'tabs' | 'filter';
+    items: readonly TabRowItem<V>[];
+    value: NoInfer<V>;
+    onChange(id: NoInfer<V>): void;
+    /** The strip's accessible name. Default "Views" for tabs, "Filters" for a filter. */
+    label?: Text;
+    /** The most pills the strip shows; the rest go into a More menu. The active pill always shows. Default all that fit. */
+    maxVisible?: number;
+    /** Before the pills, in the same line: a section title, a back button. */
+    lead?: ReactNode;
+    /** Pinned at the row's end: the "+" create button and the view menu. */
+    end?: ReactNode;
+    /** 'list' (default): 6px before, 8px after (8 each on a phone). 'page': 20px each side (12 on a phone). */
+    inset?: 'list' | 'page';
+    /** [ and ] step through every item from anywhere on the page (default false). One row per page carries them. */
+    keys?: boolean;
+    /** Role 'tabs': a stable prefix for tab and panel ids; the pills then control `tabPanelProps(id, value)`. */
+    id?: string;
+    className?: string;
+}
+/** Ids shared by a tab and its panel, for a panel rendered outside `<Tabs>`. */
+export declare function tabIds(prefix: string, value: string): {
+    tab: string;
+    panel: string;
+};
+/** Props for a panel rendered outside `<Tabs>`: `<div {...tabPanelProps(prefix, value)}>`. */
+export declare function tabPanelProps(prefix: string, value: string): {
+    id: string;
+    role: 'tabpanel';
+    'aria-labelledby': string;
+    tabIndex: number;
+};
+/** The next enabled tab from `from` in `direction`, wrapping round. Null when no other tab is enabled. */
+export declare function stepTab<V extends string>(tabs: readonly TabItem<V>[], from: V, direction: 1 | -1): V | null;
+/** A strip of view pills whose choice switches the content below it, with its panel when `children` is given. */
+export declare function Tabs<V extends string>({ tabs, value, onChange, label, keys, activation, children, id, className, panelClassName, }: TabsProps<V>): import("react").JSX.Element;
+/**
+ * The 44px row of pills over a list or a page (TLB1, TLB2). Role 'tabs' switches the content below (tablist), role
+ * 'filter' narrows one list (radiogroup); one look for both. It never wraps or scrolls: the pills its row has no room
+ * for, and those past `maxVisible`, go into a More menu, the active pill kept in the last place. When even the active
+ * pill alone has no room beside More and the end content, its label shortens with an ellipsis (its count stays).
+ */
+export declare function TabRow<V extends string>({ role, items, value, onChange, label, maxVisible, lead, end, inset, keys, id, className, }: TabRowProps<V>): import("react").JSX.Element;
+export {};

package/dist/space-sdk/src/ui/blocks/blocks.d.ts

@@ -0,0 +1,217 @@
+/**
+ * Building blocks promoted from Spaces (toolkit spec 2.12): Section, Badge, Button, SegmentedControl, NativeSelect,
+ * EmptyState, Notice and Metric. Flat look (no boxes, borders or eyebrows; the page title lives in the top bar), styled
+ * by `toolkit.css`. Every text prop takes EN/FR words or a plain string.
+ */
+import { type ButtonHTMLAttributes, type ReactNode, type SelectHTMLAttributes } from 'react';
+import { type Words } from '../../words';
+import type { Tone } from '../list/Row';
+type Text = Words | string;
+export declare const BLOCK_WORDS: Readonly<{
+    previousPage: {
+        en: string;
+        fr: string;
+    };
+    nextPage: {
+        en: string;
+        fr: string;
+    };
+    pageOf: {
+        en: string;
+        fr: string;
+    };
+    rangeOf: {
+        en: string;
+        fr: string;
+    };
+    pagination: {
+        en: string;
+        fr: string;
+    };
+    emptyTitle: {
+        en: string;
+        fr: string;
+    };
+    emptyBody: {
+        en: string;
+        fr: string;
+    };
+}>;
+/**
+ * What a Section holds, which sets its spacing. bar: a period or filter bar (px 24, pt 12). stats: a full-width
+ * StatRow strip. chart: a chart under its head (px 24, pt 32). data: a table or list under its head (pt 40; the head
+ * px 24, pb 12; the edge cells 24 in). form: fields across the full width (px 24, pt 24); each field caps its own width.
+ */
+export type SectionKind = 'bar' | 'stats' | 'chart' | 'data' | 'form';
+/** The props of `Section`. */
+export interface SectionProps {
+    /** What the section holds, which sets its spacing. Default 'data'. */
+    kind?: SectionKind;
+    /** A data label in the head row (h2, 14px medium); never a page title, which lives in the top bar. */
+    title?: Text;
+    /** A muted count after the title (12px, tabular). */
+    count?: number;
+    /** Muted text after the title (a date range, a source): words, or any content. */
+    meta?: ReactNode | Words;
+    /** A TabRow or SegmentedControl in the head row. A TabRow folds what does not fit into More; in a bar, other controls scroll sideways in the one row; a chart head 560px or narrower puts them on their own line. */
+    tabs?: ReactNode;
+    /** Ghost icon buttons at the end of the head row (a 32px "+", a view menu). */
+    actions?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+}
+/**
+ * A full-width page section with no border, ring, background or radius on any kind. The head row (title, count, meta,
+ * tabs, actions) shows only when one of them is given.
+ */
+export declare function Section({ kind, title, count, meta, tabs, actions, children, className }: SectionProps): import("react").JSX.Element;
+export interface BadgeProps {
+    tone?: Tone;
+    icon?: ReactNode | string;
+    /** Words or a plain string are shown in the toolkit locale; any other content as it is. */
+    children?: ReactNode | Words;
+    className?: string;
+}
+export declare function Badge({ tone, icon, children, className }: BadgeProps): import("react").JSX.Element;
+/**
+ * default: a soft neutral fill. primary: the page's main action. secondary: the Portal's secondary fill. ghost: no
+ * fill until hover. link: text in the primary colour, underlined on hover. danger: a destructive action.
+ */
+export type ButtonVariant = 'default' | 'primary' | 'secondary' | 'ghost' | 'link' | 'danger';
+export type ButtonSize = 'sm' | 'md' | 'lg';
+export interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    icon?: ReactNode | string;
+    /**
+     * Makes the button a toggle (aria-pressed): quiet while off, filled while on, whatever the variant. Its hover is
+     * lighter than the on fill, so an off toggle under the pointer never reads as on. For several, see ToggleGroup.
+     */
+    pressed?: boolean;
+    children?: ReactNode | Words;
+}
+export declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface ToggleGroupProps<V extends string> {
+    options: readonly SegmentedOption<V>[];
+    /** The options that are on. */
+    value: readonly V[];
+    /** The options on after a press, in option order. */
+    onChange(value: V[]): void;
+    /** The group's accessible name. */
+    label?: Text;
+    /** Default 'sm'. */
+    size?: ButtonSize;
+    className?: string;
+}
+/**
+ * Several toggles, any number on (filters, chart series): a role="group" of aria-pressed buttons. Each press turns
+ * one option on or off; the caller decides what an empty set means (keep the last one on, or turn them all on).
+ * For one choice out of several use SegmentedControl.
+ */
+export declare function ToggleGroup<V extends string>({ options, value, onChange, label, size, className }: ToggleGroupProps<V>): import("react").JSX.Element;
+export interface SegmentedOption<V extends string> {
+    value: V;
+    label: Text;
+    icon?: ReactNode | string;
+    count?: number;
+    disabled?: boolean;
+}
+export interface SegmentedControlProps<V extends string> {
+    options: readonly SegmentedOption<V>[];
+    value: V;
+    onChange(value: V): void;
+    /** The group's accessible name. */
+    label?: Text;
+    className?: string;
+}
+/** Pills for a mode switch inside a section (a chart's Bars, Line, Area; the period bar's presets); never a TabRow. */
+export declare function SegmentedControl<V extends string>({ options, value, onChange, label, className }: SegmentedControlProps<V>): import("react").JSX.Element;
+export interface SwitchProps {
+    checked: boolean;
+    onChange(checked: boolean): void;
+    /** Accessible name; shown beside the switch unless `hideLabel`. */
+    label: Text;
+    /** Keep the label for screen readers only (a row already says what the switch does). */
+    hideLabel?: boolean;
+    disabled?: boolean;
+    /** A change is being saved: the switch shows busy and ignores presses. */
+    busy?: boolean;
+    /** 'sm' (default, 16px tall, rows and menus) or 'md' (20px, settings). */
+    size?: 'sm' | 'md';
+    className?: string;
+}
+/**
+ * An on/off switch (role switch). Clicks on it never reach the row under it, so it sits inside a list row without
+ * opening the row.
+ */
+export declare function Switch({ checked, onChange, label, hideLabel, disabled, busy, size, className }: SwitchProps): import("react").JSX.Element;
+export interface PaginationProps {
+    /** The current page, from 1. */
+    page: number;
+    /** How many pages; with `total` and `pageSize` it is worked out. */
+    pageCount?: number;
+    /** Item count: the label then reads "21 to 40 of 134". */
+    total?: number;
+    pageSize?: number;
+    onChange(page: number): void;
+    /** A page is loading: the buttons wait. */
+    busy?: boolean;
+    className?: string;
+}
+/** Previous and next page buttons with "Page 2 of 5" (or "21 to 40 of 134" when the total is known). */
+export declare function Pagination({ page, pageCount, total, pageSize, onChange, busy, className }: PaginationProps): import("react").JSX.Element;
+export interface NativeSelectOption<V extends string> {
+    value: V;
+    label: Text;
+    disabled?: boolean;
+}
+export interface NativeSelectProps<V extends string> extends Omit<SelectHTMLAttributes<HTMLSelectElement>, 'value' | 'onChange' | 'children'> {
+    options: readonly NativeSelectOption<V>[];
+    value: V;
+    onChange(value: V): void;
+    /** Accessible name (no visible label). */
+    label?: Text;
+}
+/** The platform select, styled flat: the right control on phones and in narrow toolbars. */
+export declare function NativeSelect<V extends string>({ options, value, onChange, label, className, ...rest }: NativeSelectProps<V>): import("react").JSX.Element;
+export interface EmptyStateProps {
+    /** Default "Nothing here yet". */
+    title?: Text;
+    body?: Text;
+    /** A button under the text. */
+    action?: ReactNode;
+    icon?: ReactNode | string;
+    className?: string;
+}
+export declare function EmptyState({ title, body, action, icon, className }: EmptyStateProps): import("react").JSX.Element;
+export interface NoticeProps {
+    tone?: Tone;
+    children?: ReactNode | Words;
+    /** Shows a Try again button. */
+    onRetry?: () => void;
+    /** Other buttons on the right. */
+    action?: ReactNode;
+    /**
+     * The message cannot wait: a screen reader breaks off what it is saying to read it (role="alert"). Keep it for a
+     * problem the person must act on now; any tone may be urgent. Default false: role="status", read once the reader is
+     * idle, also for danger.
+     */
+    urgent?: boolean;
+    className?: string;
+}
+/** A one-line message in the page (an error with Try again, a warning, a tip). Only an urgent notice is an alert. */
+export declare function Notice({ tone, children, onRetry, action, urgent, className }: NoticeProps): import("react").JSX.Element;
+export interface MetricProps {
+    label: Text;
+    value: ReactNode;
+    /** A change against the comparison period, already formatted ("+12%"). */
+    delta?: ReactNode;
+    /** Colours the delta: up is good unless `invert`. */
+    trend?: 'up' | 'down' | 'flat';
+    /** A rising value is bad (costs, errors). */
+    invert?: boolean;
+    hint?: Text;
+    className?: string;
+}
+export declare function Metric({ label, value, delta, trend, invert, hint, className }: MetricProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,4 @@
+export { BLOCK_WORDS, Badge, Button, EmptyState, Metric, NativeSelect, Notice, Pagination, Section, SegmentedControl, Switch, ToggleGroup, } from './blocks';
+export type { BadgeProps, ButtonProps, ButtonSize, ButtonVariant, EmptyStateProps, MetricProps, NativeSelectOption, NativeSelectProps, NoticeProps, PaginationProps, SectionKind, SectionProps, SegmentedControlProps, SegmentedOption, SwitchProps, ToggleGroupProps, } from './blocks';
+export { TABROW_WORDS, TABS_WORDS, TabRow, Tabs, stepTab, tabIds, tabPanelProps } from './Tabs';
+export type { TabItem, TabRowItem, TabRowProps, TabsProps } from './Tabs';

package/dist/space-sdk/src/ui/board/BoardView.d.ts

@@ -0,0 +1,36 @@
+/**
+ * BoardView (toolkit spec 2.3, board layout): a Kanban board, one column per stage, built on ListReader so the reader,
+ * open modes, `openParam`, selection, the selection bar and actions behave exactly as in a list.
+ *
+ * - Columns sit side by side (gap 12, padding 12) and each scrolls on its own; the board scrolls sideways. On a phone
+ *   each column takes about 85% of the width and snaps into place.
+ * - Tiles are ListReader tiles (`renderTile`): a ring on all four sides, never a coloured edge or a shadow.
+ * - Arrows move the cursor: Up/Down (and J/K) within a column, Left/Right to the nearest column with tiles. Enter or
+ *   a click opens the tile in the reader beside the board, or as a slide when there is no room. Esc closes it. With
+ *   nothing open the board runs full width, and nothing opens or closes on its own when the width changes.
+ * - Selection: X, Shift+Up/Down, Mod+A, Mod-click and Shift-click; the selection bar floats as a pill.
+ * - Moving (with `onMove`): drag a tile or the selection to a column (a line shows where it lands), Shift+Left/Right
+ *   to the next column, or M (Move to) and pick a column. The page moves the items (optimistically, if it likes); the
+ *   cursor stays on the moved tile.
+ */
+import type { Words } from '../../words';
+import { type ListReaderProps, type TileParts } from '../list/ListReader';
+import type { BoardColumn, BoardMoveHandler } from './boardModel';
+/** The props of `BoardView`: ListReader's, with the board's columns instead of rows and groups. */
+export interface BoardViewProps<T> extends Omit<ListReaderProps<T>, 'row' | 'layout' | 'renderTile' | 'columns' | 'groupBy' | 'collapsible' | 'collapsed' | 'onCollapsedChange' | 'tileVariant' | 'autoOpen' | 'hasMore' | 'onLoadMore' | 'loadingMore' | 'empty' | 'density' | 'board'> {
+    /** The stages, left to right. A `tone` adds a small dot before the label. */
+    columns: readonly BoardColumn[];
+    /** The id of the column an item sits in. An item whose column is not listed is not shown. */
+    getColumn(item: T): string;
+    /** One tile: title, subtitle, body, figure, trailing (and a mark). */
+    renderTile(item: T): TileParts;
+    /**
+     * Moves tiles to `toColumnId`: drag and drop (with `index`, the place among the tiles that stay in that column),
+     * Shift+Left/Right and the M (Move to) menu (without). Return an UndoFn for Undo in the toast. Leave out for a board
+     * that only reads.
+     */
+    onMove?: BoardMoveHandler;
+    /** Shown in a column with no tiles. Default "No items" / "Aucun élément". */
+    emptyColumn?: Words | string;
+}
+export declare function BoardView<T>({ columns, getColumn, renderTile, onMove, emptyColumn, ...rest }: BoardViewProps<T>): import("react").JSX.Element;