semiotic 3.5.1 → 3.5.2

package/dist/components/charts/xy/DifferenceChart.d.ts

@@ -0,0 +1,172 @@
+import type { Datum } from "../shared/datumTypes";
+import * as React from "react";
+import type { StreamXYFrameProps } from "../../stream/types";
+import type { RealtimeFrameHandle } from "../../realtime/types";
+import type { LegendInteractionMode, LegendPosition } from "../shared/hooks";
+import type { BaseChartProps, AxisConfig, ChartAccessor } from "../shared/types";
+import { type TooltipProp } from "../../Tooltip/Tooltip";
+/**
+ * DifferenceChart props
+ */
+export interface DifferenceChartProps<TDatum extends Datum = Datum> extends BaseChartProps, AxisConfig {
+    /** Array of `{x, a, b}` data points. Omit for push API mode. */
+    data?: TDatum[];
+    /** Accessor for the x value. Default `"x"`. */
+    xAccessor?: ChartAccessor<TDatum, number>;
+    /** Accessor for series A. Default `"a"`. */
+    seriesAAccessor?: ChartAccessor<TDatum, number>;
+    /** Accessor for series B. Default `"b"`. */
+    seriesBAccessor?: ChartAccessor<TDatum, number>;
+    /** Display label for series A (legend + tooltip). Default `"A"`. */
+    seriesALabel?: string;
+    /** Display label for series B. Default `"B"`. */
+    seriesBLabel?: string;
+    /** Fill color when series A is above series B. Default `"var(--semiotic-danger, #dc2626)"`. */
+    seriesAColor?: string;
+    /** Fill color when series B is above series A. Default `"var(--semiotic-info, #2563eb)"`. */
+    seriesBColor?: string;
+    /** Show the A and B series as overlay lines on top of the filled difference. Default `true`. */
+    showLines?: boolean;
+    /** Line stroke width when `showLines` is true. Default `1.5`. */
+    lineWidth?: number;
+    /** Show data points on the overlay lines. Default `false`. */
+    showPoints?: boolean;
+    /** Point radius when `showPoints` is true. Default `3`. */
+    pointRadius?: number;
+    /** Curve interpolation for both the area boundary and overlay lines. Default `"linear"`. */
+    curve?: "linear" | "monotoneX" | "monotoneY" | "step" | "stepAfter" | "stepBefore" | "basis" | "cardinal" | "catmullRom";
+    /** Fill opacity for the difference region. Default `0.6`. */
+    areaOpacity?: number;
+    /** Gradient fill across each segment, same shape as AreaChart.gradientFill. */
+    gradientFill?: boolean | {
+        topOpacity: number;
+        bottomOpacity: number;
+    } | {
+        colorStops: Array<{
+            offset: number;
+            color: string;
+        }>;
+    };
+    /** Enable hover annotations. */
+    enableHover?: boolean;
+    /** Show grid lines. Default `false`. */
+    showGrid?: boolean;
+    /** Show legend. Default `true`. */
+    showLegend?: boolean;
+    /** Legend interaction mode. */
+    legendInteraction?: LegendInteractionMode;
+    /** Legend position. */
+    legendPosition?: LegendPosition;
+    /** Tooltip config. */
+    tooltip?: TooltipProp;
+    /** Annotation objects. */
+    annotations?: Datum[];
+    /** Fixed x domain. */
+    xExtent?: [number | undefined, number | undefined] | [number];
+    /** Fixed y domain. */
+    yExtent?: [number | undefined, number | undefined] | [number];
+    /** Stable ID accessor for push-mode `remove()` / `update()`. */
+    pointIdAccessor?: string | ((d: Datum) => string);
+    /** Maximum number of raw rows kept in the push buffer. When exceeded,
+     *  oldest rows are evicted FIFO (sliding window). Default: unbounded.
+     *  Recommended for long-running streams so the per-render segment
+     *  recomputation stays bounded. */
+    windowSize?: number;
+    /** Pass-through StreamXYFrame props. */
+    frameProps?: Partial<Omit<StreamXYFrameProps, "chartType" | "data" | "size">>;
+}
+/**
+ * Crossover-segmented record used by the area pipeline. One row per
+ * vertex along either the upper or lower boundary; `__diffSegment` is a
+ * group key per segment so the area scene builder produces one polygon
+ * per id with the correct fill color.
+ */
+interface SegmentRow {
+    __x: number;
+    /** Upper boundary y value (max of A, B). The area pipeline reads this. */
+    __y: number;
+    /** Lower boundary y value (min of A, B) — picked up as per-datum y0. */
+    __y0: number;
+    /** Segment id. Format: `"seg-<index>-<winner>"`. */
+    __diffSegment: string;
+    /** Which series is on top in this segment ("A" or "B"). Drives fill. */
+    __diffWinner: "A" | "B";
+    /** Original A value at this x (or interpolated at crossovers). */
+    __valA: number;
+    /** Original B value at this x (or interpolated at crossovers). */
+    __valB: number;
+    /** Original datum (for tooltip lookup at non-crossover vertices). */
+    __sourceDatum?: Datum;
+}
+/**
+ * Walk sorted data, splitting at each A↔B crossover. Inserts an
+ * interpolated vertex on BOTH sides of every crossover so adjacent
+ * segments meet at a zero-width point (no jagged edges).
+ *
+ * Non-finite rows are skipped; the algorithm tracks the most recent
+ * VALID non-tie row (not the index neighbor) for crossover detection,
+ * so a non-finite gap doesn't drop a crossover that straddles it.
+ *
+ * Tie rows (a === b) are handled distinctly from non-tie rows:
+ *
+ *   - When a tie row sits BETWEEN two non-tie rows with the SAME
+ *     winner, the tie is emitted in that winner's segment as a
+ *     zero-width vertex.
+ *   - When a tie row sits between non-tie rows with DIFFERENT winners,
+ *     the FIRST tie of the run becomes the crossover vertex. The old
+ *     segment closes at the tie's x, the new segment opens at the same
+ *     point, and any subsequent tie rows (multi-tie runs) carry into
+ *     the new segment as zero-width vertices.
+ *
+ * This preserves the data's actual zero-difference point: if the user
+ * supplied a tie row explicitly, the fill switches color exactly at
+ * that x rather than at a linear-interpolated x that ignored the tie.
+ *
+ * Exported for direct unit-testing — the area pipeline depends on the
+ * exact crossover-vertex shape produced here.
+ */
+export declare function computeDifferenceSegments<TDatum extends Datum>(raw: TDatum[], getX: (d: TDatum) => number, getA: (d: TDatum) => number, getB: (d: TDatum) => number): SegmentRow[];
+/**
+ * DifferenceChart — fills the area between two series with a color
+ * that switches based on which series is higher at each x. Crossover
+ * points are interpolated so segments meet cleanly. Both series can
+ * optionally be drawn as overlay lines on top of the fill.
+ *
+ * Classic uses: temperature anomaly (actual vs. normal), forecast
+ * accuracy (actual vs. predicted), budget variance, A/B comparison.
+ *
+ * @example
+ * ```tsx
+ * <DifferenceChart
+ *   data={[
+ *     { date: 1, actual: 50, forecast: 45 },
+ *     { date: 2, actual: 52, forecast: 60 },
+ *     { date: 3, actual: 70, forecast: 58 },
+ *   ]}
+ *   xAccessor="date"
+ *   seriesAAccessor="actual"
+ *   seriesBAccessor="forecast"
+ *   seriesALabel="Actual"
+ *   seriesBLabel="Forecast"
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Streaming via push API — omit `data`, push raw {x, a, b} rows.
+ * const ref = useRef<RealtimeFrameHandle>(null)
+ * useEffect(() => {
+ *   const id = setInterval(() => {
+ *     const t = Date.now()
+ *     ref.current?.push({ x: t, a: 50 + Math.random() * 10, b: 50 + Math.random() * 10 })
+ *   }, 500)
+ *   return () => clearInterval(id)
+ * }, [])
+ * return <DifferenceChart ref={ref} xAccessor="x" seriesAAccessor="a" seriesBAccessor="b" />
+ * ```
+ */
+export declare const DifferenceChart: {
+    <TDatum extends Datum = Datum>(props: DifferenceChartProps<TDatum> & React.RefAttributes<RealtimeFrameHandle>): React.ReactElement | null;
+    displayName?: string;
+};
+export {};

package/dist/components/charts/xy/Scatterplot.d.ts

@@ -5,6 +5,8 @@ import type { RealtimeFrameHandle } from "../../realtime/types";
 import type { BaseChartProps, AxisConfig, ChartAccessor } from "../shared/types";
 import { type TooltipProp } from "../../Tooltip/Tooltip";
 import type { LegendInteractionMode, LegendPosition } from "../shared/hooks";
+import { type RegressionProp } from "../shared/regressionUtils";
+import type { ForecastConfig, AnomalyConfig } from "../shared/statisticalOverlays";
 /**
  * Scatterplot component props
  */
@@ -45,6 +47,38 @@ export interface ScatterplotProps<TDatum extends Datum = Datum> extends BaseChar
     legendPosition?: LegendPosition;
     /** Annotation objects to render on the chart */
     annotations?: Datum[];
+    /**
+     * Overlay a regression line on the scatter. Accepts:
+     * - `true` — linear regression with default styling
+     * - `"linear"` | `"polynomial"` | `"loess"` — pick a method
+     * - `RegressionConfig` — full control (method, bandwidth, order,
+     *   color, strokeWidth, strokeDasharray, label)
+     *
+     * Sugar over `annotations={[{ type: "trend", … }]}` — for richer
+     * setups (multiple regression lines, custom anchoring) drop into
+     * the annotations array directly.
+     *
+     * @example
+     * ```tsx
+     * <Scatterplot data={d} xAccessor="x" yAccessor="y" regression />
+     * <Scatterplot data={d} xAccessor="x" yAccessor="y" regression="loess" />
+     * <Scatterplot data={d} xAccessor="x" yAccessor="y"
+     *   regression={{ method: "polynomial", order: 3, color: "#ef4444", label: "Cubic" }} />
+     * ```
+     */
+    regression?: RegressionProp;
+    /**
+     * Forecast overlay — extends the scatter with tagged future
+     * points + (optional) confidence-envelope annotations. Same shape
+     * as LineChart's `forecast` prop.
+     */
+    forecast?: ForecastConfig;
+    /**
+     * Anomaly overlay — adds a ±σ band annotation and per-point
+     * anomaly dots. Standalone (without forecast) gives raw anomaly
+     * detection on the scatter.
+     */
+    anomaly?: AnomalyConfig;
     /** Fixed x domain `[min, max]` (either bound may be undefined to leave that side data-derived). */
     xExtent?: [number | undefined, number | undefined] | [number];
     /** Fixed y domain `[min, max]` (either bound may be undefined to leave that side data-derived). */

package/dist/components/geometry/ribbonGeometry.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Shared ribbon geometry — emits both the SVG path-D string and the
+ * centerline cubic-bezier cache for a sankey-style band.
+ *
+ * Both SankeyDiagram (via `areaLink` in `./sankeyLinks`) and
+ * ProcessSankey (via the HOC's ribbon-spec construction) need to
+ * draw the same M-C-L-C-Z trapezoid-cap-with-bezier-sides shape and
+ * provide a matching 4-point centerline bezier for the particle
+ * pool. The two charts compute their inputs differently — Sankey
+ * reads (x0/x1/y0/y1, sankeyWidth) from the d3-sankey layout while
+ * ProcessSankey computes (sx, sTop, sBot, tx, tTop, tBot, cp1X, cp2X)
+ * from its temporal attachment math — but the *emission* is shared.
+ *
+ * For Sankey:  cp1X = xi(curvature), cp2X = xi(1-curvature) (smooth
+ *              S-curve, symmetric around the midpoint).
+ * For ProcessSankey: cp1X = cp2X = cx where `cx` depends on
+ *              `ribbonLane` ("source"/"target"/"both") — concentrates
+ *              the bend at a chosen x position.
+ */
+import type { BezierCache } from "../stream/networkTypes";
+export interface RibbonGeometryInput {
+    /** Source x coordinate. */
+    sx: number;
+    /** Source band top (y at source end, smaller y). */
+    sTop: number;
+    /** Source band bottom (y at source end, larger y). */
+    sBot: number;
+    /** Target x coordinate. */
+    tx: number;
+    /** Target band top. */
+    tTop: number;
+    /** Target band bottom. */
+    tBot: number;
+    /** x of the near-source bezier control point. The top curve uses
+     *  `(cp1X, sTop)` as its first control point and the bottom curve
+     *  uses `(cp1X, sBot)` as its last (mirrored). */
+    cp1X: number;
+    /** x of the near-target bezier control point. The top curve uses
+     *  `(cp2X, tTop)` as its second control point and the bottom curve
+     *  uses `(cp2X, tBot)` as its first (mirrored). */
+    cp2X: number;
+}
+export interface RibbonGeometryOutput {
+    /** Closed SVG path describing the visible ribbon band. */
+    pathD: string;
+    /** Centerline cubic for the particle pool. Matches the shape
+     *  `NetworkPipelineStore.buildStandardBezier` produces for sankey
+     *  edges, so both ribbon kinds drive the shared particle
+     *  pipeline identically. */
+    bezier: BezierCache;
+}
+/**
+ * Build both the visible-ribbon path-D and the centerline bezier
+ * cache from a single set of geometric inputs.
+ *
+ * @example
+ * ```ts
+ * // SankeyDiagram (smooth curvature-based S-curve):
+ * const xi = interpolateNumber(source.x1, target.x0)
+ * buildRibbonGeometry({
+ *   sx: source.x1, tx: target.x0,
+ *   sTop: edge.y0 - edge.sankeyWidth / 2,
+ *   sBot: edge.y0 + edge.sankeyWidth / 2,
+ *   tTop: edge.y1 - edge.sankeyWidth / 2,
+ *   tBot: edge.y1 + edge.sankeyWidth / 2,
+ *   cp1X: xi(0.5),  cp2X: xi(0.5),  // curvature defaults to 0.5
+ * })
+ *
+ * // ProcessSankey (lane-aware bend):
+ * const cx = ribbonLane === "source" ? sx + (tx - sx) * 0.85
+ *          : ribbonLane === "target" ? sx + (tx - sx) * 0.15
+ *          : (sx + tx) / 2
+ * buildRibbonGeometry({ sx, sTop, sBot, tx, tTop, tBot, cp1X: cx, cp2X: cx })
+ * ```
+ */
+export declare function buildRibbonGeometry(input: RibbonGeometryInput): RibbonGeometryOutput;

package/dist/components/semiotic-ai.d.ts

@@ -1,5 +1,6 @@
 export { LineChart } from "./charts/xy/LineChart";
 export { AreaChart } from "./charts/xy/AreaChart";
+export { DifferenceChart } from "./charts/xy/DifferenceChart";
 export { StackedAreaChart } from "./charts/xy/StackedAreaChart";
 export { Scatterplot } from "./charts/xy/Scatterplot";
 export { ConnectedScatterplot } from "./charts/xy/ConnectedScatterplot";
@@ -30,6 +31,7 @@ export { SwimlaneChart } from "./charts/ordinal/SwimlaneChart";
 export { ForceDirectedGraph } from "./charts/network/ForceDirectedGraph";
 export { ChordDiagram } from "./charts/network/ChordDiagram";
 export { SankeyDiagram } from "./charts/network/SankeyDiagram";
+export { ProcessSankey } from "./charts/network/ProcessSankey";
 export { TreeDiagram } from "./charts/network/TreeDiagram";
 export { Treemap } from "./charts/network/Treemap";
 export { CirclePack } from "./charts/network/CirclePack";

package/dist/components/semiotic-network.d.ts

@@ -11,10 +11,12 @@ export { TreeDiagram } from "./charts/network/TreeDiagram";
 export { Treemap } from "./charts/network/Treemap";
 export { CirclePack } from "./charts/network/CirclePack";
 export { OrbitDiagram } from "./charts/network/OrbitDiagram";
+export { ProcessSankey } from "./charts/network/ProcessSankey";
 export { NetworkCustomChart } from "./charts/custom/NetworkCustomChart";
 export type { StreamNetworkFrameProps, StreamNetworkFrameHandle, NetworkChartType, NetworkSceneNode, NetworkSceneEdge, NetworkLabel, ThresholdAlertConfig } from "./stream/networkTypes";
 export type { ForceDirectedGraphProps } from "./charts/network/ForceDirectedGraph";
 export type { SankeyDiagramProps } from "./charts/network/SankeyDiagram";
+export type { ProcessSankeyProps, ProcessSankeyTick } from "./charts/network/ProcessSankey";
 export type { ChordDiagramProps } from "./charts/network/ChordDiagram";
 export type { TreeDiagramProps } from "./charts/network/TreeDiagram";
 export type { TreemapProps } from "./charts/network/Treemap";
@@ -22,3 +24,5 @@ export type { CirclePackProps } from "./charts/network/CirclePack";
 export type { OrbitDiagramProps } from "./charts/network/OrbitDiagram";
 export type { NetworkCustomChartProps } from "./charts/custom/NetworkCustomChart";
 export type { NetworkCustomLayout, NetworkLayoutContext, NetworkLayoutResult, } from "./stream/networkCustomLayout";
+export { validateProcessSankey, formatProcessSankeyIssue, } from "./charts/network/processSankey/algorithm";
+export type { ProcessSankeyNode as ProcessSankeyValidatorNode, ProcessSankeyEdge as ProcessSankeyValidatorEdge, ProcessSankeyIssue, } from "./charts/network/processSankey/algorithm";

package/dist/components/semiotic-realtime.d.ts

@@ -20,3 +20,5 @@ export type { RealtimeHeatmapProps } from "./charts/realtime/RealtimeHeatmap";
 export type { ArrowOfTime, WindowMode, ThresholdType, LineStyle, BarStyle, WaterfallStyle, SwarmStyle, AnnotationContext, CrosshairStyle, HoverAnnotationConfig, HoverData } from "./realtime/types";
 export type { StreamXYFrameProps, StreamXYFrameHandle, StreamChartType } from "./stream/types";
 export type { StreamNetworkFrameProps, StreamNetworkFrameHandle, NetworkChartType } from "./stream/networkTypes";
+export { useStreamStatus } from "./charts/shared/useStreamStatus";
+export type { StreamStatus, StreamStatusOptions, StreamStatusResult, } from "./charts/shared/useStreamStatus";

package/dist/components/semiotic-utils.d.ts

@@ -29,3 +29,7 @@ export { RingBuffer } from "./realtime/RingBuffer";
 export { IncrementalExtent } from "./realtime/IncrementalExtent";
 export { normalizeTooltip, MultiPointTooltip } from "./Tooltip/Tooltip";
 export { useReducedMotion, useHighContrast } from "./stream/useMediaPreferences";
+export { sweepToAngles, valueToAngle, computeArcBoundingBox, } from "./charts/shared/radialGeometry";
+export type { SweepAngles, ArcBoundingBox } from "./charts/shared/radialGeometry";
+export { useStreamStatus } from "./charts/shared/useStreamStatus";
+export type { StreamStatus, StreamStatusOptions, StreamStatusResult, } from "./charts/shared/useStreamStatus";

package/dist/components/semiotic-xy.d.ts

@@ -6,6 +6,7 @@ import StreamXYFrame from "./stream/StreamXYFrame";
 export { StreamXYFrame };
 export { LineChart } from "./charts/xy/LineChart";
 export { AreaChart } from "./charts/xy/AreaChart";
+export { DifferenceChart } from "./charts/xy/DifferenceChart";
 export { StackedAreaChart } from "./charts/xy/StackedAreaChart";
 export { Scatterplot } from "./charts/xy/Scatterplot";
 export { ConnectedScatterplot } from "./charts/xy/ConnectedScatterplot";
@@ -21,6 +22,7 @@ export type { StreamXYFrameProps, StreamXYFrameHandle } from "./stream/types";
 export type { CustomLayout, LayoutContext, LayoutResult } from "./stream/customLayout";
 export type { LineChartProps } from "./charts/xy/LineChart";
 export type { AreaChartProps } from "./charts/xy/AreaChart";
+export type { DifferenceChartProps } from "./charts/xy/DifferenceChart";
 export type { StackedAreaChartProps } from "./charts/xy/StackedAreaChart";
 export type { ScatterplotProps } from "./charts/xy/Scatterplot";
 export type { ConnectedScatterplotProps } from "./charts/xy/ConnectedScatterplot";

package/dist/components/semiotic.d.ts

@@ -1,7 +1,7 @@
 import StreamXYFrame from "./stream/StreamXYFrame";
 import StreamOrdinalFrame from "./stream/StreamOrdinalFrame";
 import StreamNetworkFrame from "./stream/StreamNetworkFrame";
-import { Scatterplot, ConnectedScatterplot, LineChart, AreaChart, StackedAreaChart, Heatmap, BubbleChart, BarChart, StackedBarChart, LikertChart, SwarmPlot, BoxPlot, Histogram, ViolinPlot, RidgelinePlot, DotPlot, PieChart, DonutChart, GaugeChart, GroupedBarChart, FunnelChart, SwimlaneChart, ForceDirectedGraph, ChordDiagram, SankeyDiagram, TreeDiagram, Treemap, CirclePack, OrbitDiagram, ScatterplotMatrix, MinimapChart, QuadrantChart, MultiAxisLineChart, CandlestickChart, XYCustomChart, NetworkCustomChart, OrdinalCustomChart } from "./charts";
+import { Scatterplot, ConnectedScatterplot, LineChart, AreaChart, DifferenceChart, StackedAreaChart, Heatmap, BubbleChart, BarChart, StackedBarChart, LikertChart, SwarmPlot, BoxPlot, Histogram, ViolinPlot, RidgelinePlot, DotPlot, PieChart, DonutChart, GaugeChart, GroupedBarChart, FunnelChart, SwimlaneChart, ForceDirectedGraph, ChordDiagram, SankeyDiagram, ProcessSankey, TreeDiagram, Treemap, CirclePack, OrbitDiagram, ScatterplotMatrix, MinimapChart, QuadrantChart, MultiAxisLineChart, CandlestickChart, XYCustomChart, NetworkCustomChart, OrdinalCustomChart } from "./charts";
 import { LinkedCharts } from "./LinkedCharts";
 import { ThemeProvider, useTheme } from "./ThemeProvider";
 import { exportChart } from "./export/exportChart";
@@ -23,8 +23,8 @@ import { RealtimeTemporalHistogram, RealtimeHistogram } from "./charts/realtime/
 import { RealtimeSwarmChart } from "./charts/realtime/RealtimeSwarmChart";
 import { RealtimeWaterfallChart } from "./charts/realtime/RealtimeWaterfallChart";
 import { RealtimeHeatmap } from "./charts/realtime/RealtimeHeatmap";
-export { StreamXYFrame, StreamOrdinalFrame, StreamNetworkFrame, Scatterplot, ConnectedScatterplot, LineChart, AreaChart, StackedAreaChart, Heatmap, BubbleChart, BarChart, StackedBarChart, LikertChart, SwarmPlot, BoxPlot, Histogram, ViolinPlot, RidgelinePlot, DotPlot, ForceDirectedGraph, ChordDiagram, SankeyDiagram, TreeDiagram, PieChart, DonutChart, GaugeChart, FunnelChart, GroupedBarChart, SwimlaneChart, Treemap, CirclePack, OrbitDiagram, ScatterplotMatrix, MinimapChart, QuadrantChart, MultiAxisLineChart, CandlestickChart, XYCustomChart, NetworkCustomChart, OrdinalCustomChart, LinkedCharts, ThemeProvider, useTheme, exportChart, toConfig, fromConfig, toURL, fromURL, copyConfig, configToJSX, serializeSelections, deserializeSelections, fromVegaLite, ChartErrorBoundary, ChartContainer, ChartGrid, CategoryColorProvider, useCategoryColors, ContextLayout, DetailsPanel, Tooltip, MultiLineTooltip, normalizeTooltip, RingBuffer, IncrementalExtent, RealtimeLineChart, RealtimeTemporalHistogram, RealtimeHistogram, RealtimeSwarmChart, RealtimeWaterfallChart, RealtimeHeatmap, createHatchPattern };
-export { ScatterplotProps, ConnectedScatterplotProps, LineChartProps, AreaChartProps, StackedAreaChartProps, HeatmapProps, BubbleChartProps, BarChartProps, StackedBarChartProps, LikertChartProps, SwarmPlotProps, BoxPlotProps, HistogramProps, ViolinPlotProps, DotPlotProps, PieChartProps, DonutChartProps, GaugeChartProps, GaugeThreshold, FunnelChartProps, GroupedBarChartProps, SwimlaneChartProps, RidgelinePlotProps, OrbitDiagramProps, OrbitNode, ForceDirectedGraphProps, ChordDiagramProps, SankeyDiagramProps, TreeDiagramProps, TreemapProps, CirclePackProps, ScatterplotMatrixProps, MinimapChartProps, MinimapConfig, QuadrantChartProps, MultiAxisLineChartProps, MultiAxisSeriesConfig, CandlestickChartProps, QuadrantsConfig, QuadrantConfig, CenterlineStyle, BaseChartProps, AxisConfig, Accessor, ChartAccessor, ChartMode } from "./charts";
+export { StreamXYFrame, StreamOrdinalFrame, StreamNetworkFrame, Scatterplot, ConnectedScatterplot, LineChart, AreaChart, DifferenceChart, StackedAreaChart, Heatmap, BubbleChart, BarChart, StackedBarChart, LikertChart, SwarmPlot, BoxPlot, Histogram, ViolinPlot, RidgelinePlot, DotPlot, ForceDirectedGraph, ChordDiagram, SankeyDiagram, ProcessSankey, TreeDiagram, PieChart, DonutChart, GaugeChart, FunnelChart, GroupedBarChart, SwimlaneChart, Treemap, CirclePack, OrbitDiagram, ScatterplotMatrix, MinimapChart, QuadrantChart, MultiAxisLineChart, CandlestickChart, XYCustomChart, NetworkCustomChart, OrdinalCustomChart, LinkedCharts, ThemeProvider, useTheme, exportChart, toConfig, fromConfig, toURL, fromURL, copyConfig, configToJSX, serializeSelections, deserializeSelections, fromVegaLite, ChartErrorBoundary, ChartContainer, ChartGrid, CategoryColorProvider, useCategoryColors, ContextLayout, DetailsPanel, Tooltip, MultiLineTooltip, normalizeTooltip, RingBuffer, IncrementalExtent, RealtimeLineChart, RealtimeTemporalHistogram, RealtimeHistogram, RealtimeSwarmChart, RealtimeWaterfallChart, RealtimeHeatmap, createHatchPattern };
+export { ScatterplotProps, ConnectedScatterplotProps, LineChartProps, AreaChartProps, DifferenceChartProps, StackedAreaChartProps, HeatmapProps, BubbleChartProps, BarChartProps, StackedBarChartProps, LikertChartProps, SwarmPlotProps, BoxPlotProps, HistogramProps, ViolinPlotProps, DotPlotProps, PieChartProps, DonutChartProps, GaugeChartProps, GaugeThreshold, FunnelChartProps, GroupedBarChartProps, SwimlaneChartProps, RidgelinePlotProps, OrbitDiagramProps, OrbitNode, ForceDirectedGraphProps, ChordDiagramProps, SankeyDiagramProps, ProcessSankeyProps, ProcessSankeyTick, TreeDiagramProps, TreemapProps, CirclePackProps, ScatterplotMatrixProps, MinimapChartProps, MinimapConfig, QuadrantChartProps, MultiAxisLineChartProps, MultiAxisSeriesConfig, CandlestickChartProps, QuadrantsConfig, QuadrantConfig, CenterlineStyle, BaseChartProps, AxisConfig, Accessor, ChartAccessor, ChartMode } from "./charts";
 export type { StreamXYFrameProps, StreamXYFrameHandle, StreamChartType, RuntimeMode, SceneNode, Changeset, StreamScales, StreamLayout, CurveType, CanvasRendererFn } from "./stream/types";
 export type { StreamRendererFn } from "./stream/renderers/types";
 export type { StreamOrdinalFrameProps, StreamOrdinalFrameHandle, OrdinalChartType, OrdinalScales, OrdinalSceneNode } from "./stream/ordinalTypes";

package/dist/components/server/serverChartConfigs.d.ts

@@ -9,6 +9,7 @@ export declare const CHART_CONFIGS: {
     Sparkline: ChartConfig;
     LineChart: ChartConfig;
     AreaChart: ChartConfig;
+    DifferenceChart: ChartConfig;
     StackedAreaChart: ChartConfig;
     Scatterplot: ChartConfig;
     CandlestickChart: ChartConfig;
@@ -44,6 +45,7 @@ export declare const CHART_CONFIGS: {
     GaugeChart: ChartConfig;
     ForceDirectedGraph: ChartConfig;
     SankeyDiagram: ChartConfig;
+    ProcessSankey: ChartConfig;
     ChordDiagram: ChartConfig;
     TreeDiagram: ChartConfig;
     Treemap: ChartConfig;

package/dist/components/stream/GeoPipelineStore.d.ts

@@ -47,6 +47,27 @@ export declare class GeoPipelineStore {
     pushPoint(datum: Datum): void;
     /** Push multiple streaming points */
     pushMany(data: Datum[]): void;
+    /** Append a single line/flow record (coordinates pre-resolved). Lines
+     *  aren't ring-buffered — the bounded set is the geography.
+     *  Mutates `lineData` in place to avoid the O(n) GC churn of an
+     *  array spread per push. The mutation is invisible to callers
+     *  because `setLines` defensive-copies on entry and `getLines`
+     *  defensive-copies on exit. */
+    pushLine(line: Datum): void;
+    /** Append multiple line/flow records in one pass. Same in-place
+     *  mutation rationale as `pushLine`. Loops instead of
+     *  `Array.prototype.push(...safe)` so very large batches don't
+     *  blow the engine's argument-count limit (mirrors how `pushMany`
+     *  for points iterates rather than spreads). */
+    pushManyLines(lines: Datum[]): void;
+    /** Remove line records by id. Requires `lineIdAccessor`. */
+    removeLine(id: string | string[]): Datum[];
+    /** Read the current line/flow set (post-push, pre-projection).
+     *  Defensive copy — `pushLine` / `pushManyLines` mutate
+     *  `lineData` in place, so returning by reference would let
+     *  callers observe ingest-side mutations on a snapshot they
+     *  thought was stable. */
+    getLines(): Datum[];
     /**
      * Remove points by ID. Requires pointIdAccessor to be configured.
      * Returns the removed items.

package/dist/components/stream/OrdinalSVGOverlay.d.ts

@@ -4,6 +4,7 @@ import type { OrdinalScales } from "./ordinalTypes";
 import type { AnnotationContext } from "../realtime/types";
 import type { ReactNode } from "react";
 import type { LegendGroup, GradientLegendConfig } from "../types/legendTypes";
+import { type AxisExtentMode } from "../charts/shared/axisExtent";
 interface OrdinalSVGOverlayProps {
     width: number;
     height: number;
@@ -26,6 +27,12 @@ interface OrdinalSVGOverlayProps {
     rTickValues?: number[];
     /** Align first tick label to start, last to end */
     tickLabelEdgeAlign?: boolean;
+    /** Axis extent mode. "nice" (default) uses d3-scale's rounded
+     *  tick generator. "exact" pins the first and last value-axis
+     *  tick to the actual data min and max with equidistant
+     *  intermediate ticks. Ignored for the categorical (o) axis;
+     *  applies to the value (r) axis only. */
+    axisExtent?: AxisExtentMode;
     showGrid?: boolean;
     title?: string | ReactNode;
     legend?: ReactNode | {
@@ -69,6 +76,7 @@ interface OrdinalSVGUnderlayProps {
     showGrid?: boolean;
     rFormat?: (d: number) => string;
     rTickValues?: number[];
+    axisExtent?: AxisExtentMode;
 }
 export declare function OrdinalSVGUnderlay(props: OrdinalSVGUnderlayProps): import("react/jsx-runtime").JSX.Element | null;
 export declare function OrdinalSVGOverlay(props: OrdinalSVGOverlayProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/stream/PipelineStore.d.ts

@@ -14,6 +14,11 @@ export interface PipelineConfig {
     extentPadding: number;
     /** Pixel inset on scale ranges to prevent glyph clipping at chart edges. Default 0. */
     scalePadding?: number;
+    /** When `"exact"`, the x and y axis domains pin to the literal data
+     *  min/max — `extentPadding` is skipped so the first and last ticks
+     *  read as the actual data bounds. Default `"nice"` keeps the existing
+     *  padded domain so glyphs at the extremes don't clip the plot edge. */
+    axisExtent?: import("../charts/shared/axisExtent").AxisExtentMode;
     maxCapacity?: number;
     xAccessor?: string | ((d: Datum) => number);
     yAccessor?: string | ((d: Datum) => number);

package/dist/components/stream/SVGOverlay.d.ts

@@ -10,6 +10,17 @@ export interface AxisConfig {
     tickFormat?: (d: any, index?: number, allTicks?: number[]) => string | ReactNode;
     baseline?: boolean | "under";
     jaggedBase?: boolean;
+    /** Explicit tick values. When provided, bypasses both d3's "nice"
+     *  generator and `axisExtent: "exact"` — the caller has hand-picked
+     *  the positions. Pixel-distance filtering downstream still drops
+     *  overlapping labels. Accepts `number | Date`: values pass through
+     *  to the scale (d3-scale's `scaleTime` reads Dates natively;
+     *  `scaleLinear` accepts numbers — feeding a Date into a linear
+     *  scale via `valueOf()` works at runtime but `tickFormat` receives
+     *  the Date as-is, so user formatters should match the axis's
+     *  underlying scale type). Mirrors the ordinal frame's
+     *  `rTickValues` contract. */
+    tickValues?: Array<number | Date>;
     /** Grid line stroke style: "dashed" (6,4), "dotted" (2,4), or a custom strokeDasharray string. Applied to grid lines extending from ticks across the chart area. */
     gridStyle?: "dashed" | "dotted" | string;
     /** Always include the domain max as a tick, even if d3 omits it. */
@@ -40,6 +51,12 @@ interface SVGOverlayProps {
     yLabelRight?: string;
     xFormat?: (d: number | Date | string, index?: number, allTicks?: number[]) => string | ReactNode;
     yFormat?: (d: number | Date | string) => string | ReactNode;
+    /** Axis extent mode. "nice" (default) uses d3-scale's rounded
+     *  tick generator — labels stay round but the first/last tick
+     *  may sit inside the data domain. "exact" pins the first and
+     *  last tick to the actual data min and max with equidistant
+     *  intermediate ticks. Applies to both x and y axes. */
+    axisExtent?: import("../charts/shared/axisExtent").AxisExtentMode;
     showGrid?: boolean;
     title?: string | ReactNode;
     legend?: ReactNode | {
@@ -116,6 +133,7 @@ interface SVGUnderlayProps {
     showGrid?: boolean;
     xFormat?: (d: number | Date | string, index?: number, allTicks?: number[]) => string | ReactNode;
     yFormat?: (d: number | Date | string) => string | ReactNode;
+    axisExtent?: import("../charts/shared/axisExtent").AxisExtentMode;
 }
 export declare function SVGUnderlay(props: SVGUnderlayProps): import("react/jsx-runtime").JSX.Element | null;
 export declare function SVGOverlay(props: SVGOverlayProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/stream/annotationAccessorResolver.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Annotation-context accessors must be string keys — SVG overlay
+ * rules look up coordinates with `data[xAccessor]`. When a chart's
+ * user accessor is a function, we bake the resolved value under a
+ * synthetic stable key on each annotation datum and forward the
+ * synthetic key as the annotation's xAccessor / yAccessor.
+ *
+ * Originally inline in `StreamXYFrame.tsx`; lifted here so
+ * `StreamOrdinalFrame` (and any future frame with the same need)
+ * can share the same plumbing rather than re-implementing it.
+ */
+import type { Datum } from "../charts/shared/datumTypes";
+export interface ResolvedAnnotationAccessor {
+    /** String key the annotation context will read on each datum. */
+    key: string | undefined;
+    /** Accessor function when the user supplied one (synthetic key
+     *  gets baked from this); `null` when the user supplied a string
+     *  or nothing. */
+    fn: ((d: Datum) => any) | null;
+}
+/**
+ * Resolve an accessor pair to the (key, fn) shape the annotation
+ * pipeline needs. Probes the primary accessor first, then the
+ * fallback (e.g. `valueAccessor` when no `yAccessor` was supplied).
+ *
+ * - String accessor → use it as the key, no enrichment needed.
+ * - Function accessor → use the synthetic resolved-key, run the fn
+ *   per-datum to bake the value.
+ * - Otherwise undefined.
+ */
+export declare function resolveAnnotationAccessor(primary: unknown, fallback: unknown, resolvedKey: string, fallbackKey: string): ResolvedAnnotationAccessor;
+/**
+ * Build an `enrichAnnotationData(rawData)` function that walks the
+ * data array and bakes synthetic-key values for any function
+ * accessors. Returns the original array reference unchanged when no
+ * enrichment is needed (no annotations, no function accessors, or
+ * synthetic keys already present).
+ */
+export declare function buildEnrichAnnotationData(xResolved: ResolvedAnnotationAccessor, yResolved: ResolvedAnnotationAccessor, hasAnnotations: boolean): (rawData: Datum[] | undefined) => Datum[] | undefined;

package/dist/components/stream/geoTypes.d.ts

@@ -95,6 +95,8 @@ export interface GeoPipelineConfig {
     introAnimation?: boolean;
     annotations?: Datum[];
     pointIdAccessor?: string | ((d: Datum) => string);
+    /** ID accessor on line data — required for `removeLine` by id. */
+    lineIdAccessor?: string | ((d: Datum) => string);
 }
 export interface StreamGeoFrameProps<T = Datum> {
     projection: ProjectionProp;
@@ -108,6 +110,8 @@ export interface StreamGeoFrameProps<T = Datum> {
     yAccessor?: string | ((d: T) => number);
     lineDataAccessor?: string | ((d: T) => Datum[]);
     pointIdAccessor?: string | ((d: T) => string);
+    /** ID accessor on line data — required for ref `removeLine` by id. */
+    lineIdAccessor?: string | ((d: T) => string);
     lineType?: "geo" | "line";
     /** Flow rendering style: "basic" (straight/great-circle), "offset" (bidirectional offset), "arc" (curved arcs) @default "basic" */
     flowStyle?: "basic" | "offset" | "arc";
@@ -212,6 +216,14 @@ export interface StreamGeoFrameHandle {
     pushMany(data: Datum[]): void;
     /** Remove points by ID. Requires pointIdAccessor. */
     removePoint(id: string | string[]): Datum[];
+    /** Append a single line/flow record. Coordinates pre-resolved per `lineDataAccessor`. */
+    pushLine(line: Datum): void;
+    /** Append multiple line/flow records in one batch. */
+    pushManyLines(lines: Datum[]): void;
+    /** Remove lines by ID. Requires `lineIdAccessor`. */
+    removeLine(id: string | string[]): Datum[];
+    /** Read the current line/flow set. */
+    getLines(): Datum[];
     clear(): void;
     getProjection(): GeoProjection | null;
     getGeoPath(): GeoPath<any, GeoPermissibleObjects> | null;

package/dist/components/stream/ordinalTypes.d.ts

@@ -156,6 +156,11 @@ export interface OrdinalPipelineConfig {
     windowSize: number;
     windowMode: WindowMode;
     extentPadding: number;
+    /** When `"exact"`, the value-axis domain is pinned to the literal data
+     *  min/max — `extentPadding` is skipped so the first and last ticks
+     *  land on the actual data bounds. Default `"nice"` keeps the existing
+     *  padded domain so symbols at the extremes don't clip the plot edge. */
+    axisExtent?: import("../charts/shared/axisExtent").AxisExtentMode;
     projection: "vertical" | "horizontal" | "radial";
     categoryAccessor?: string | ((d: Datum) => string);
     valueAccessor?: string | ((d: Datum) => number) | Array<string | ((d: Datum) => number)>;
@@ -315,6 +320,13 @@ export interface StreamOrdinalFrameProps<T = Datum> {
     rTickValues?: number[];
     /** Align first tick label to start and last tick label to end. Default false. */
     tickLabelEdgeAlign?: boolean;
+    /** Axis extent mode for the value (r) axis. `"nice"` (default) uses
+     *  d3-scale's rounded tick generator. `"exact"` pins the first and
+     *  last tick to the actual data min and max with equidistant
+     *  intermediate ticks. The categorical (o) axis is unaffected since
+     *  it's a band scale, not a continuous one. Ignored when explicit
+     *  `rTickValues` are provided — caller has hand-picked positions. */
+    axisExtent?: import("../charts/shared/axisExtent").AxisExtentMode;
     pieceStyle?: (d: Datum, category?: string) => Style;
     summaryStyle?: (d: Datum, category?: string) => Style;
     colorScheme?: string | string[];