@notis_ai/cli 0.2.18 → 0.2.20

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

@@ -0,0 +1,46 @@
+/**
+ * The board model (toolkit spec 2.3, board layout): its columns, how a ListReader in `layout="board"` is told about
+ * them, and the pure helpers the board uses (column order, the neighbour column, the drop index).
+ */
+import type { ActionRunResult, Words } from '../../words';
+import type { Tone } from '../list/Row';
+/** One column of a board: a stage. `tone` adds a small dot before its label (never a coloured edge). */
+export interface BoardColumn {
+    id: string;
+    label: Words | string;
+    tone?: Tone;
+}
+/**
+ * Where tiles go. `toColumnId` is the column; `index` is the place in that column among the tiles that stay there
+ * (0 = first), given by a drop. A keyboard or menu move leaves it out: the tiles join the column wherever the page puts
+ * them. The page moves the items (optimistically, if it likes); the board keeps the cursor on the moved tile. Return
+ * an UndoFn for Undo in the toast, or `{ failed }` / throw to say it did not work.
+ */
+export type BoardMoveHandler = (ids: string[], toColumnId: string, index?: number) => ActionRunResult | Promise<ActionRunResult>;
+/** The board of a ListReader in `layout="board"` (BoardView builds it). */
+export interface ListBoard<T> {
+    columns: readonly BoardColumn[];
+    /** The id of the column an item sits in. An item whose column is not in `columns` is not shown. */
+    getColumn(item: T): string;
+    /** Moves tiles: drag and drop, Shift+Left/Right and the M (Move to) menu. 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;
+}
+/** Items in board order: column by column (as `columns` lists them), each keeping the order `items` gave. */
+export declare function boardOrder<T>(items: readonly T[], columns: readonly BoardColumn[], getColumn: (item: T) => string): T[];
+/** The column next to `columnId` (`-1` left, `1` right), empty or not; null at the edge or for an unknown column. */
+export declare function neighbourColumn(columns: readonly BoardColumn[], columnId: string, delta: -1 | 1): string | null;
+/**
+ * Where a drop at `pointerY` lands in a column: the index among `tiles` (the column's tiles in order, the dragged ones
+ * left out) of the first tile whose middle is below the pointer, else the end. `before` is that tile's id (null at the
+ * end), where the drop line shows.
+ */
+export declare function dropIndex(tiles: ReadonlyArray<{
+    id: string;
+    top: number;
+    height: number;
+}>, pointerY: number): {
+    index: number;
+    before: string | null;
+};

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

@@ -0,0 +1,9 @@
+/** The board's own words (EN and FR). Move to, Open and the rest come from the action catalogue and the list. */
+import { type Words } from '../../words';
+export declare const BOARD_WORDS: Readonly<{
+    board: Words;
+    moveLeft: Words;
+    moveRight: Words;
+    emptyColumn: Words;
+    moved: Words;
+}>;

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

@@ -0,0 +1,5 @@
+export { BoardView } from './BoardView';
+export type { BoardViewProps } from './BoardView';
+export { boardOrder, dropIndex as boardDropIndex, neighbourColumn } from './boardModel';
+export type { BoardColumn, BoardMoveHandler, ListBoard } from './boardModel';
+export { BOARD_WORDS } from './boardWords';

package/dist/space-sdk/src/ui/calendar/CalendarView.d.ts

@@ -0,0 +1,49 @@
+/**
+ * CalendarView (toolkit spec 2.11, deck "calendar": month, week and agenda over the same items, plus a tray of items
+ * with no date). Keys (spec 3, settled in 6): `[` and `]` step a month (a week, three weeks in the agenda), T comes
+ * back to today and puts the cursor on today's first item, J/K and the up and down arrows walk the items in reading
+ * order, the left and right arrows jump to the next or previous day with items, Enter opens.
+ *
+ * Generic over the item: give `getDate` (and `getEnd` for multi-day items); `row` draws an item, else its title.
+ */
+import * as React from 'react';
+import { type Locale, type Words } from '../../words/types';
+import { type CalendarViewKind, type DateInput } from './calendarMath';
+/** How an item is drawn: a month chip, a dot (narrow month), a week or tray card, an agenda row. */
+export type CalendarItemVariant = 'chip' | 'dot' | 'card' | 'row';
+export interface CalendarViewProps<T> {
+    items: readonly T[];
+    getDate: (item: T) => DateInput;
+    /** Last day of a multi-day item (drawn on every day, counted once by the keys). */
+    getEnd?: (item: T) => DateInput;
+    /** Default `item.id`. */
+    getId?: (item: T) => string;
+    /** Default `item.title` (or `item.name`). */
+    getTitle?: (item: T) => string;
+    /** Draws an item; the toolkit gives the chip, focus and keys around it. */
+    row?: (item: T, variant: CalendarItemVariant) => React.ReactNode;
+    view?: CalendarViewKind;
+    defaultView?: CalendarViewKind;
+    onViewChange?: (view: CalendarViewKind) => void;
+    /** Views offered by the switch, in order. Default month, week, agenda. */
+    views?: readonly CalendarViewKind[];
+    onOpen?: (item: T) => void;
+    /** The open item (drawn as open). */
+    openId?: string | null;
+    /** Shows the tray of items with no date. Default true. */
+    tray?: boolean;
+    /** Accessible name of the item list. Default "Items by date". */
+    label?: Words | string;
+    locale?: Locale;
+    className?: string;
+    /** Today, for tests and previews. */
+    today?: Date;
+}
+/** Below this width the month view draws dots and narrow weekday names, and the week stacks. */
+export declare const CALENDAR_NARROW_MAX = 640;
+/** Below this width the tray goes under the grid. */
+export declare const CALENDAR_TRAY_SIDE_MIN = 900;
+export declare function CalendarView<T>(props: CalendarViewProps<T>): React.JSX.Element;
+export declare namespace CalendarView {
+    var displayName: string;
+}

package/dist/space-sdk/src/ui/calendar/DayPicker.d.ts

@@ -0,0 +1,23 @@
+/**
+ * DayPicker: the react-day-picker calendar the Portal used (`portal/src/components/ui/calendar.tsx`), moved into the
+ * toolkit (spec 2.11) and re-skinned with `nui-dp-*` classes in toolkit.css instead of Tailwind and the library sheet.
+ *
+ * Weeks start on Monday, as in the deck. Month and day names follow the toolkit locale (EN or FR) unless a
+ * react-day-picker `locale` is passed. Weekday heads use the narrow names ("M T W" / "L M M", B7) so the grid fits.
+ */
+import * as React from 'react';
+import { DayPicker as ReactDayPicker } from 'react-day-picker';
+import type { Locale } from '../../words/types';
+export type { DateRange, Matcher } from 'react-day-picker';
+type ReactDayPickerProps = React.ComponentProps<typeof ReactDayPicker>;
+/** Omit that keeps the single, multiple and range modes apart. */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+export type DayPickerProps = DistributiveOmit<ReactDayPickerProps, 'locale'> & {
+    /** `en` or `fr`; defaults to the toolkit locale. A react-day-picker locale object is accepted too. */
+    locale?: Locale | ReactDayPickerProps['locale'];
+};
+/** A calendar of days in the toolkit look: Monday first, narrow weekday heads, EN or FR names. */
+export declare function DayPicker({ className, classNames, components, formatters, showOutsideDays, locale, ...props }: DayPickerProps): React.JSX.Element;
+export declare namespace DayPicker {
+    var displayName: string;
+}

package/dist/space-sdk/src/ui/calendar/calendarMath.d.ts

@@ -0,0 +1,81 @@
+/**
+ * CalendarView math (toolkit spec 2.11, deck layouts-new.js calendar). Pure: date-fns only, no React.
+ *
+ * Weeks start on Monday. Month view shows whole weeks around the month; week view one week; agenda three weeks
+ * from the start of the shown week, skipping empty days except today. Navigation order is the order the chips
+ * appear: day by day, then the tray of items with no date.
+ */
+import { toIsoDay } from '../period/periods';
+export type CalendarViewKind = 'month' | 'week' | 'agenda';
+export declare const CALENDAR_VIEWS: readonly CalendarViewKind[];
+/** Days an agenda shows. */
+export declare const AGENDA_DAYS = 21;
+/** A month cell shows this many chips; with more, one fewer plus "+N more". */
+export declare const MONTH_CHIPS = 3;
+/** A multi-day item is drawn on at most this many days. */
+export declare const MAX_SPAN_DAYS = 62;
+export type DateInput = Date | string | number | null | undefined;
+/** A local day from a Date, an ISO day ("2026-10-15", local), an ISO time or a timestamp. Invalid gives null. */
+export declare function toDay(value: DateInput): Date | null;
+export declare const dayKey: typeof toIsoDay;
+/** Monday of the week holding `date`. */
+export declare function weekStart(date: Date): Date;
+export declare function isWeekend(date: Date): boolean;
+/** The first day each view starts on for an offset (months for month, weeks for week and agenda) from today. */
+export declare function viewStart(view: CalendarViewKind, offset: number, today: Date): Date;
+/** How far `[` and `]` move the offset: one month, one week, or three weeks for the agenda. */
+export declare function offsetStep(view: CalendarViewKind): number;
+export interface MonthGrid {
+    /** First of the month. */
+    month: Date;
+    /** Whole weeks, Monday first: `rows * 7` days. */
+    days: Date[];
+    rows: number;
+}
+export declare function monthGrid(monthDate: Date): MonthGrid;
+export declare function weekDays(start: Date): Date[];
+/** The days a view shows (the month view's whole weeks, the week, or the agenda's 21 days). */
+export declare function visibleDays(view: CalendarViewKind, offset: number, today: Date): Date[];
+export interface DayBuckets<T> {
+    byDay: Map<string, T[]>;
+    none: T[];
+}
+/**
+ * Items by day key. With `getEnd`, an item is drawn on each day from its date to its end (at most MAX_SPAN_DAYS);
+ * an end before the start counts as one day. Order inside a day keeps the input order.
+ */
+export declare function bucketByDay<T>(items: readonly T[], getDate: (item: T) => DateInput, getEnd?: (item: T) => DateInput): DayBuckets<T>;
+/** The chips a month cell shows: all up to three; with more, two (unless expanded). */
+export declare function shownChips<T>(items: readonly T[], expanded: boolean, limit?: number): {
+    shown: T[];
+    more: number;
+};
+/** Days of the agenda that print: those with items, and today always. */
+export declare function agendaDays<T>(days: readonly Date[], byDay: Map<string, T[]>, today: Date): Date[];
+export interface NavEntry {
+    id: string;
+    /** Day key, or null for the tray. */
+    day: string | null;
+}
+/**
+ * Chips in the order they appear (what J and K walk): day by day over the shown days, then the tray. An item
+ * drawn on several days counts once, at its first day. Month cells hide what sits behind "+N more".
+ */
+export declare function navOrder<T>(options: {
+    view: CalendarViewKind;
+    days: readonly Date[];
+    byDay: Map<string, T[]>;
+    none?: readonly T[];
+    getId: (item: T) => string;
+    expandedDay?: string | null;
+    today: Date;
+}): NavEntry[];
+/** ArrowRight and ArrowLeft: the first chip of the next (or previous) day that has chips. No cursor starts at the ends. */
+export declare function stepDay(order: readonly NavEntry[], cursor: string | null | undefined, delta: 1 | -1): string | null;
+/**
+ * Where T puts the cursor once the view is back on today: the first chip of today, else the first chip after today,
+ * else the last chip before it, else nothing.
+ */
+export declare function todayCursor(order: readonly NavEntry[], today: Date): string | null;
+/** Keeps the cursor when it is still shown; else the first chip (or nothing). */
+export declare function settleCursor(order: readonly NavEntry[], cursor: string | null | undefined): string | null;

package/dist/space-sdk/src/ui/charts/Chart.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Charts (toolkit spec 2.11).
+ *
+ * The recharts wrapper the Portal used (`portal/src/components/ui/chart.tsx`: ChartContainer, ChartTooltip,
+ * ChartTooltipContent, ChartLegend, ChartStyle), moved here and styled by `nui-chart-*` rules in toolkit.css instead
+ * of Tailwind. The recharts primitives are re-exported so a host and a Space draw with the toolkit's one recharts
+ * instance (two copies do not share their chart context).
+ *
+ * `Chart` is the ready piece: one period series as a line, bars or an area, the comparison as a dashed line, a
+ * legend, tooltips in the toolkit locale, and its numbers in a hidden table for Markdown (RenderChartData). Bars and
+ * areas can stack, and bars can run horizontally with their value after each bar.
+ */
+import * as React from 'react';
+import { ResponsiveContainer, Tooltip, type BarShapeProps, type LabelProps, type TooltipContentProps } from 'recharts';
+import { type Locale, type Words } from '../../words/types';
+import type { CompareId } from '../period/periods';
+export { Area, AreaChart, Bar, BarChart, CartesianGrid, Cell, ComposedChart, LabelList, Legend, Line, LineChart, Pie, PieChart, ReferenceDot, ReferenceLine, ResponsiveContainer, Scatter, Tooltip, XAxis, YAxis, } from 'recharts';
+declare const THEMES: {
+    readonly light: '';
+    readonly dark: '.dark';
+};
+export type ChartConfig = {
+    [k in string]: {
+        label?: React.ReactNode;
+        icon?: React.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+interface ChartContextValue {
+    config: ChartConfig;
+}
+export declare function useChart(): ChartContextValue;
+export type ChartContainerProps = React.ComponentProps<'div'> & {
+    config: ChartConfig;
+    children: React.ComponentProps<typeof ResponsiveContainer>['children'];
+    /**
+     * Width over height of the box. Default 16 / 9; `'auto'` drops the ratio, so the box takes the height its parent,
+     * `height` or `style` gives it.
+     */
+    aspect?: number | 'auto';
+    /** A fixed height (px, or any CSS length). It drops the default ratio unless `aspect` is also given. */
+    height?: number | string;
+};
+/** Sizes a recharts chart to its box and defines `--color-<key>` for each configured series. */
+export declare const ChartContainer: React.ForwardRefExoticComponent<Omit<ChartContainerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare function ChartStyle({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}): React.JSX.Element | null;
+/**
+ * recharts' own Tooltip (the same component, not a wrapper): pass `content`, such as a ChartTooltipContent or your
+ * own box. recharts drops series without a value at the point; `filterNull={false}` keeps them, and
+ * ChartTooltipContent shows them as "No data".
+ */
+export declare const ChartTooltip: typeof Tooltip;
+type TooltipItem = NonNullable<TooltipContentProps['payload']>[number];
+export type ChartTooltipContentProps = Partial<TooltipContentProps> & {
+    className?: string;
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: 'line' | 'dot' | 'dashed';
+    nameKey?: string;
+    labelKey?: string;
+    labelClassName?: string;
+    color?: string;
+    /** Formats each value. Default: a number in the locale ("1,240" / "1 240"), a string as written. */
+    valueFormatter?: (value: number | string, item: TooltipItem) => React.ReactNode;
+    /** Language of the default number format and of "No data". Default the toolkit locale. */
+    locale?: Locale;
+};
+/**
+ * The tooltip box: a label line, then one row per series with its indicator, name and value. A series without a
+ * value at the point shows "No data" (it reaches the box when the Tooltip has `filterNull={false}`). Works inside a
+ * ChartContainer (names and colours from its config) or alone.
+ */
+export declare const ChartTooltipContent: React.ForwardRefExoticComponent<Partial<TooltipContentProps> & {
+    className?: string;
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: 'line' | 'dot' | 'dashed';
+    nameKey?: string;
+    labelKey?: string;
+    labelClassName?: string;
+    color?: string;
+    /** Formats each value. Default: a number in the locale ("1,240" / "1 240"), a string as written. */
+    valueFormatter?: (value: number | string, item: TooltipItem) => React.ReactNode;
+    /** Language of the default number format and of "No data". Default the toolkit locale. */
+    locale?: Locale;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * One legend entry: an item of recharts' legend payload, or your own for a legend drawn outside a chart (a hand-made
+ * chart, a Scatter, a key shared by several charts).
+ */
+export interface ChartLegendItem {
+    /** The series key: its label and colour come from the config. */
+    dataKey?: unknown;
+    /** The label when the config has none for the key (recharts puts the series name here). */
+    value?: React.ReactNode;
+    /** Any CSS colour. Default the config colour, else `var(--color-<key>)` (defined inside a ChartContainer only). */
+    color?: string;
+    /** How the key is drawn. Default a square, or a dashed line for a dashed series. */
+    shape?: 'square' | 'circle' | 'line' | 'dashed';
+    /** A dashed series, such as a comparison: drawn as a dashed line. */
+    dashed?: boolean;
+    /** recharts' legend type: `none` (a series with `legendType="none"`) leaves the entry out. */
+    type?: string;
+    /** recharts' series props: a `strokeDasharray` draws the key dashed. */
+    payload?: unknown;
+}
+export type ChartLegendProps = React.ComponentProps<'div'> & {
+    hideIcon?: boolean;
+    /** The entries: recharts' Legend `payload`, or ChartLegendItem objects of your own. */
+    payload?: readonly unknown[];
+    verticalAlign?: 'top' | 'bottom';
+    nameKey?: string;
+    /** Labels, colours and icons by key. Default the ChartContainer's config; give it for a legend outside one. */
+    config?: ChartConfig;
+};
+/**
+ * The legend: a key (square, circle, line or dashed line) and a label per series. Inside a ChartContainer, as a
+ * recharts `<Legend content>`, or alone with `config` and ChartLegendItem entries.
+ */
+export declare const ChartLegend: React.ForwardRefExoticComponent<Omit<ChartLegendProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * A bar shape that keeps zero-size bars, so their labels still draw (recharts drops a zero bar, and its label, unless
+ * the Bar has a shape of its own). Draws the bar as recharts does. `<Bar shape={barShape} label={...} />`.
+ */
+export declare function barShape(props: BarShapeProps): React.ReactElement;
+/**
+ * A bar's value label, zero bars included: after the end of a horizontal bar, or above a vertical one with
+ * `position: 'top'`. Pair it with `shape={barShape}` (zero bars keep their place) and give `formatter` for the
+ * number text. Made for values of 0 and up.
+ * `<Bar shape={barShape} label={{ content: barLabel, position: 'right', formatter: (v) => format(v) }} />`
+ */
+export declare function barLabel(props: LabelProps): React.ReactElement | null;
+export type ChartKind = 'line' | 'bar' | 'area';
+export interface ChartSeries {
+    /** Field of each row holding the value. */
+    key: string;
+    label: Words | string;
+    /** Any CSS colour. Default the chart tokens in order (`--chart-1`, `--chart-2`...). */
+    color?: string;
+}
+export interface ChartProps {
+    kind: ChartKind;
+    /** One row per point, such as `periodSeries()` rows. */
+    data: readonly object[];
+    /** The series drawn. Default `{ key: 'value', label: 'This period' }`. */
+    series?: ChartSeries | readonly ChartSeries[];
+    /**
+     * The comparison, drawn as a dashed line. A CompareId reads the `compare` field and names it ("Previous period");
+     * a series names its own field. Omitted or `none`: no comparison.
+     */
+    compare?: CompareId | ChartSeries | false | null;
+    /** Unique field per row for the x axis. Default `key` when rows have it, else `label`. */
+    xKey?: string;
+    /** Field with the short axis label. Default `label`. */
+    labelKey?: string;
+    /** Field with the full point name in tooltips and the data table. Default `range`, else the axis label. */
+    nameKey?: string;
+    /** Accessible name of the chart and title of its data table. */
+    title?: Words | string;
+    /**
+     * Height in px. Default 140 for bars and 200 for a line or an area (deck PG3), or one row per point for horizontal
+     * bars (32px, or 14px a series plus 12 when several series sit side by side). A chart that switches kind passes one
+     * height, so the switch never moves the page.
+     */
+    height?: number;
+    /** Bars or areas stack, and the value axis fits each point's total. Lines ignore it. */
+    stacked?: boolean;
+    /**
+     * Bars run left to right, one row per point: its label before the bar on at most two lines, its value after (the
+     * total when stacked). Only for `kind="bar"`; draws no comparison.
+     */
+    horizontal?: boolean;
+    /** Value text in tooltips and the data table. Default whole numbers (one decimal under 10). */
+    format?: (value: number, locale: Locale) => string;
+    /** The short value after each horizontal bar (or stack), such as "1.2k" beside an exact tooltip. Default `format`. */
+    labelFormat?: (value: number, locale: Locale) => string;
+    /**
+     * The last point is still filling (the range ends today): its bar is drawn full colour, the others lighter until
+     * hovered (deck period-r6). Default: true when the last row's `to` is today.
+     */
+    live?: boolean;
+    locale?: Locale;
+    className?: string;
+}
+/** The colour series `i` is drawn with. */
+export declare function seriesColor(series: ChartSeries, index: number): string;
+/** The hidden table of a chart: one row per point, the point name then each series value. */
+export declare function chartTableRows(data: readonly object[], series: readonly ChartSeries[], compare: ChartSeries | null, nameOf: (row: object) => string, format: (value: number) => string): Array<Array<string | null>>;
+/** A period chart (bars, a line or an area) with an optional dashed comparison; 140px bars or a 200px plot by default. */
+export declare function Chart({ kind, data, series: seriesProp, compare: compareProp, xKey: xKeyProp, labelKey, nameKey: nameKeyProp, title, height: heightProp, stacked, horizontal: horizontalProp, format: formatProp, labelFormat: labelFormatProp, live: liveProp, locale: localeProp, className, }: ChartProps): React.JSX.Element;
+export declare namespace Chart {
+    var displayName: string;
+}
+/** "1,240 on Jan 5" / "1 240 le 5 janv.", for a Space's own tooltips and summaries. */
+export declare function chartPointText(value: string, name: string, locale: Locale, previous?: string | null): string;

package/dist/space-sdk/src/ui/charts/ChartTable.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ChartTable (toolkit spec 2.11, deck chart page alt b): the metrics of a chart page as a table under the chart.
+ * Columns: Metric, Trend (a sparkline, 140), Value (112), then Previous (112) and Change (96) with a comparison. Trend
+ * and Previous hide when the table is 760px or narrower. The deck table rules: 40px rows, a sticky 36px header, the
+ * Metric cell 24px in and the last cell 24px from the right edge. A real table, so view Markdown reads it as one.
+ */
+import * as React from 'react';
+import { type Locale, type Words } from '../../words/types';
+import type { CompareId } from '../period/periods';
+import { type StatMetric } from './StatRow';
+export interface SparklineProps {
+    /** One value per point. A null (or NaN) is a gap: the line breaks there instead of dropping to zero. */
+    values: readonly (number | null)[];
+    width?: number;
+    height?: number;
+    className?: string;
+}
+/** A small area plus line (72 by 24 by default), drawn in `--chart-1`. Decorative: hidden from assistive tech. */
+export declare function Sparkline({ values, width, height, className }: SparklineProps): React.JSX.Element;
+export interface ChartTableProps {
+    metrics: readonly StatMetric[];
+    /** Default `prev`; `none` drops the Previous and Change columns. */
+    compare?: CompareId;
+    /** Accessible name. Default "Key figures". */
+    title?: Words | string;
+    /** The highlighted metric (the one the chart above draws). */
+    activeId?: string;
+    /** Makes rows pressable: picks the metric the chart draws. */
+    onSelect?: (metric: StatMetric) => void;
+    locale?: Locale;
+    className?: string;
+}
+/** The metrics of a chart page as a table: 40px rows, a sticky header, Trend and Previous hidden at 760px or less. */
+export declare function ChartTable({ metrics, compare, title, activeId, onSelect, locale: localeProp, className }: ChartTableProps): React.JSX.Element;
+export declare namespace ChartTable {
+    var displayName: string;
+}

package/dist/space-sdk/src/ui/charts/RenderChartData.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import type { ReactNode } from 'react';
+export interface RenderChartDataProps {
+    title: string;
+    columns: readonly string[];
+    rows: readonly (readonly (string | number | boolean | null)[])[];
+    /** The visible chart. `Chart` and `ChartTable` already render their own data table. */
+    children?: ReactNode;
+}
+/**
+ * A chart's data, available to view Markdown without adding a second visible table (toolkit spec 2.11; moved from
+ * `src/components/RenderChartData.tsx`). Keep labels and values identical to the chart. The renderer recognizes this
+ * semantic table inside Shadow DOM; snapshots never infer numbers from SVG geometry. `Chart` renders its numbers
+ * through it.
+ */
+export declare function RenderChartData({ title, columns, rows, children }: RenderChartDataProps): React.JSX.Element;

package/dist/space-sdk/src/ui/charts/StatRow.d.ts

@@ -0,0 +1,59 @@
+/**
+ * StatRow (toolkit spec 2.11, deck chart page alt b, PG2): the key figures above a chart, as a full-width strip of
+ * four equal cells (two when the strip is 640px or narrower). Each cell, 24px in and 16px tall padding, shows its
+ * label, the value with its change, and the previous value with what it is compared to. No card, gap or rule between
+ * cells; a strip right after a bar Section takes a hairline above and below (the toolkit's blocks rules).
+ */
+import * as React from 'react';
+import { type Locale, type Words } from '../../words/types';
+import { type Delta } from '../period/dateFormat';
+import type { CompareId } from '../period/periods';
+/** One figure of a StatRow or a ChartTable row. */
+export interface StatMetric {
+    /** Stable key. Default the label. */
+    id?: string;
+    label: Words | string;
+    /** This period. A string is shown as written (no change computed). */
+    value: number | string;
+    /** The comparison period's value. */
+    previous?: number | null;
+    /** Default whole numbers (one decimal under 10) in the locale. */
+    format?: (value: number, locale: Locale) => string;
+    /** False when a rise is bad (costs, errors): the change turns red. Default true. */
+    higherIsBetter?: boolean;
+    /** Replaces the second line ("1,020 previous period"). */
+    hint?: Words | string;
+    /** Values over the period, for the ChartTable trend column. A null is a gap in the sparkline. */
+    spark?: readonly (number | null)[];
+    /**
+     * Beside the label, in StatRow and ChartTable: what the figure means, usually an info button that opens a popover
+     * or a tooltip (the Space's own). In a pressable ChartTable row a press on it does not pick the row.
+     */
+    about?: React.ReactNode;
+}
+export interface StatRowProps {
+    metrics: readonly StatMetric[];
+    /** What `previous` is: names it on the second line. Default `prev`; `none` hides previous values and changes. */
+    compare?: CompareId;
+    locale?: Locale;
+    className?: string;
+}
+export interface MetricView {
+    key: string;
+    label: string;
+    value: string;
+    previous: string | null;
+    delta: Delta | null;
+    sub: string | null;
+}
+/** "vs previous period" without its "vs ": "previous period" / "période précédente". */
+export declare function vsTail(compare: CompareId, locale: Locale): string;
+/** The texts of one metric cell, computed once for StatRow and ChartTable. Pure. */
+export declare function metricView(metric: StatMetric, compare: CompareId, locale: Locale): MetricView;
+/** True when a slot holds something to draw. */
+export declare function hasSlot(node: React.ReactNode): boolean;
+/** The key figures strip: four equal cells per line (two at 640px or narrower), full width, no frame. */
+export declare function StatRow({ metrics, compare, locale: localeProp, className }: StatRowProps): React.JSX.Element;
+export declare namespace StatRow {
+    var displayName: string;
+}

package/dist/space-sdk/src/ui/charts/chartData.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Chart data mapping (toolkit spec 2.11). Pure: date-fns only.
+ *
+ * Dated points go into bins sized for the period, the way the deck draws it: hours for one day, days up to a month,
+ * weeks up to six months, then months. The comparison period is binned the same way and lined up bin by bin.
+ */
+import type { Locale } from '../../words/types';
+import { type DateRange } from '../period/periods';
+export type BinUnit = 'hour' | 'day' | 'week' | 'month';
+export interface Bin {
+    from: Date;
+    to: Date;
+}
+export interface DatedPoint {
+    date: Date | string | number;
+    value: number;
+}
+/** One row of a period chart: the bin, its value and, with a comparison, the value of the same bin before. */
+export interface PeriodChartRow {
+    /** ISO start of the bin, a stable key. */
+    key: string;
+    /** Short axis label ("Jan 5", "14", "Mar"). */
+    label: string;
+    /** Full bin name for tooltips ("Jan 5 to 11, 2026"). */
+    range: string;
+    from: Date;
+    to: Date;
+    value: number;
+    compare: number | null;
+}
+export declare function binUnit(range: DateRange): BinUnit;
+/** The bins of a range. Weeks step seven days from the first day; the last week and month stop at the range end. */
+export declare function buildBins(range: DateRange, unit?: BinUnit): Bin[];
+/** Adds up (or averages, for levels such as active users) the points that fall in each bin. Empty bins are 0. */
+export declare function aggregate(points: readonly DatedPoint[], bins: readonly Bin[], mode?: 'sum' | 'avg'): number[];
+export declare function binLabel(bin: Bin, unit: BinUnit, locale: Locale): string;
+export declare function binRangeLabel(bin: Bin, unit: BinUnit, locale: Locale): string;
+export interface PeriodSeriesInput {
+    points: readonly DatedPoint[];
+    range: DateRange;
+    /** The comparison range; its points come from `comparePoints`, or from `points` when they cover it. */
+    compareRange?: DateRange | null;
+    comparePoints?: readonly DatedPoint[];
+    mode?: 'sum' | 'avg';
+    unit?: BinUnit;
+    locale: Locale;
+}
+/** Rows for `<Chart>`: one per bin of the period, with the comparison lined up bin by bin (cut to the same count). */
+export declare function periodSeries(input: PeriodSeriesInput): PeriodChartRow[];
+/** Sum or average of a period, for a stat next to the chart. */
+export declare function total(points: readonly DatedPoint[], range: DateRange, mode?: 'sum' | 'avg'): number;
+/** Half the widest short axis label ("15 sept.", "12 PM"), in px. */
+export declare const AXIS_LABEL_HALF = 24;
+/**
+ * Room between two labelled points of a line or area chart, in px (80): an edge label anchored inward (see
+ * `edgeAnchor`), a whole label wide, and the centred label next to it, half a label, keep 8px apart.
+ */
+export declare const AXIS_LABEL_ROOM: number;
+/**
+ * Axis labels: about seven, counted back from the last bin so the newest one always shows. With `spacing`, the px
+ * between neighbouring points, a narrow chart labels fewer points so no two labels meet.
+ */
+export declare function axisLabelStep(count: number, spacing?: number): number;
+export declare function showAxisLabel(index: number, count: number, spacing?: number): boolean;
+/**
+ * How an axis label sits on its point `x` in a line or area chart, whose first and last points lie on the plot edges
+ * (`left`, `right`): a label closer to an edge than half a label starts (left) or ends (right) at its point, so it
+ * never runs out of the chart. Every other label is centred.
+ */
+export declare function edgeAnchor(x: number, left: number, right: number): 'start' | 'middle' | 'end';
+/** Top of the value axis: 10% above the highest value (this period or the comparison), never below 1. */
+export declare function chartMax(values: ReadonlyArray<number | null | undefined>): number;
+/** True when the period ends today, so its last bin is still filling (drawn full colour). */
+export declare function endsToday(range: DateRange, now?: Date): boolean;
+/**
+ * Paths of a sparkline (deck: an area plus a line, 72 by 24): `line` strokes the values left to right, `area` closes
+ * it down to the baseline. Values scale to the highest one (×1.1, like the chart); one value draws a flat line.
+ * A missing value (null, undefined, NaN) is a gap: each point keeps its place, the line and the area break at the
+ * gap, and a point alone between gaps is a dot (a zero-length segment the round line cap draws).
+ */
+export declare function sparkPaths(values: readonly (number | null | undefined)[], width?: number, height?: number): {
+    line: string;
+    area: string;
+};