@makinbakin/sdk 0.0.1-rc.26 → 0.0.1-rc.28

package/_internal/core/plugin-types.d.ts

@@ -28,6 +28,8 @@ export interface ApprovalActor {
     source: 'channel' | 'web' | 'system';
 }
 export interface StorageAdapter {
+    /** Absolute private root when backed by a local filesystem. Not browser assets. */
+    readonly localRoot?: string;
     read(path: string): string | null;
     write(path: string, content: string): void;
     append(path: string, content: string): void;
@@ -99,6 +101,10 @@ export type { ExecToolResult } from '@makinbakin/sdk/types';
 /** Definition for a registerable execution tool */
 /** Context available to exec tool handlers — provides access to plugin services */
 export interface PluginToolContext {
+    /** Set only by a verified transport, never from tool parameters. */
+    invocation?: {
+        agentId: string;
+    };
     storage: StorageAdapter;
     events: EventBus;
     pluginId: string;
@@ -111,6 +117,8 @@ export interface PluginToolContext {
     getSettings<T = Record<string, unknown>>(): T;
 }
 export interface ExecToolDefinition<Shape extends ZodRawShape = ZodRawShape> {
+    /** Reject unverified HTTP/MCP callers before invoking the handler. */
+    requiresVerifiedAgent?: boolean;
     name: string;
     description: string;
     label?: string;
@@ -580,7 +588,16 @@ export interface ListSettingsField extends BaseSettingsField {
      */
     uniqueField?: string;
 }
-export type SettingsField = StringSettingsField | NumberSettingsField | BooleanSettingsField | SelectSettingsField | ListSettingsField;
+/**
+ * Per-agent on/off grid. Renders every roster agent with its avatar and a
+ * toggle; the persisted value is the array of enabled agent ids. Reusable by
+ * any plugin that gates a feature per agent.
+ */
+export interface AgentTogglesSettingsField extends BaseSettingsField {
+    type: 'agent-toggles';
+    default?: string[];
+}
+export type SettingsField = StringSettingsField | NumberSettingsField | BooleanSettingsField | SelectSettingsField | ListSettingsField | AgentTogglesSettingsField;
 export interface PluginSettingsSchema {
     fields: SettingsField[];
 }
@@ -608,6 +625,8 @@ export interface BakinPlugin {
      * a half-removed state.
      */
     onUninstall?(ctx: PluginContext): void | Promise<void>;
+    /** Preflight before destructive removal. A rejection aborts removal. */
+    beforeUninstall?(ctx: PluginContext): void | Promise<void>;
     /** Declarative settings schema for auto-generated settings UI */
     settingsSchema?: PluginSettingsSchema;
     navItems?: NavItem[];

package/_internal/core/routing/define.d.ts

@@ -37,6 +37,7 @@ export interface DefinePluginInput {
     onShutdown?(): void | Promise<void>;
     onSettingsChange?(settings: Record<string, unknown>): void | Promise<void>;
     onUninstall?(ctx: any): void | Promise<void>;
+    beforeUninstall?(ctx: any): void | Promise<void>;
     settingsSchema?: PluginSettingsSchema;
     navItems?: NavItem[];
     contentFiles?: ContentFile[];

package/_internal/host/ui/action-status.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Legacy host bridge for root `src/components/ui/*` compatibility shims.
+ * Product and plugin consumers should use their existing supported imports;
+ * only the host package and SDK may reach the private implementation.
+ */
+export { Button, buttonVariants } from '../../ui/index';
+export type { ButtonProps, ButtonSize, ButtonVariant, ButtonVariantOptions, LegacyButtonSize, LegacyButtonVariant, } from '../../ui/index';
+export { Progress, ProgressIndicator, ProgressLabel, ProgressTrack, ProgressValue, } from '../../ui/index';
+export type { ProgressIndicatorProps, ProgressProps, ProgressSize, ProgressTone, ProgressTrackProps, } from '../../ui/index';
+export { Alert, AlertAction, AlertDescription, AlertTitle, alertVariants } from '../../ui/index';
+export type { AlertProps, AlertTone, AlertVariantOptions, LegacyAlertVariant, } from '../../ui/index';
+export { Badge, badgeVariants } from '../../ui/index';
+export type { BadgeProps, BadgeSize, BadgeTone, BadgeVariant, BadgeVariantOptions, LegacyBadgeVariant, } from '../../ui/index';

package/_internal/host/ui/modals.d.ts

@@ -0,0 +1,5 @@
+/** Legacy host bridge for the canonical modal and side-overlay primitives. */
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, } from '../../ui/index';
+export { UnsavedChangesDialog } from '../../ui/patterns/unsaved-changes-dialog';
+export type { UnsavedChangesDialogProps } from '../../ui/patterns/unsaved-changes-dialog';
+export type { DialogCloseProps, DialogContentProps, DialogDescriptionProps, DialogFooterProps, DialogHeaderProps, DialogOverlayProps, DialogPortalProps, DialogProps, DialogTitleProps, DialogTriggerProps, SheetCloseProps, SheetContentProps, SheetDescriptionProps, SheetFooterProps, SheetHeaderProps, SheetOverlayProps, SheetPortalProps, SheetProps, SheetSide, SheetTitleProps, SheetTriggerProps, } from '../../ui/index';

package/_internal/ui/behaviors/clipboard.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Clipboard write that works OUTSIDE secure contexts. Bakin is served over
+ * plain HTTP on the tailnet, where `navigator.clipboard` is UNDEFINED — the
+ * old `navigator.clipboard?.writeText(...)` pattern silently no-opped on
+ * every copy button (the 2026-07-25 chat copy bug). Async Clipboard API
+ * when available, legacy execCommand('copy') via an off-screen textarea
+ * otherwise. Returns whether the copy actually happened so UIs only show
+ * the success check for a real copy.
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;

package/_internal/ui/behaviors/selection-navigation.d.ts

@@ -0,0 +1,5 @@
+export type HorizontalSelectionKey = 'ArrowLeft' | 'ArrowRight' | 'Home' | 'End';
+export type VerticalSelectionKey = 'ArrowUp' | 'ArrowDown' | 'Home' | 'End';
+export declare function horizontalSelectionIndex(disabled: readonly boolean[], currentIndex: number, key: HorizontalSelectionKey): number | undefined;
+/** Vertical twin of `horizontalSelectionIndex` — same wrap and disabled-skip rules. */
+export declare function verticalSelectionIndex(disabled: readonly boolean[], currentIndex: number, key: VerticalSelectionKey): number | undefined;

package/_internal/ui/behaviors/use-persisted-leading-edge-resize.d.ts

@@ -0,0 +1,29 @@
+import { type KeyboardEvent, type PointerEvent } from 'react';
+type ResizeAxis = 'x' | 'y';
+interface PersistedResizeOptions {
+    axis: ResizeAxis;
+    defaultSize: number;
+    minSize: number;
+    maxSize: number;
+    storageKey?: string;
+    disabled?: boolean;
+}
+export interface PersistedResizeHandleProps {
+    role: 'separator';
+    tabIndex: number;
+    'aria-orientation': 'horizontal' | 'vertical';
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    onPointerDown: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerMove: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerUp: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerCancel: (event: PointerEvent<HTMLDivElement>) => void;
+    onKeyDown: (event: KeyboardEvent<HTMLDivElement>) => void;
+}
+/** Private shared mechanics for a pane resized from its leading edge. */
+export declare function usePersistedLeadingEdgeResize({ axis, defaultSize, minSize, maxSize, storageKey, disabled, }: PersistedResizeOptions): {
+    size: number;
+    handleProps: PersistedResizeHandleProps;
+};
+export {};

package/_internal/ui/charts/area-chart.d.ts

@@ -0,0 +1,27 @@
+import { type ChartDatum, type ChartSeries } from './chart-data-table';
+export interface AreaChartProps {
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    /** Accessible name for the plot and basis for its exact-data caption. */
+    label: string;
+    description?: string;
+    height?: number;
+    /** Stack non-negative series into cumulative bands instead of overlaying them. */
+    stacked?: boolean;
+    formatValue?: (value: number) => string;
+    emptyLabel?: string;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+}
+/**
+ * Dependency-free cumulative-magnitude trend chart sharing LineChart's exact
+ * data, missing-value, and focus-equivalence contract. A single-series gap
+ * breaks the fill; a stacked column cannot honestly show a mid-stack gap, so
+ * the missing series is omitted from that column's band boundaries and the
+ * omission is surfaced through the exact table's missing labels.
+ */
+export declare function AreaChart({ data, series, label, description, height, stacked, formatValue, emptyLabel, compactData, showDataTable, dataTableExpandable, }: AreaChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/axis.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared axis and series-geometry helpers for the hand-rolled SVG chart kit.
+ * Chart-specific value semantics (stacked coercion, negative handling) stay
+ * local to the chart that owns them.
+ */
+/** Non-negative reported value; negative and non-finite readings are explicit gaps. */
+export declare function reportedValue(value: number | undefined): number | null;
+/** Thin dense x-axes to at most ~6 labels while always keeping the last one. */
+export declare function shouldRenderXLabel(index: number, count: number): boolean;
+/** Ellipsize long axis labels so dense axes stay legible. */
+export declare function axisLabel(label: string): string;
+/** Split a point series on gaps (nulls) into contiguous drawable runs. */
+export declare function contiguousSegments<P>(points: readonly (P | null)[]): P[][];

package/_internal/ui/charts/bar-chart.d.ts

@@ -0,0 +1,21 @@
+import { type ChartDatum, type ChartSeries } from './chart-data-table';
+export interface BarChartProps {
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    /** Accessible name for the plot and basis for its exact-data caption. */
+    label: string;
+    description?: string;
+    height?: number;
+    /** Stack non-negative series within each x-axis bucket instead of grouping them. */
+    stacked?: boolean;
+    formatValue?: (value: number) => string;
+    emptyLabel?: string;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+}
+/** Dependency-free grouped or stacked non-negative comparison chart with exact data. */
+export declare function BarChart({ data, series, label, description, height, stacked, formatValue, emptyLabel, showDataTable, compactData, dataTableExpandable, }: BarChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/chart-data-table.d.ts

@@ -0,0 +1,61 @@
+import type { ReactNode } from 'react';
+export interface ChartDatum {
+    /** Stable x-axis key. */
+    x: string;
+    /** Human-readable x-axis label; defaults to `x`. */
+    xLabel?: string;
+    /** Finite values keyed by `ChartSeries.key`. Omit a key when it is unknown. */
+    values: Record<string, number>;
+    /** Per-series labels for intentionally absent cells. */
+    missingLabels?: Record<string, string>;
+}
+export interface ChartSeries {
+    key: string;
+    label: string;
+    /** CSS color. Defaults to the matching fixed categorical token. */
+    color?: string;
+}
+/** Everything the default exact table renders from, handed to `renderTable`. */
+export interface ChartDataTableRenderContext {
+    caption: string;
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    formatValue: (value: number) => ReactNode;
+    missingValue: ReactNode;
+    emptyLabel: ReactNode;
+}
+export interface ChartDataTableProps {
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    /** Accessible table name and visible disclosure label. */
+    caption: string;
+    formatValue?: (value: number) => ReactNode;
+    /** Rendered when a series has no finite value; defaults to “Not reported”. */
+    missingValue?: ReactNode;
+    /** Rendered across the table body when there are no rows. */
+    emptyLabel?: ReactNode;
+    /** Starts the exact-data disclosure open. */
+    defaultOpen?: boolean;
+    /**
+     * When false, renders the table statically with no disclosure chrome —
+     * always visible, no collapse affordance. `defaultOpen` is ignored.
+     */
+    expandable?: boolean;
+    /** Visually hide the exact table when the owning visual is intentionally compact. */
+    visuallyHidden?: boolean;
+    /**
+     * Escape hatch: replaces the table region's markup when the default
+     * label-plus-series grid cannot express the dataset (derived columns, row
+     * ordering, per-row structure). The disclosure chrome, the `View {caption}`
+     * summary, and the keyboard-reachable overflow region stay kit-owned; the
+     * returned markup MUST render a table (or equivalent structure) named by
+     * `context.caption` and must not turn absent values into zeros.
+     */
+    renderTable?: (context: ChartDataTableRenderContext) => ReactNode;
+    className?: string;
+}
+/** Compatibility name retained for chart implementations migrating in T33b. */
+export declare const CHART_TOKEN_COLORS: readonly ["var(--bakin-color-data-series-1)", "var(--bakin-color-data-series-2)", "var(--bakin-color-data-series-3)", "var(--bakin-color-data-series-4)", "var(--bakin-color-data-series-5)", "var(--bakin-color-data-series-6)", "var(--bakin-color-data-series-7)", "var(--bakin-color-data-series-8)"];
+export declare function chartSeriesColor(series: ChartSeries, index: number): string;
+/** Exact values for visual charts, either disclosed visibly or retained for compact summaries. */
+export declare function ChartDataTable({ data, series, caption, formatValue, missingValue, emptyLabel, defaultOpen, expandable, visuallyHidden, renderTable, className, }: ChartDataTableProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/chart-explainer.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentPropsWithoutRef } from 'react';
+export type ChartExplainerProps = ComponentPropsWithoutRef<'p'>;
+/** Plain-language context for what a chart means and when a user should act. */
+export declare function ChartExplainer({ children, className, ...props }: ChartExplainerProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/composition-bar.d.ts

@@ -0,0 +1,41 @@
+import { type ChartTone } from './palette';
+export interface CompositionBarSegment {
+    /** Stable entity key; palette slots are assigned against the sorted full key set. */
+    key: string;
+    label: string;
+    /** Non-negative share of the whole. Non-finite or negative values count as zero. */
+    value: number;
+    /** CSS color. Defaults to the fixed categorical slot for `key`. */
+    color?: string;
+}
+export interface CompositionBarProps {
+    data: readonly CompositionBarSegment[];
+    /** Accessible name for the strip and basis for its legend name. */
+    label: string;
+    /** `inline` fits inside a metric row; `default` leaves room for the legend. */
+    size?: 'inline' | 'default';
+    /**
+     * List legend with exact values below the strip. Defaults to true at size
+     * `default`; forced off at size `inline`, where the accessible summary
+     * carries the exact values instead.
+     */
+    legend?: boolean;
+    formatValue?: (value: number) => string;
+    /** Accessible description when `data` is empty. */
+    emptyLabel?: string;
+    /**
+     * Opt-in status mode for outcome strips: maps segment key → tone, and every
+     * segment wears the validated status chart-fill step for its tone (a tone
+     * entry outranks the segment's `color`; an unmapped segment falls back
+     * explicitly to its `color`, then `neutral` — never a categorical slot).
+     * Omit for categorical strips; behavior without `tones` is unchanged.
+     */
+    tones?: Readonly<Record<string, ChartTone>>;
+}
+/**
+ * Single horizontal 100%-stacked strip for part-to-whole composition only.
+ * Zero-value segments are omitted from the strip but stay in the accessible
+ * summary and legend; the legend IS the exact data at this scale, so there is
+ * no separate exact-data table.
+ */
+export declare function CompositionBar({ data, label, size, legend, formatValue, emptyLabel, tones, }: CompositionBarProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/index.d.ts

@@ -0,0 +1,24 @@
+export { BarChart } from './bar-chart';
+export type { BarChartProps } from './bar-chart';
+export { PieChart } from './pie-chart';
+export type { PieChartDatum, PieChartProps } from './pie-chart';
+export { ChartDataTable, chartSeriesColor, CHART_TOKEN_COLORS } from './chart-data-table';
+export type { ChartDataTableProps, ChartDataTableRenderContext, ChartDatum, ChartSeries } from './chart-data-table';
+export { ChartExplainer } from './chart-explainer';
+export type { ChartExplainerProps } from './chart-explainer';
+export { CompositionBar } from './composition-bar';
+export type { CompositionBarProps, CompositionBarSegment } from './composition-bar';
+export { ChartTooltip } from './chart-tooltip';
+export type { ChartTooltipProps } from './chart-tooltip';
+export { LineChart } from './line-chart';
+export type { LineChartProps } from './line-chart';
+export { AreaChart } from './area-chart';
+export type { AreaChartProps } from './area-chart';
+export { RankedBarChart } from './ranked-bar-chart';
+export type { RankedBarChartProps } from './ranked-bar-chart';
+export { assignSeriesColors, CHART_MAX_SERIES, CHART_OTHER_COLOR, CHART_SERIES_COLORS, CHART_TONE_COLORS, chartToneColor, } from './palette';
+export type { ChartTone } from './palette';
+export { Sparkline } from './sparkline';
+export type { SparklineProps } from './sparkline';
+export { StackedColumnChart } from './stacked-column-chart';
+export type { StackedColumnChartProps, StackedColumnDatum } from './stacked-column-chart';

package/_internal/ui/charts/line-chart.d.ts

@@ -0,0 +1,26 @@
+import { type ChartDatum, type ChartSeries } from './chart-data-table';
+export interface LineChartProps {
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    /** Accessible name for the plot and basis for its exact-data caption. */
+    label: string;
+    description?: string;
+    height?: number;
+    formatValue?: (value: number) => string;
+    emptyLabel?: string;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+    /**
+     * Draw each contiguous segment as a monotone cubic (Fritsch–Carlson)
+     * instead of straight lines. The curve passes exactly through every data
+     * point and never overshoots, so it cannot imply values outside the data.
+     * Marks, tooltips, and the exact-data table are unaffected.
+     */
+    smooth?: boolean;
+}
+/** Dependency-free multi-series trend chart with exact data and focus-equivalent marks. */
+export declare function LineChart({ data, series, label, description, height, formatValue, emptyLabel, compactData, showDataTable, dataTableExpandable, smooth, }: LineChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/monotone-curve.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Monotone cubic interpolation (Fritsch–Carlson) for chart line paths.
+ *
+ * The smoothed curve passes exactly through every data point and never
+ * overshoots: within each segment the interpolant stays inside the y-range of
+ * its two endpoints, so a smoothed line can never imply a value outside the
+ * data. Pure math, no DOM — unit-tested directly.
+ */
+export interface CurvePoint {
+    x: number;
+    y: number;
+}
+/**
+ * Fritsch–Carlson tangents: secant-averaged slopes limited so each cubic
+ * Hermite segment is monotone between its endpoints (no overshoot).
+ */
+export declare function monotoneTangents(points: readonly CurvePoint[]): number[];
+/**
+ * SVG path for the monotone cubic through `points` as Hermite segments in
+ * cubic Bézier form. Fewer than two points yields an empty string; exactly two
+ * yields the straight segment the linear renderer would draw.
+ */
+export declare function monotonePathD(points: readonly CurvePoint[]): string;

package/_internal/ui/charts/palette.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Fixed categorical order validated for adjacent color-vision-deficiency
+ * separation on Bakin's dark canvas. Labels and exact values still carry
+ * meaning; these colors are reinforcement, never the only distinction.
+ */
+export declare const CHART_SERIES_COLORS: readonly ["var(--bakin-color-data-series-1)", "var(--bakin-color-data-series-2)", "var(--bakin-color-data-series-3)", "var(--bakin-color-data-series-4)", "var(--bakin-color-data-series-5)", "var(--bakin-color-data-series-6)", "var(--bakin-color-data-series-7)", "var(--bakin-color-data-series-8)"];
+/** Low-chroma slot for every entity folded into a visible “Other” group. */
+export declare const CHART_OTHER_COLOR = "var(--bakin-color-data-other)";
+/**
+ * Vocabulary for outcome-meaning series. A series that MEANS good/bad/warning
+ * wears a status step; a series that is merely “series 4” wears a categorical
+ * slot — never both in one chart. `neutral` is the honest step for outcome
+ * series that make no good-or-bad claim (canceled, unattributed remainder).
+ */
+export type ChartTone = 'success' | 'danger' | 'attention' | 'neutral';
+/**
+ * Status chart-fill steps. The success/danger/attention trio is re-stepped in
+ * lightness from Bakin's status hues and frozen only after passing the dataviz
+ * palette validator on the dark chart surfaces (all-pairs CVD ΔE ≥ 8, normal
+ * ΔE ≥ 15, ≥ 3:1 contrast); the attention step is deliberately separated from
+ * the categorical amber slot. Changing any value requires re-validation — see
+ * tests/ui/charts/chart-status-tokens.test.ts.
+ */
+export declare const CHART_TONE_COLORS: Record<ChartTone, string>;
+/** Resolve one tone to its frozen status chart-fill step. */
+export declare function chartToneColor(tone: ChartTone): string;
+export declare const CHART_MAX_SERIES: 8;
+/**
+ * Assign the full entity set, not a filtered view. Sorting once against the
+ * complete set prevents surviving series from changing color across filters.
+ */
+export declare function assignSeriesColors(keys: readonly string[]): Map<string, string>;

package/_internal/ui/charts/pie-chart.d.ts

@@ -0,0 +1,80 @@
+import { type ChartTone } from './palette';
+export interface PieChartDatum {
+    /** Stable entity key; the palette slot follows this key, never the value. */
+    key: string;
+    label: string;
+    value: number;
+}
+export interface PieChartProps {
+    data: readonly PieChartDatum[];
+    /** Accessible name for the plot and basis for its exact-data caption. */
+    label: string;
+    description?: string;
+    /** Ring variant with a generous inner radius. */
+    donut?: boolean;
+    formatValue?: (value: number) => string;
+    emptyLabel?: string;
+    /**
+     * Opt-in status mode for outcome charts: maps entity key → tone, and every
+     * slice wears the validated status chart-fill step for its tone instead of
+     * a categorical slot. A rendered key without an entry falls back explicitly
+     * to `neutral` — never to a categorical color and never to a status it did
+     * not claim. Omit for categorical charts; behavior without `tones` is
+     * unchanged. Status and categorical fills never mix in one ring.
+     */
+    tones?: Readonly<Record<string, ChartTone>>;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+}
+/** A pie renders at most this many slices; later entities fold into Other. */
+export declare const PIE_MAX_SLICES = 5;
+/** Slices below this share rely on the legend and exact table instead of a direct label. */
+export declare const PIE_DIRECT_LABEL_MIN_FRACTION = 0.12;
+export interface PieSliceModel {
+    key: string;
+    label: string;
+    value: number;
+    color: string;
+    /** Share of the rendered whole, 0..1. */
+    fraction: number;
+    /** Turn fraction from 12 o'clock, clockwise. */
+    start: number;
+    end: number;
+    isOther: boolean;
+    /** Present on the Other slice: how many entities were folded. */
+    foldedCount?: number;
+}
+export interface PieModel {
+    slices: PieSliceModel[];
+    /** Sum of every rendered value, including the Other fold. */
+    total: number;
+    /** Negative input is a programming error; nothing renders. */
+    hasNegative: boolean;
+}
+/** Point on a circle at a clockwise turn fraction starting from 12 o'clock. */
+export declare function polarPoint(cx: number, cy: number, radius: number, fraction: number): {
+    x: number;
+    y: number;
+};
+/** Closed slice path; `innerRadius` 0 draws a pie wedge, greater an annulus segment. */
+export declare function pieSlicePath(cx: number, cy: number, outerRadius: number, innerRadius: number, start: number, end: number): string;
+/** Whole-percent share label that never rounds a real part to nothing or everything. */
+export declare function formatPieShare(fraction: number): string;
+/**
+ * Pure render model: zero and non-finite values are omitted from the ring
+ * (the exact table keeps them), any finite negative value invalidates the
+ * whole ring, colors come from the fixed palette assignment over the FULL
+ * entity set, and slices beyond the cap — the smallest by value, plus any
+ * entity beyond the palette's stable slots — fold into one Other slice.
+ * Rendered slices keep the caller's data order; they are never reordered
+ * by value. With `tones`, every slice wears its status chart-fill step
+ * (unmapped keys explicitly fall back to `neutral`) and the palette's
+ * stable-slot cap no longer forces a fold — the slice cap still does.
+ */
+export declare function buildPieModel(data: readonly PieChartDatum[], tones?: Readonly<Record<string, ChartTone>>): PieModel;
+/** Part-to-whole share of at most five slices with fixed entity colors and an exact-data disclosure. */
+export declare function PieChart({ data, label, description, donut, formatValue, emptyLabel, tones, showDataTable, compactData, dataTableExpandable, }: PieChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/ranked-bar-chart.d.ts

@@ -0,0 +1,41 @@
+import { type ChartDatum, type ChartSeries } from './chart-data-table';
+import { type ChartTone } from './palette';
+export interface RankedBarChartProps {
+    data: readonly ChartDatum[];
+    /** Ranked bars intentionally compare one unit at a time. */
+    series: ChartSeries;
+    /**
+     * Optional highlighted sub-segment of each bar (e.g. the failed portion of a
+     * call total). Its value is read from `datum.values[secondary.key]`, must
+     * share the primary unit, and renders as a full-opacity inset segment over a
+     * muted total; the legend, per-bar accessible label, and exact table carry
+     * both numbers. Color defaults to the second categorical slot.
+     */
+    secondary?: ChartSeries;
+    /** Accessible name for the chart and basis for its exact-data caption. */
+    label: string;
+    description?: string;
+    /**
+     * Opt-in status coloring for outcome-meaning series: maps series key →
+     * tone, and that series wears the validated status chart-fill step (a tone
+     * entry outranks `ChartSeries.color`). Series without an entry keep their
+     * categorical default, so an identity bar can carry a status overlay (the
+     * failure-overlay pattern). Omit for purely categorical rankings; behavior
+     * without `tones` is unchanged.
+     */
+    tones?: Readonly<Record<string, ChartTone>>;
+    formatValue?: (value: number) => string;
+    emptyLabel?: string;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+}
+/**
+ * Ranked single-unit comparison with full labels, visible exact values, and
+ * an exact-data disclosure. Long entity names stay readable because they are
+ * never squeezed into an x-axis.
+ */
+export declare function RankedBarChart({ data, series, secondary, label, description, tones, formatValue, emptyLabel, showDataTable, compactData, dataTableExpandable, }: RankedBarChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/sparkline.d.ts

@@ -0,0 +1,16 @@
+export interface SparklineProps {
+    /** Null and non-finite values are explicit gaps, never coerced to zero. */
+    values: readonly (number | null)[];
+    width?: number;
+    height?: number;
+    stroke?: string;
+    /** Accessible description, e.g. “input tokens over the last 10 runs”. */
+    label: string;
+    /** Optional human-readable labels corresponding to `values`. */
+    labels?: readonly string[];
+    formatValue?: (value: number) => string;
+    /** Soft same-color fill under each reported segment; gaps break the fill exactly like the line. */
+    area?: boolean;
+}
+/** Compact exact trend summary; pair it with visible current value and direction copy. */
+export declare function Sparkline({ values, width, height, stroke, label, labels, formatValue, area, }: SparklineProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/stacked-column-chart.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from 'react';
+import { type ChartDatum, type ChartSeries } from './chart-data-table';
+export type StackedColumnDatum = ChartDatum;
+export interface StackedColumnChartProps {
+    data: readonly StackedColumnDatum[];
+    /** Full stable entity set; labels and explicit colors override key defaults. */
+    series?: readonly ChartSeries[];
+    /** Compatibility shorthand for a full set whose labels equal their keys. */
+    seriesKeys?: readonly string[];
+    /** Accessible name for the plot. */
+    label?: string;
+    /** Accessible name for the exact-values disclosure. */
+    dataLabel?: string;
+    /** Bucket keys that are still accumulating data. */
+    partialKeys?: readonly string[];
+    /** Plot height in px, excluding legend and labels. */
+    height?: number;
+    formatValue?: (value: number) => string;
+    /** Exact-table label for an absent series value. */
+    missingValue?: ReactNode;
+    /** Plot/tooltip label for a bucket with no reported series values. */
+    missingBucketLabel?: string;
+    /** Shown when no buckets exist. */
+    emptyLabel?: string;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+}
+/** Dense interactive stacked comparison with stable entities and an exact-data disclosure. */
+export declare function StackedColumnChart({ data, series: declaredSeries, seriesKeys, label, dataLabel, partialKeys, height, formatValue, missingValue, missingBucketLabel, emptyLabel, compactData, showDataTable, dataTableExpandable, }: StackedColumnChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/content/code-block.d.ts

@@ -0,0 +1,43 @@
+import * as React from 'react';
+export type CodeBlockLanguage = 'json' | 'text';
+export interface CodeBlockProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    /** Exact source to render. Never truncated or reflowed by this component. */
+    code: string;
+    /**
+     * `json` tokenizes keys, strings, numbers, and keyword literals. Anything
+     * else renders verbatim in the mono frame — an unknown language is shown
+     * honestly rather than mis-highlighted.
+     */
+    language?: CodeBlockLanguage;
+    /**
+     * Names the block. A scrollable block becomes a focusable group carrying
+     * this name; a wrapped block needs no name because it has no scroll region
+     * to reach. Also used for the copy action's label.
+     */
+    label?: string;
+    /** Adds a copy action for the exact source. */
+    copyable?: boolean;
+    /** Wraps long lines instead of scrolling horizontally. */
+    wrap?: boolean;
+}
+type TokenKind = 'key' | 'string' | 'number' | 'literal' | 'plain';
+interface Token {
+    kind: TokenKind;
+    text: string;
+}
+/**
+ * Split JSON into display tokens. Returns a single plain token when the input
+ * is not parseable, so malformed payloads still render exactly as received
+ * rather than being silently mangled by a partial highlight.
+ */
+export declare function tokenizeJson(source: string): Token[];
+/**
+ * The one surface for rendering code and structured data.
+ *
+ * Highlighting is a property of this component rather than something each
+ * consumer paints, so every code surface stays legible and consistent. Colors
+ * come from the syntax token family, which is contrast-validated as normal
+ * text — highlighting must never trade readability for decoration.
+ */
+export declare function CodeBlock({ className, code, copyable, label, language, wrap, ...props }: CodeBlockProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/_internal/ui/content/index.d.ts

@@ -0,0 +1,2 @@
+export { CodeBlock, tokenizeJson } from './code-block';
+export type { CodeBlockLanguage, CodeBlockProps } from './code-block';