@k2b/ui 0.49.0 → 0.51.0

package/dist/types/content/ChartRoot.d.ts

@@ -0,0 +1,92 @@
+import type { JSX } from "solid-js";
+import type { ChartDrawingOptions } from "../charts/core/render";
+import type { ChartCursor } from "./chart-cursor";
+import { type ChartDatumRef, type ChartKind, type ChartSelection, type ChartTooltipFormatter } from "./chart-inspection-core";
+/**
+ * Chart — Solid interaction and sizing around the portable UI chart core.
+ *
+ * **Live-update story.** `charts.<kind>(opts)` returns an SVG string;
+ * Solid's `innerHTML` is reactive, so any time a prop (signal, store
+ * slice, derived value) changes, the SVG re-renders. No manual
+ * subscription, no imperative DOM patching. Trade-off: every change
+ * is a full SVG re-build, not a diff — fine for dashboard cadences
+ * (poll, websocket, store updates). Don't use this for 60fps streaming.
+ *
+ * **Sizing.** The server and browser render the same logical viewBox. CSS
+ * fits Cartesian plots to the container and preserves text/marker sizes;
+ * maps fit the whole world and zoom uniformly across the full plot; pies, donuts and gauges retain
+ * their aspect ratio. No measurement
+ * or hydration redraw is needed. The caller sizes the wrapper, for example
+ * `style={{ height: "14rem" }}`. State timelines derive their default height
+ * from the row count and legend via `stateTimelineHeight()`.
+ *
+ * **Why so thin.** The props are a discriminated union over each
+ * registered core chart renderer — `kind: "line"` brings in exactly the params
+ * `charts.line` expects, `kind: "bar"` brings in `charts.bar`'s, etc.
+ * Options stay aligned with the core renderer without renaming. Every chart provides
+ * renderer-owned inspection, tooltips and optional selection by default.
+ * `interactive` adds bounded pan / zoom and reset controls to maps and state timelines.
+ * When a core renderer gains an option, it is automatically available at every
+ * callsite.
+ *
+ * **Theming.** The core renderers use `currentColor` for axes / ticks /
+ * tick labels — set the wrapping element's `color` and everything
+ * inherits. Series colors come from `--stdlib-chart-c1..c8` CSS
+ * custom properties; override on the parent for per-chart palettes.
+ *
+ * ```tsx
+ * <Chart kind="line" style={{ height: "12rem" }}
+ *        series={[{ data: points() }]}
+ *        yAxis={{ format: v => `€${v}k` }} />
+ *
+ * <Chart kind="donut" style={{ height: "12rem" }} data={slices()} />
+ *
+ * <Chart kind="sparkline" style={{ width: "6rem", height: "1.5rem" }} data={trend()} />
+ *
+ * <Chart kind="map" style={{ height: "16rem" }} series={locations()} interactive />
+ * ```
+ */
+/** All registered chart kinds. */
+export type { ChartKind } from "./chart-inspection-core";
+export type ChartLabels = Partial<{
+    empty: string;
+    series: string;
+    interactiveMap: string;
+    interactiveTimeline: string;
+    interactiveLine: string;
+    interactiveChart: string;
+    zoomIn: string;
+    zoomOut: string;
+    resetMap: string;
+    resetTimeline: string;
+}>;
+/**
+ * Per-kind props: `kind` discriminator + the exact options that
+ * `charts.<kind>` accepts, **minus** `width` / `height` (the wrapper
+ * owns those — CSS fits a stable coordinate space to the box). Solid's
+ * component model handles discriminated unions natively, so callsites
+ * get full type safety.
+ */
+export type ChartProps = {
+    [K in ChartKind]: Extract<ChartDrawingOptions, {
+        kind: K;
+    }> & {
+        class?: string;
+        style?: JSX.CSSProperties | string;
+        labels?: ChartLabels;
+        /**
+         * Navigation for maps and state timelines: pan, zoom and reset controls.
+         * Arrows pan; Alt+arrows inspect. Every chart shows tooltips and keyboard
+         * inspection without this prop.
+         */
+        interactive?: boolean;
+        onSelect?: (selection: ChartSelection) => void;
+        /** Controlled highlight; indices belong to this exact input snapshot. */
+        selected?: ChartDatumRef | null;
+        /** Customize the always-on tooltip with a title and labeled text rows. */
+        tooltip?: ChartTooltipFormatter;
+        /** Optional shared X cursor for line charts. */
+        cursor?: ChartCursor;
+    };
+}[ChartKind];
+export declare const renderChartRoot: (props: ChartProps, renderChartSvg: typeof import("../charts/core/render").renderChartSvg) => JSX.Element;

package/dist/types/content/ChartSnapshotView.d.ts

@@ -5,6 +5,7 @@ import type { ChartSnapshot } from "./chart-snapshot";
 export declare function ChartSnapshotView(props: {
     snapshot: ChartSnapshot;
     cursor?: ChartCursor;
+    legend?: () => ParentNode | undefined;
     selectedKey: string | null;
     onSelect: (key: string) => void;
     style?: JSX.CSSProperties;

package/dist/types/content/ChartSparkline.d.ts

@@ -0,0 +1,5 @@
+import { type ChartProps } from "./ChartRoot";
+/** The same chart host and SVG for stat trends, without the catalog dispatcher. */
+export declare function ChartSparkline(props: Omit<Extract<ChartProps, {
+    kind: "sparkline";
+}>, "kind">): import("solid-js").JSX.Element;

package/dist/types/content/DataTable.d.ts

@@ -1,5 +1,6 @@
 import { type JSX } from "solid-js";
 import type { CollectionSelection } from "./collection-selection";
+import { type DataTableTypedColumn } from "./data-table-columns";
 export type DataTableColumn<T> = {
     id: string;
     header: JSX.Element | ((ctx: {
@@ -29,6 +30,22 @@ export type DataTableColumn<T> = {
      * rate while another sorts by the absolute count behind it.
      */
     sortable?: boolean | string;
+    /** What the column holds; see `DataTableColumnType`. */
+    type?: DataTableTypedColumn["type"];
+    format?: DataTableTypedColumn["format"];
+    /** Labels and tones of a status column, by stored value. */
+    states?: DataTableTypedColumn["states"];
+    /** The value a bar column fills its track at; defaults to its largest value. */
+    max?: number;
+    /** The zone a date column with a time reads in; defaults to the reader's. */
+    timeZone?: string;
+    /** How a delta column reads and rates its change. */
+    delta?: DataTableTypedColumn["delta"];
+    /**
+     * How much a narrow table needs the column: 1 (default) always shows; 3 hides below a table width of 560 px,
+     * 2 below 420 px. Hidden values stay one tap away in the row's details.
+     */
+    priority?: 1 | 2 | 3;
 };
 export type DataTableSort = {
     key: string;
@@ -104,6 +121,17 @@ export type DataTableProps<T> = {
     /** Additional classes for the scrolling region, such as `k2b-detail-trail`. */
     scrollClass?: string;
     scrollPreserveKey?: string | false;
+    /**
+     * The id of the column whose values split the rows into groups, each its own `<tbody>` under a row with the
+     * group's value and count, in the order the groups first appear.
+     */
+    groupBy?: string;
+    /**
+     * The host's search text. With no rows left, the table says that nothing matches it and offers to clear it
+     * through `onClearQuery`, instead of `empty`. Filter the rows with `filterRows`.
+     */
+    query?: string;
+    onClearQuery?: () => void;
 };
 export type DataTablePanelProps = {
     children: JSX.Element;

package/dist/types/content/DataTableTools.d.ts

@@ -0,0 +1,44 @@
+import { type Accessor, type JSX } from "solid-js";
+import type { DataTableColumn, DataTableSort } from "./DataTable";
+export type DataTableViewOptions<T> = {
+    rows: Accessor<readonly T[]>;
+    columns: Accessor<readonly DataTableColumn<T>[]>;
+    sort?: DataTableSort | null;
+    groupBy?: string | null;
+};
+export type DataTableView<T> = {
+    query: Accessor<string>;
+    setQuery: (query: string) => void;
+    sort: Accessor<DataTableSort | null>;
+    setSort: (sort: DataTableSort | null) => void;
+    groupBy: Accessor<string | null>;
+    setGroupBy: (id: string | null) => void;
+    /** The rows that match the query, in the chosen order. */
+    rows: Accessor<T[]>;
+};
+/**
+ * The state of a table a reader searches, sorts and groups in the browser: pass `rows()` and the state to `DataTable`
+ * and the setters to `DataTableTools` and `onSortChange`. Search and order read the shown text of typed columns.
+ */
+export declare function createDataTableView<T>(options: DataTableViewOptions<T>): DataTableView<T>;
+export type DataTableToolsProps = {
+    /** The table's name, for the search field's accessible name ("Search Campaigns"). */
+    label: string;
+    query?: string;
+    onQueryChange?: (query: string) => void;
+    /** Columns the reader may group by; without them no group choice shows. An empty list keeps the choice in place while it loads. */
+    groups?: readonly {
+        id: string;
+        label: string;
+    }[];
+    groupBy?: string | null;
+    onGroupByChange?: (id: string | null) => void;
+    /** While the table has no rows to work on, such as during loading or after a failure. */
+    disabled?: boolean;
+    class?: string;
+};
+/**
+ * Search and group choice for the head of the frame that holds a table, never inside the table. Below a frame width
+ * of 560 px the tools take their own line under the title and the search field fills it.
+ */
+export declare function DataTableTools(props: DataTableToolsProps): JSX.Element;

package/dist/types/content/FlowAmount.d.ts

@@ -0,0 +1,28 @@
+import { type JSX } from "solid-js";
+export type FlowAmountDirection = "in" | "out" | "none";
+export type FlowAmountProps = Omit<JSX.HTMLAttributes<HTMLSpanElement>, "children"> & {
+    /** Signed amount: positive money comes in, negative goes out, zero moves nothing. */
+    value: number;
+    /** ISO 4217 currency code, e.g. `"EUR"`. */
+    currency: string;
+    /** Explicit locale override; defaults to the inherited render locale. */
+    locale?: string;
+    /** Fixed fraction digits. Defaults to the currency's standard digits. */
+    decimals?: number;
+    /** The direction words screen readers hear, e.g. `{ in: "Einnahme", out: "Ausgabe" }`. */
+    labels?: {
+        in?: string;
+        out?: string;
+    };
+    /** `"lg"` is the key figure size. */
+    size?: "md" | "lg";
+};
+/** The direction a signed amount moves money; `-0` and non-finite amounts move nothing (non-finite shows "—"). */
+export declare const flowDirection: (value: number) => FlowAmountDirection;
+/**
+ * Money with a direction: incoming is turquoise on a ringed surface with an arrow down-left, outgoing is violet with
+ * an arrow up-right, zero is grey with "=". The amount carries no sign; the arrow and, for screen readers, a word say
+ * the direction, so colour is never the only signal.
+ */
+export declare function FlowAmount(props: FlowAmountProps): JSX.Element;
+export default FlowAmount;

package/dist/types/content/PdfViewer.d.ts

@@ -0,0 +1,32 @@
+import { type JSX } from "solid-js";
+import { type PdfPageSize } from "./pdf-document";
+export type PdfViewerProps = {
+    /** The PDF itself. A new value opens that document. */
+    data: Blob | ArrayBuffer;
+    /** The document's name, for the scroll area and the page images. */
+    title: string;
+    /** Without the zoom bar, always fit to the width. Defaults to `true`. */
+    zoom?: boolean;
+    /** Shows only this page (zero-based) instead of all pages one below the other. */
+    page?: number;
+    /** The first visible page is drawn; a host can drop its loading state. */
+    onReady?: () => void;
+    /** The document could not be opened, or a page could not be drawn and has no image yet. */
+    onError?: (error: unknown) => void;
+    class?: string;
+};
+/** Steps for − and + in percent; Ctrl or ⌘ with the wheel and two fingers zoom freely between the first and the last. */
+export declare const PDF_ZOOM_STEPS: readonly [25, 50, 75, 100, 125, 150, 200, 300];
+/** The next zoom step above or below `percent`; at either end it stays there. */
+export declare const nextPdfZoomStep: (percent: number, direction: 1 | -1) => number;
+/**
+ * The page width most pages share, at a tie the first page's. "Width" fits every page to the area, so a landscape page
+ * among portrait ones never scrolls sideways; percentages and fixed zoom follow this common width.
+ */
+export declare const commonPageWidth: (pages: readonly PdfPageSize[]) => number;
+/**
+ * A PDF drawn by pdf.js in every browser: pages as images in one scroll area, an invisible text layer over each page
+ * to select, copy, and find text, and a small zoom bar. Only pages near the view are drawn and carry text; the others
+ * keep their size, so the scroll bar is right from the start. Printing and forms stay with the browser's own viewer.
+ */
+export default function PdfViewer(props: PdfViewerProps): JSX.Element;

package/dist/types/content/balance-summary-messages.d.ts

@@ -0,0 +1,11 @@
+declare const balanceSummaryMessages: import("@k2b/stdlib").Catalog<{
+    start: string;
+    end: string;
+    in: string;
+    out: string;
+}>;
+export type BalanceSummaryMessages = ReturnType<(typeof balanceSummaryMessages)["resolve"]>["t"];
+/** Resolved from an explicit locale override, else the inherited render locale. */
+export declare const useBalanceSummaryMessages: (override?: () => string | undefined) => (() => BalanceSummaryMessages);
+export declare const checkBalanceSummaryMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/content/chart-bar.d.ts

@@ -1,10 +1,23 @@
-import { type AxisOptions, type BarItem, type ReferenceLine } from "@k2b/stdlib";
+import { type AxisOptions, type BarItem, type ReferenceLine } from "../charts/core/svg-renderers";
 /**
  * Bar chart options: stdlib's `charts.bar` options plus a title for the category axis and a separate value format.
  * The wrapper owns size and inspection.
  */
 export type BarChartOptions = {
-    data: BarItem[];
+    data?: BarItem[];
+    /** Aligned categories and series. Null observations are gaps. */
+    x?: string[];
+    series?: {
+        label: string;
+        data: (number | null)[];
+    }[];
+    layout?: "columns" | "rows" | "grouped" | "stacked";
+    normalize?: boolean;
+    locale?: string;
+    compare?: {
+        label: string;
+        data: (number | null)[];
+    };
     /** Value axis. `label` titles it, `format` writes its ticks and, without `valueFormat`, the printed values. */
     yAxis?: AxisOptions;
     /**
@@ -43,11 +56,23 @@ export type BarChartOptions = {
 export type BarChartLayout = "columns" | "rows";
 /** Estimated width of `text` at `size` pixels in the UI sans font with tabular figures; a little wide on purpose. */
 export declare const chartTextWidth: (text: string, size?: number) => number;
+/** Split a label into at most `lines` lines of `maxPx`; the last line ends with an ellipsis when the label is longer. */
+export declare const wrapLabel: (label: string, maxPx: number, lines: number) => {
+    lines: string[];
+    truncated: boolean;
+};
+type Scale = {
+    domain: [number, number];
+    ticks: number[];
+    log: boolean;
+};
+export declare const headerHeight: (opts: BarChartOptions) => number;
 /** The layout a bar chart takes and its logical height, so server and browser reserve the same box. */
 export declare const barChartLayout: (opts: BarChartOptions, width?: number) => {
     layout: BarChartLayout;
     height: number;
 };
+export declare const renderHeader: (opts: BarChartOptions, width: number) => string;
 /**
  * Render a bar chart in which every category has its label. Few short labels stand below vertical columns; otherwise
  * each category becomes a horizontal row with its label left of the bar and its value at the bar's end. Rows grow the
@@ -58,3 +83,71 @@ export declare const renderBarChartSvg: (opts: BarChartOptions & {
     height: number;
     inspect?: boolean;
 }) => string;
+/** Stable wrapping legend slots reserve the widest total or category value before interaction. */
+export declare function barSeriesLegend(entries: {
+    label: string;
+    data: (number | null)[];
+}[], format: (v: number) => string, width?: number, displayWidth?: number, maxHeight?: number): {
+    items: {
+        label: string;
+        data: (number | null)[];
+        total: number | null;
+        x: number;
+        y: number;
+        labelWidth: number;
+        valueX: number;
+    }[];
+    hidden: number;
+    height: number;
+};
+/** Category geometry shared by SVG, server snapshots and browser inspection. */
+export declare function seriesBarLayout(opts: BarChartOptions, size?: {
+    width: number;
+    height: number;
+}): {
+    width: number;
+    height: number;
+    columns: {
+        label: string;
+        index: number;
+        center: number;
+        current: {
+            seriesIndex: number;
+            raw: number | null | undefined;
+            value: number | null;
+            base: number;
+        }[];
+        total: number;
+        previous: number | null | undefined;
+    }[];
+    totals: (number | null)[];
+    scale: Scale;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    slot: number;
+    y: (value: number) => number;
+    format: (value: number) => string;
+    units: number;
+    entries: {
+        label: string;
+        data: (number | null)[];
+    }[];
+    legend: boolean;
+    legendLayout: {
+        items: {
+            label: string;
+            data: (number | null)[];
+            total: number | null;
+            x: number;
+            y: number;
+            labelWidth: number;
+            valueX: number;
+        }[];
+        hidden: number;
+        height: number;
+    };
+    barWidthPx: number;
+};
+export {};

package/dist/types/content/chart-calendar.d.ts

@@ -0,0 +1,4 @@
+import type { ChartInspectionNavigation } from "./chart-inspection-core";
+export declare const calendarInspectionNavigation: ChartInspectionNavigation;
+/** A calendar starts at the newest week. Pointer inspection never resets its scroll position. */
+export declare function mountCalendarScroll(container: HTMLElement): () => void;

package/dist/types/content/chart-inspection-core.d.ts

@@ -1,21 +1,15 @@
-import type { ChartDatum, charts } from "@k2b/stdlib";
+import type { ChartKind } from "../charts/core/types";
 import type { ChartCursor } from "./chart-cursor";
-export type ChartKind = keyof typeof charts;
-export type ChartDatumRef = Pick<ChartDatum, "role" | "index" | "seriesIndex">;
-export declare const sameChartDatum: (a: ChartDatumRef, b: ChartDatumRef) => boolean;
-export type ChartSelection = {
-    kind: ChartKind;
-    datum: ChartDatum;
-};
-export type ChartTooltip = {
-    title?: string;
-    rows: readonly {
-        label: string;
-        value: string;
-    }[];
+export { type ChartDatumRef, type ChartSelection, type ChartTooltip, type ChartTooltipFormatter, isChartDatum, sameChartDatum, } from "../charts/core/inspection";
+export type { ChartKind } from "../charts/core/types";
+import { type ChartDatumRef, type ChartSelection, type ChartTooltipFormatter } from "../charts/core/inspection";
+/** Host policy for inspecting an overflowing drawing. */
+export type ChartInspectionNavigation = {
+    last?: boolean;
+    pointer?: boolean;
+    reveal?: (element: SVGGraphicsElement) => void;
+    keepScroll?: boolean;
 };
-export type ChartTooltipFormatter = (selection: ChartSelection) => ChartTooltip;
-export declare function isChartDatum(value: unknown): value is ChartDatum;
 /** Enhances existing SVG nodes. Pointer/focus changes never rebuild the chart. */
 export declare function createChartInspector(options: {
     container: () => HTMLElement | undefined;
@@ -24,8 +18,13 @@ export declare function createChartInspector(options: {
     anchor: () => HTMLSpanElement | undefined;
     kind: () => ChartKind;
     enabled: () => boolean;
+    /** Locale for unformatted values in an attached series legend. */
+    locale?: () => string;
+    /** Legend host when it is outside the inspected SVG container. */
+    legend?: () => ParentNode | undefined;
     format: ChartTooltipFormatter;
     select: (selection: ChartSelection) => void;
+    nav?: () => ChartInspectionNavigation | undefined;
 }): {
     selectDatum: (selected: ChartDatumRef | null | undefined) => void;
     selectData: (selected: readonly ChartDatumRef[]) => void;
@@ -33,6 +32,7 @@ export declare function createChartInspector(options: {
     destroy: () => void;
     move: (event: PointerEvent) => void;
     down: (event: PointerEvent) => void;
+    up: () => void;
     click: (event: MouseEvent) => void;
     focus: (event: FocusEvent) => void;
     key: (event: KeyboardEvent) => boolean;
@@ -45,12 +45,17 @@ export declare function closeChartInspectionOnOutside(options: {
     container: () => HTMLElement | undefined;
     tooltip: () => HTMLElement | undefined;
     close: () => void;
+    keepScroll?: () => boolean | undefined;
 }): () => void;
 export type InspectChartOptions = {
     kind: ChartKind;
+    nav?: ChartInspectionNavigation;
     format: ChartTooltipFormatter;
     select?: (selection: ChartSelection) => void;
     cursor?: ChartCursor;
+    locale?: string;
+    /** Host for a separately rendered series legend. Defaults to the chart container. */
+    legend?: ParentNode;
 };
 export type ChartInspection = {
     invalidate(): void;

package/dist/types/content/chart-inspection.d.ts

@@ -1,5 +1,5 @@
 import type { ChartCursor } from "./chart-cursor";
-import { type ChartKind, type ChartSelection, type ChartTooltipFormatter } from "./chart-inspection-core";
+import { type ChartInspectionNavigation, type ChartKind, type ChartSelection, type ChartTooltipFormatter } from "./chart-inspection-core";
 export type { ChartSelection } from "./chart-inspection-core";
 export declare function createChartInspection(options: {
     container: () => HTMLDivElement | undefined;
@@ -7,7 +7,10 @@ export declare function createChartInspection(options: {
     tooltip: () => HTMLSpanElement | undefined;
     anchor: () => HTMLSpanElement | undefined;
     kind: () => ChartKind;
+    nav?: () => ChartInspectionNavigation | undefined;
     enabled: () => boolean;
+    locale?: () => string;
+    legend?: () => ParentNode | undefined;
     format: ChartTooltipFormatter;
     select: (selection: ChartSelection) => void;
 }): {
@@ -15,6 +18,7 @@ export declare function createChartInspection(options: {
     selectData: (selected: readonly import("./chart-inspection-core").ChartDatumRef[]) => void;
     move: (event: PointerEvent) => void;
     down: (event: PointerEvent) => void;
+    up: () => void;
     click: (event: MouseEvent) => void;
     focus: (event: FocusEvent) => void;
     key: (event: KeyboardEvent) => boolean;

package/dist/types/content/chart-map-viewport.d.ts

@@ -1,4 +1,4 @@
-import type { MapViewport } from "@k2b/stdlib";
+import type { MapViewport } from "../charts/core/svg";
 export declare const DEFAULT_MAP_VIEWPORT: MapViewport;
 export declare const normalizeMapViewport: (viewport: MapViewport | undefined) => MapViewport;
 export declare const zoomMapViewport: (viewport: MapViewport, delta: number, focus?: Pick<MapViewport, "latitude" | "longitude">) => MapViewport;

package/dist/types/content/chart-message-catalog.d.ts

@@ -0,0 +1,84 @@
+export declare const chartMessages: import("@k2b/stdlib").Catalog<{
+    chartView: string;
+    chartDiagram: string;
+    chartData: string;
+    chartSeries: string;
+    chartOnly: string;
+    chartShowAll: string;
+    chartShowing: string;
+    chartSelectedDatum: string;
+    chartReference: string;
+    chartCurrent: string;
+    chartPinReference: string;
+    chartRemoveComparison: string;
+    chartPreviousData: string;
+    chartCopyData: string;
+    chartCopyFailed: string;
+    chartLegend: string;
+    chartLoading: string;
+    chartLoadingRange: ({ range }: {
+        range: string;
+    }) => string;
+    chartLoadFailed: string;
+    chartLoadFailedKept: string;
+    chartAsOf: ({ time }: {
+        time: string;
+    }) => string;
+    chartRefreshFailed: string;
+    chartRowsShown: ({ shown, total }: {
+        shown: string;
+        total: string;
+    }) => string;
+    interactiveLineChart: string;
+    interactiveChart: string;
+    chartFields: ({ key }: {
+        key: string;
+    }) => string;
+    interactiveMap: string;
+    interactiveTimeline: string;
+    series: string;
+    resetMapView: string;
+    resetTimelineView: string;
+}>;
+export declare const resolveChartMessages: (locale: string) => {
+    chartView: string;
+    chartDiagram: string;
+    chartData: string;
+    chartSeries: string;
+    chartOnly: string;
+    chartShowAll: string;
+    chartShowing: string;
+    chartSelectedDatum: string;
+    chartReference: string;
+    chartCurrent: string;
+    chartPinReference: string;
+    chartRemoveComparison: string;
+    chartPreviousData: string;
+    chartCopyData: string;
+    chartCopyFailed: string;
+    chartLegend: string;
+    chartLoading: string;
+    chartLoadingRange: ({ range }: {
+        range: string;
+    }) => string;
+    chartLoadFailed: string;
+    chartLoadFailedKept: string;
+    chartAsOf: ({ time }: {
+        time: string;
+    }) => string;
+    chartRefreshFailed: string;
+    chartRowsShown: ({ shown, total }: {
+        shown: string;
+        total: string;
+    }) => string;
+    interactiveLineChart: string;
+    interactiveChart: string;
+    chartFields: ({ key }: {
+        key: string;
+    }) => string;
+    interactiveMap: string;
+    interactiveTimeline: string;
+    series: string;
+    resetMapView: string;
+    resetTimelineView: string;
+};

package/dist/types/content/chart-messages.d.ts

@@ -1,37 +1,6 @@
-declare const chartMessages: import("@k2b/stdlib").Catalog<{
-    chartView: string;
-    chartDiagram: string;
-    chartData: string;
-    chartSeries: string;
-    chartOnly: string;
-    chartShowAll: string;
-    chartShowing: string;
-    chartSelectedDatum: string;
-    chartReference: string;
-    chartCurrent: string;
-    chartPinReference: string;
-    chartRemoveComparison: string;
-    chartPreviousData: string;
-    chartCopyData: string;
-    chartCopyFailed: string;
-    chartLegend: string;
-    chartRowsShown: ({ shown, total }: {
-        shown: string;
-        total: string;
-    }) => string;
-    interactiveLineChart: string;
-    interactiveChart: string;
-    chartFields: ({ key }: {
-        key: string;
-    }) => string;
-    interactiveMap: string;
-    interactiveTimeline: string;
-    series: string;
-    resetMapView: string;
-    resetTimelineView: string;
-}>;
+import { chartMessages } from "./chart-message-catalog";
+export { chartMessages, resolveChartMessages } from "./chart-message-catalog";
 export type ChartMessages = ReturnType<(typeof chartMessages)["resolve"]>["t"];
 /** Resolved from the inherited render locale. */
 export declare const useChartMessages: () => (() => ChartMessages);
 export declare const checkChartMessages: () => import("@k2b/stdlib").CatalogIssue[];
-export {};

package/dist/types/content/chart-snapshot.d.ts

@@ -1,26 +1 @@
-import { type ChartDatum } from "@k2b/stdlib";
-import { type ChartKind, type ChartRenderOptions } from "./Chart";
-import { type ChartSelection, type ChartTooltip, type ChartTooltipFormatter } from "./chart-inspection-core";
-/** Trusted output of prepareChartSnapshot; never accept arbitrary user SVG. */
-export type ChartSnapshot = {
-    kind: ChartKind;
-    svg: string;
-    width: number;
-    height: number;
-    stretch: boolean;
-    marks: readonly {
-        key: string;
-        rowKey: string;
-        datum: ChartDatum;
-        tooltip: ChartTooltip;
-        reference?: boolean;
-    }[];
-};
-/** Pure SVG preparation for server or browser. Transfer only this output across SSR boundaries. */
-export declare function prepareChartSnapshot(options: ChartRenderOptions, inspection: {
-    key: (selection: ChartSelection) => string;
-    /** Defaults to the mark key for one-to-one charts. */
-    rowKey?: (selection: ChartSelection) => string;
-    tooltip: ChartTooltipFormatter;
-    reference?: (selection: ChartSelection) => boolean;
-}): ChartSnapshot;
+export { type ChartSnapshot, prepareChartSnapshot } from "../charts/core/snapshot";

package/dist/types/content/chart-svg.d.ts

@@ -1,4 +1,4 @@
-import type { MapViewport } from "@k2b/stdlib";
+import type { MapViewport } from "../charts/core/svg";
 /** Give maps a CSS-sized viewport while retaining the renderer's projection.
  * The outer SVG uses pixels for headers/legend; the nested geographic viewport
  * keeps one fitted scale across zoom levels and clips only at the plot edges.