semiotic 3.5.3 → 3.6.0

package/dist/components/ai/repairChartConfig.d.ts

@@ -0,0 +1,73 @@
+import type { Datum } from "../charts/shared/datumTypes";
+import type { ChartDataProfile, Suggestion } from "./chartCapabilityTypes";
+import type { IntentId } from "./intents";
+/**
+ * Repair result when the chosen chart fits the data — nothing to fix.
+ */
+export interface RepairOkResult {
+    status: "ok";
+    component: string;
+    /** The same data profile that was evaluated. */
+    profile: ChartDataProfile;
+}
+/**
+ * Repair result when the chosen chart doesn't fit. Carries the diagnostic
+ * reason from the capability's `fits()` plus ranked alternatives that *do*
+ * fit, with their reasons surfaced for caller narration.
+ */
+export interface RepairAlternativeResult {
+    status: "alternative";
+    /** The component the caller asked about. */
+    component: string;
+    /** Why it doesn't fit. */
+    reason: string;
+    /** Whether the caller intended one of the alternatives anyway. */
+    alternatives: Suggestion[];
+    profile: ChartDataProfile;
+}
+/**
+ * Repair result when no capability is registered for the asked component.
+ */
+export interface RepairUnknownResult {
+    status: "unknown";
+    component: string;
+    /** Closest matches by family/intent — best effort. */
+    alternatives: Suggestion[];
+    profile: ChartDataProfile;
+}
+export type RepairResult = RepairOkResult | RepairAlternativeResult | RepairUnknownResult;
+export interface RepairOptions {
+    /** Caller's intent — informs ranking of alternatives when the chart doesn't fit. */
+    intent?: IntentId | IntentId[];
+    /** Non-tabular payload (network/hierarchy/GeoJSON). Forwarded to profileData. */
+    rawInput?: unknown;
+    /** Limit number of alternatives returned (default 3). */
+    maxAlternatives?: number;
+    /** Pre-computed profile, avoids recomputation. */
+    profile?: ChartDataProfile;
+}
+/**
+ * Validate that a chart component is a sensible choice for a dataset, and
+ * if not, propose alternatives that *do* fit — ranked by the caller's
+ * intent if provided.
+ *
+ * This is the "auto-fix" surface for `--doctor` and agent retry loops.
+ * Given a chart + data, returns either:
+ *
+ *   - { status: "ok", component }                — the chart fits, ship it
+ *   - { status: "alternative", reason, alternatives } — the chart doesn't
+ *       fit; here are charts that do, ranked by intent if specified
+ *   - { status: "unknown", alternatives }        — we don't have a
+ *       capability for that component name; here are sensible defaults
+ *
+ * The contract: a caller can always render `alternatives[0]` and get
+ * something useful. The `reason` field is suitable for verbatim display
+ * to the user.
+ *
+ * @example
+ * repairChartConfig("PieChart", productData, { intent: "rank" })
+ *   // → { status: "alternative",
+ *   //     reason: "9 slices is too many for a pie chart",
+ *   //     alternatives: [BarChart, DotPlot, ...] }
+ */
+export declare function repairChartConfig(component: string, data: ReadonlyArray<Datum> | null | undefined, options?: RepairOptions): RepairResult;

package/dist/components/ai/streamingTypes.d.ts

@@ -0,0 +1,64 @@
+import type { ChartRubric } from "./chartCapabilityTypes";
+import type { IntentId } from "./intents";
+/**
+ * Streaming chart selection has a different shape than static. We don't have
+ * rows yet — we have a *schema*: which fields will arrive, what types, plus
+ * environment hints (throughput, retention).
+ *
+ * Rather than overloading `profileData` (which is row-statistics-centric) we
+ * model streams as a parallel API. The two share the intent vocabulary —
+ * "trend" still means trend — but the suitability logic is its own thing.
+ */
+export type StreamFieldKind = "numeric" | "categorical" | "date" | "boolean";
+export interface StreamFieldSchema {
+    name: string;
+    kind: StreamFieldKind;
+    /** Optional role hint — overrides the engine's inference. */
+    role?: "x" | "y" | "value" | "category" | "series" | "size";
+}
+/**
+ * Schema describing what a stream emits. No data, just shape + environment hints.
+ */
+export interface StreamSchema {
+    fields: ReadonlyArray<StreamFieldSchema>;
+    /**
+     * Hint about expected event rate. Affects chart selection — heatmaps and
+     * waterfalls amortize high-throughput streams better than line charts do.
+     *   • "low"    — < 1 event/sec, line/area charts read well
+     *   • "medium" — ~1-100 events/sec
+     *   • "high"   — > 100 events/sec, prefer aggregating visualizations
+     */
+    throughput?: "low" | "medium" | "high";
+    /**
+     * Hint about how long events are kept in view.
+     *   • "windowed"   — only recent events visible (default)
+     *   • "cumulative" — all events accumulate
+     */
+    retention?: "windowed" | "cumulative";
+}
+/**
+ * Stream capability descriptor — parallel to ChartCapability but operates on
+ * a schema. No `fits(profile)`; instead `fits(schema)` returns null/reason.
+ */
+export interface StreamChartCapability {
+    component: string;
+    importPath: "semiotic/realtime";
+    rubric: ChartRubric;
+    fits: (schema: StreamSchema) => null | string;
+    intentScores: Partial<Record<IntentId, StreamIntentScorer>>;
+    caveats?: (schema: StreamSchema) => ReadonlyArray<string>;
+    buildProps: (schema: StreamSchema) => Record<string, unknown>;
+}
+export type StreamIntentScorer = number | ((schema: StreamSchema) => number);
+export interface StreamSuggestion {
+    component: string;
+    family: "realtime";
+    importPath: "semiotic/realtime";
+    score: number;
+    intentScores: Partial<Record<IntentId, number>>;
+    rubric: ChartRubric;
+    reasons: ReadonlyArray<string>;
+    caveats: ReadonlyArray<string>;
+    /** Props ready to spread into the matching realtime chart. */
+    props: Record<string, unknown>;
+}

package/dist/components/ai/suggestCharts.d.ts

@@ -0,0 +1,76 @@
+import type { Datum } from "../charts/shared/datumTypes";
+import { type ProfileDataOptions } from "./profileData";
+import type { ChartCapability, ChartDataProfile, Suggestion } from "./chartCapabilityTypes";
+import type { IntentId } from "./intents";
+import { type AudienceProfile } from "./audienceProfile";
+export interface SuggestChartsOptions extends ProfileDataOptions {
+    /** Ranking intent(s). When omitted, suggestions are ranked by mean intent score. */
+    intent?: IntentId | IntentId[];
+    /** Restrict to these component names. */
+    allow?: ReadonlyArray<string>;
+    /** Exclude these component names. */
+    deny?: ReadonlyArray<string>;
+    /** Maximum suggestions to return (default 10). */
+    maxResults?: number;
+    /** Include variant-level suggestions (default true). */
+    includeVariants?: boolean;
+    /** Filter out suggestions with a composite score below this (default 0 — keep all). */
+    minScore?: number;
+    /** Provide a pre-built profile instead of re-deriving from data. */
+    profile?: ChartDataProfile;
+    /** Override the registry. Defaults to the global capability registry. */
+    capabilities?: ReadonlyArray<ChartCapability>;
+    /**
+     * Audience profile — overrides chart familiarity and applies adoption-target
+     * bias to the ranking. See `audienceProfile.ts`.
+     */
+    audience?: AudienceProfile;
+}
+/**
+ * Suggest charts for a dataset, ranked by intent suitability.
+ *
+ * Heuristic-only — does not call an LLM. Designed to be cheap enough to run on every
+ * keystroke in a UI, and to feed structured context to an LLM when one is available.
+ */
+export declare function suggestCharts(data: ReadonlyArray<Datum> | null | undefined, options?: SuggestChartsOptions): Suggestion[];
+/**
+ * One rejected capability: a chart whose `fits()` returned a reason.
+ * Surfaced by `explainCapabilityFit` for diagnostic panels and `--doctor` auto-fix.
+ */
+export interface RejectedCapability {
+    component: string;
+    family: ChartCapability["family"];
+    importPath: ChartCapability["importPath"];
+    /** Human-readable reason this chart can't render this profile. */
+    reason: string;
+}
+export interface ExplainCapabilityFitResult {
+    /** Capabilities that fit the profile — full ranked suggestion list. */
+    fitting: Suggestion[];
+    /** Capabilities that did not fit, with their rejection reasons. */
+    rejected: RejectedCapability[];
+    /** The profile that was evaluated against (provided or computed). */
+    profile: ChartDataProfile;
+}
+/**
+ * Like `suggestCharts`, but also returns the capabilities that *didn't* fit
+ * along with their rejection reasons. The single best primitive for:
+ *   • "Why isn't there a pie chart option?" UI surfaces (vizmart V.4)
+ *   • `--doctor` auto-fix loops that need to enumerate alternatives
+ *   • Descriptor authoring — quickly see whose `fits()` is too strict
+ *
+ * Mirrors `suggestCharts` for the fitting side. Rejection enumeration walks
+ * every registered capability whether it fits or not.
+ */
+export declare function explainCapabilityFit(data: ReadonlyArray<Datum> | null | undefined, options?: SuggestChartsOptions): ExplainCapabilityFitResult;
+/**
+ * Score a specific (component, variant) pair against a dataset and (optionally) an intent.
+ * Useful for evaluating a chart a user already chose: "is this a good fit for what they want?"
+ */
+export declare function scoreChart(component: string, data: ReadonlyArray<Datum> | null | undefined, options?: {
+    intent?: IntentId | IntentId[];
+    variantKey?: string;
+    profile?: ChartDataProfile;
+}): Suggestion | {
+    reason: string;
+};

package/dist/components/ai/suggestDashboard.d.ts

@@ -0,0 +1,92 @@
+import type { Datum } from "../charts/shared/datumTypes";
+import { type StretchSuggestion } from "./suggestStretchCharts";
+import type { ChartDataProfile, Suggestion } from "./chartCapabilityTypes";
+import type { IntentId } from "./intents";
+import type { AudienceProfile } from "./audienceProfile";
+/**
+ * One panel in a generated dashboard. Pairs a chart suggestion with the
+ * intent that motivated it — consumers render the suggestion and label it
+ * with the intent so readers know *why* that panel exists.
+ */
+export interface DashboardPanel {
+    /** The intent this panel covers. */
+    intent: IntentId;
+    /** The chart picked for that intent. */
+    suggestion: Suggestion;
+}
+export interface DashboardSuggestion {
+    /** Ordered panels, each covering a distinct intent. */
+    panels: DashboardPanel[];
+    /** Intents the engine actually filled. */
+    intentsCovered: IntentId[];
+    /** Intents the engine couldn't fill from this data. */
+    intentsMissing: IntentId[];
+    /**
+     * Stretch panels — unfamiliar-but-fitting charts the audience could grow
+     * into. Empty when no `audience` is provided or `exposureLevel` is 0.
+     * Render alongside the main panels in a distinct surface so users see
+     * them as opt-in literacy growth, not silent defaults.
+     */
+    stretchPanels: StretchSuggestion[];
+    /** The shape profile (computed once, reused for every panel). */
+    profile: ChartDataProfile;
+}
+export interface SuggestDashboardOptions {
+    /**
+     * Intents to attempt. When omitted, the engine picks a sensible default set
+     * based on the data shape (e.g. if `hasTimeAxis`, include "trend"; if
+     * `categoryCount`, include "rank" and "part-to-whole").
+     */
+    intents?: ReadonlyArray<IntentId>;
+    /** Maximum number of panels. Default 6. */
+    maxPanels?: number;
+    /**
+     * When true (default), prefer not to repeat the same chart family across
+     * panels — produces a more varied dashboard. Set false to allow duplicates.
+     */
+    diversifyByFamily?: boolean;
+    /** Allow only these component names. */
+    allow?: ReadonlyArray<string>;
+    /** Exclude these component names. */
+    deny?: ReadonlyArray<string>;
+    /** Optional pre-built profile (avoids recomputation). */
+    profile?: ChartDataProfile;
+    /** Non-tabular payload — forwarded to profileData. */
+    rawInput?: unknown;
+    /**
+     * Audience profile — applies familiarity overrides and adoption-target bias
+     * to every panel's ranking. When set with `exposureLevel >= 1`, the dashboard
+     * additionally returns `stretchPanels` showing unfamiliar-but-fitting charts.
+     */
+    audience?: AudienceProfile;
+    /** Max stretch panels (default min(maxPanels, 3)). */
+    maxStretchPanels?: number;
+}
+/**
+ * Generate a dashboard: a set of complementary chart panels, each
+ * answering a distinct analytical intent on the same dataset.
+ *
+ * The contract: every panel has a stated `intent` and a suggestion that
+ * fits that intent. The engine diversifies by chart family by default to
+ * avoid "every panel is a bar chart" outcomes. Intents that can't be
+ * filled from the data (e.g. "geo" on row data with no lat/lon) are
+ * reported in `intentsMissing` so consumers can show "no fit for geo
+ * here" rather than silently dropping them.
+ *
+ * Heuristic only — no LLM call. The result is suitable for direct
+ * rendering (each panel's `suggestion.props` is spreadable into the
+ * matching chart) or for piping to an LLM as composition context.
+ *
+ * @example
+ * const { panels } = suggestDashboard(data)
+ * return (
+ *   <Grid>
+ *     {panels.map(({ intent, suggestion }) => (
+ *       <Panel key={intent} title={intent}>
+ *         <DynamicChart component={suggestion.component} props={suggestion.props} />
+ *       </Panel>
+ *     ))}
+ *   </Grid>
+ * )
+ */
+export declare function suggestDashboard(data: ReadonlyArray<Datum> | null | undefined, options?: SuggestDashboardOptions): DashboardSuggestion;

package/dist/components/ai/suggestStreamCharts.d.ts

@@ -0,0 +1,34 @@
+import type { StreamChartCapability, StreamSchema, StreamSuggestion } from "./streamingTypes";
+import type { IntentId } from "./intents";
+export declare function registerStreamChartCapability(capability: StreamChartCapability): void;
+export declare function unregisterStreamChartCapability(component: string): void;
+export declare function getStreamCapabilities(): ReadonlyArray<StreamChartCapability>;
+export interface SuggestStreamChartsOptions {
+    intent?: IntentId | IntentId[];
+    allow?: ReadonlyArray<string>;
+    deny?: ReadonlyArray<string>;
+    maxResults?: number;
+    minScore?: number;
+    capabilities?: ReadonlyArray<StreamChartCapability>;
+}
+/**
+ * Suggest realtime charts for a schema, ranked by intent.
+ *
+ * Parallel to `suggestCharts` but operates on a `StreamSchema` (fields +
+ * throughput/retention hints) rather than row data. Use for live dashboards,
+ * monitoring views, anywhere events arrive over time rather than as a bounded
+ * table.
+ *
+ * @example
+ * const suggestions = suggestStreamCharts({
+ *   fields: [
+ *     { name: "ts", kind: "date" },
+ *     { name: "latency_ms", kind: "numeric" },
+ *     { name: "endpoint", kind: "categorical" },
+ *   ],
+ *   throughput: "high",
+ *   retention: "windowed",
+ * }, { intent: "trend" })
+ * // → [{ component: "RealtimeHeatmap", ... }, { component: "RealtimeWaterfallChart", ... }]
+ */
+export declare function suggestStreamCharts(schema: StreamSchema, options?: SuggestStreamChartsOptions): StreamSuggestion[];

package/dist/components/ai/suggestStretchCharts.d.ts

@@ -0,0 +1,60 @@
+import type { Datum } from "../charts/shared/datumTypes";
+import type { ChartDataProfile, Suggestion } from "./chartCapabilityTypes";
+import type { IntentId } from "./intents";
+import { type AudienceProfile } from "./audienceProfile";
+/**
+ * A "stretch pick" — an unfamiliar-but-fitting chart paired with the
+ * familiar chart it could substitute for. Pairing makes the literacy
+ * suggestion concrete: "instead of BarChart, try BoxPlot here, because…"
+ */
+export interface StretchSuggestion {
+    /** The unfamiliar chart we're suggesting as growth. */
+    suggestion: Suggestion;
+    /**
+     * The familiar chart this stretch could replace for the same intent.
+     * Undefined when the stretch is recommended on its own merits (e.g. a
+     * direct "increase" target with no obvious familiar counterpart).
+     */
+    replacing?: string;
+    /** Human-readable rationale, suitable for verbatim display. */
+    rationale: string;
+    /** Audience familiarity for this chart — the number that made it qualify as a stretch. */
+    familiarity: number;
+}
+export interface SuggestStretchChartsOptions {
+    /** Intent(s) to rank by. When omitted, charts are picked by data fit alone. */
+    intent?: IntentId | IntentId[];
+    /** Required — without an audience profile, the concept of "stretch" doesn't apply. */
+    audience?: AudienceProfile;
+    /** Restrict to these component names. */
+    allow?: ReadonlyArray<string>;
+    /** Exclude these component names. */
+    deny?: ReadonlyArray<string>;
+    /** Max stretch picks to return (default 5). */
+    maxResults?: number;
+    /** Pre-built profile. */
+    profile?: ChartDataProfile;
+    /** Non-tabular payload — forwarded to profileData. */
+    rawInput?: unknown;
+    /**
+     * Only return stretches within this score distance of the top familiar pick
+     * (default 1.5). Tighter values keep the suggestions plausible; wider values
+     * expose more variety.
+     */
+    scoreTolerance?: number;
+}
+/**
+ * Find pairs (familiar, stretch) where the stretch chart fits the data,
+ * has audience familiarity at or below the stretch ceiling, and either:
+ *   • is an `increase` target for this audience, OR
+ *   • scores within `scoreTolerance` of a familiar alternative for the
+ *     same intent.
+ *
+ * Each pair is returned as a StretchSuggestion with `replacing` (the
+ * familiar chart it could substitute for) and a rationale string.
+ *
+ * Heuristic only. Use `audience` with care — without target signals, every
+ * audience-unfamiliar chart becomes a candidate, which can drown the
+ * surface in dubious recommendations.
+ */
+export declare function suggestStretchCharts(data: ReadonlyArray<Datum> | null | undefined, options?: SuggestStretchChartsOptions): StretchSuggestion[];

package/dist/components/ai/useChartSuggestions.d.ts

@@ -0,0 +1,22 @@
+import type { Datum } from "../charts/shared/datumTypes";
+import { type ProfileDataOptions } from "./profileData";
+import { type SuggestChartsOptions } from "./suggestCharts";
+import type { ChartDataProfile, Suggestion } from "./chartCapabilityTypes";
+export interface UseChartSuggestionsOptions extends SuggestChartsOptions, ProfileDataOptions {
+}
+export interface UseChartSuggestionsResult {
+    suggestions: ReadonlyArray<Suggestion>;
+    profile: ChartDataProfile;
+}
+/**
+ * Memoized chart suggestion hook.
+ *
+ * Heuristic-only: this hook never calls an LLM. Pair with `useChartInterrogation`
+ * to let an LLM re-rank or narrate the heuristic suggestions.
+ *
+ * @example
+ * const { suggestions } = useChartSuggestions(data, { intent: "trend" })
+ * const top = suggestions[0]
+ * return <DynamicChart component={top.component} props={top.props} />
+ */
+export declare function useChartSuggestions(data: ReadonlyArray<Datum> | null | undefined, options?: UseChartSuggestionsOptions): UseChartSuggestionsResult;

package/dist/components/charts/geo/ChoroplethMap.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const ChoroplethMapCapability: ChartCapability;

package/dist/components/charts/geo/DistanceCartogram.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const DistanceCartogramCapability: ChartCapability;

package/dist/components/charts/geo/FlowMap.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const FlowMapCapability: ChartCapability;

package/dist/components/charts/geo/ProportionalSymbolMap.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const ProportionalSymbolMapCapability: ChartCapability;

package/dist/components/charts/index.d.ts

@@ -13,7 +13,7 @@ export type { ConnectedScatterplotProps } from "./xy/ConnectedScatterplot";
 export { LineChart } from "./xy/LineChart";
 export type { LineChartProps } from "./xy/LineChart";
 export { AreaChart } from "./xy/AreaChart";
-export type { AreaChartProps } from "./xy/AreaChart";
+export type { AreaChartProps, SemanticGradientStop } from "./xy/AreaChart";
 export { DifferenceChart } from "./xy/DifferenceChart";
 export type { DifferenceChartProps } from "./xy/DifferenceChart";
 export { StackedAreaChart } from "./xy/StackedAreaChart";
@@ -27,7 +27,7 @@ export type { ScatterplotMatrixProps } from "./xy/ScatterplotMatrix";
 export { MinimapChart } from "./xy/MinimapChart";
 export type { MinimapChartProps, MinimapConfig } from "./xy/MinimapChart";
 export { QuadrantChart } from "./xy/QuadrantChart";
-export type { QuadrantChartProps, QuadrantsConfig, QuadrantConfig, CenterlineStyle } from "./xy/QuadrantChart";
+export type { QuadrantChartProps, QuadrantsConfig, QuadrantsConfigOverride, QuadrantConfig, CenterlineStyle } from "./xy/QuadrantChart";
 export { MultiAxisLineChart } from "./xy/MultiAxisLineChart";
 export type { MultiAxisLineChartProps, MultiAxisSeriesConfig } from "./xy/MultiAxisLineChart";
 export { CandlestickChart } from "./xy/CandlestickChart";
@@ -88,8 +88,8 @@ export { OrbitDiagram } from "./network/OrbitDiagram";
 export type { OrbitDiagramProps, OrbitNode } from "./network/OrbitDiagram";
 export { RealtimeLineChart } from "./realtime/RealtimeLineChart";
 export type { RealtimeLineChartProps } from "./realtime/RealtimeLineChart";
-export { RealtimeTemporalHistogram, RealtimeHistogram } from "./realtime/RealtimeHistogram";
-export type { RealtimeTemporalHistogramProps, RealtimeHistogramProps } from "./realtime/RealtimeHistogram";
+export { RealtimeTemporalHistogram, RealtimeHistogram, TemporalHistogram } from "./realtime/RealtimeHistogram";
+export type { RealtimeTemporalHistogramProps, RealtimeHistogramProps, TemporalHistogramProps } from "./realtime/RealtimeHistogram";
 export { RealtimeSwarmChart } from "./realtime/RealtimeSwarmChart";
 export type { RealtimeSwarmChartProps } from "./realtime/RealtimeSwarmChart";
 export { RealtimeWaterfallChart } from "./realtime/RealtimeWaterfallChart";

package/dist/components/charts/network/ChordDiagram.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const ChordDiagramCapability: ChartCapability;

package/dist/components/charts/network/CirclePack.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const CirclePackCapability: ChartCapability;

package/dist/components/charts/network/ForceDirectedGraph.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const ForceDirectedGraphCapability: ChartCapability;

package/dist/components/charts/network/OrbitDiagram.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const OrbitDiagramCapability: ChartCapability;

package/dist/components/charts/network/ProcessSankey.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const ProcessSankeyCapability: ChartCapability;

package/dist/components/charts/network/SankeyDiagram.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const SankeyDiagramCapability: ChartCapability;

package/dist/components/charts/network/TreeDiagram.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const TreeDiagramCapability: ChartCapability;

package/dist/components/charts/network/Treemap.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const TreemapCapability: ChartCapability;

package/dist/components/charts/network/Treemap.d.ts

@@ -19,6 +19,14 @@ export interface TreemapProps<TNode extends Datum = Datum> extends BaseChartProp
     nodeLabel?: ChartAccessor<TNode, string>;
     padding?: number;
     paddingTop?: number;
+    /**
+     * Per-node style overlay. The returned style is merged on top of
+     * Treemap's built-in colorBy/colorByDepth/default fill, then primitive
+     * props and selection state are applied. Use this for root hiding,
+     * custom borders, or per-depth opacity without re-implementing color
+     * encoding.
+     */
+    nodeStyle?: (d: Datum) => Datum;
     enableHover?: boolean;
     legendInteraction?: LegendInteractionMode;
     tooltip?: TooltipProp;

package/dist/components/charts/ordinal/BarChart.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const BarChartCapability: ChartCapability;

package/dist/components/charts/ordinal/BoxPlot.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const BoxPlotCapability: ChartCapability;

package/dist/components/charts/ordinal/DonutChart.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const DonutChartCapability: ChartCapability;

package/dist/components/charts/ordinal/DotPlot.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const DotPlotCapability: ChartCapability;

package/dist/components/charts/ordinal/FunnelChart.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const FunnelChartCapability: ChartCapability;

package/dist/components/charts/ordinal/GaugeChart.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const GaugeChartCapability: ChartCapability;

package/dist/components/charts/ordinal/GaugeChart.d.ts

@@ -4,6 +4,7 @@ import type { StreamOrdinalFrameProps } from "../../stream/ordinalTypes";
 import type { BaseChartProps } from "../shared/types";
 import { type TooltipProp } from "../../Tooltip/Tooltip";
 import type { RealtimeFrameHandle } from "../../realtime/types";
+import { type GaugeGradientFill } from "../shared/gaugeGradient";
 export interface GaugeThreshold {
     /** Upper bound of this zone (value, not percentage) */
     value: number;
@@ -21,6 +22,15 @@ export interface GaugeChartProps extends BaseChartProps {
     max?: number;
     /** Threshold zones — ordered list of { value, color, label? }. Last threshold's value should equal max. */
     thresholds?: GaugeThreshold[];
+    /**
+     * Arc-length gradient for the gauge band.
+     *
+     * The gradient is sampled along the visible filled arc from sweep start
+     * toward the current value. If `fillZones` is false, the entire arc uses
+     * the gradient. If `fillZones` is true, the unfilled remainder stays on
+     * `backgroundColor`.
+     */
+    gradientFill?: GaugeGradientFill;
     /** Color of the value arc when no thresholds defined (default: theme primary) */
     color?: string;
     /** Background arc color (default: var(--semiotic-grid, #e0e0e0)) */

package/dist/components/charts/ordinal/GroupedBarChart.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const GroupedBarChartCapability: ChartCapability;

package/dist/components/charts/ordinal/Histogram.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const HistogramCapability: ChartCapability;

package/dist/components/charts/ordinal/Histogram.d.ts

@@ -23,8 +23,10 @@ export interface HistogramProps<TDatum extends Datum = Datum> extends BaseChartP
     data?: TDatum[];
     /**
      * Field name or function returning the bin label (used when data is
-     * already binned). Ignored when binning raw values.
-     * @default "category"
+     * already binned). For raw-observation data with no category dimension,
+     * the default treats all rows as a single "All" bucket — no need to set
+     * this explicitly.
+     * @default (d) => d.category ?? "All"
      */
     categoryAccessor?: ChartAccessor<TDatum, string>;
     /**

package/dist/components/charts/ordinal/LikertChart.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const LikertChartCapability: ChartCapability;

package/dist/components/charts/ordinal/LikertChart.d.ts

@@ -62,7 +62,7 @@ export interface LikertChartProps<TDatum extends Datum = Datum> extends BaseChar
      *
      * Odd count → center level is neutral. Even count → clean negative/positive split.
      */
-    levels: string[];
+    levels?: string[];
     /**
      * "horizontal" (default): diverging bar chart centered at 0%.
      * "vertical": stacked 100% bar chart.

package/dist/components/charts/ordinal/LikertChart.defaults.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_LIKERT_LEVELS: string[];

package/dist/components/charts/ordinal/PieChart.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const PieChartCapability: ChartCapability;

package/dist/components/charts/ordinal/RidgelinePlot.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const RidgelinePlotCapability: ChartCapability;

package/dist/components/charts/ordinal/StackedBarChart.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const StackedBarChartCapability: ChartCapability;

package/dist/components/charts/ordinal/SwarmPlot.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const SwarmPlotCapability: ChartCapability;

package/dist/components/charts/ordinal/SwimlaneChart.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const SwimlaneChartCapability: ChartCapability;

package/dist/components/charts/ordinal/ViolinPlot.capability.d.ts

@@ -0,0 +1,2 @@
+import type { ChartCapability } from "../../ai/chartCapabilityTypes";
+export declare const ViolinPlotCapability: ChartCapability;