semiotic 3.5.1 → 3.5.3

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,9 +23,9 @@ 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 type { StreamXYFrameProps, StreamXYFrameHandle, StreamChartType, RuntimeMode, SceneNode, Changeset, StreamScales, StreamLayout, CurveType, CanvasRendererFn } from "./stream/types";
+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, XYFrameAxisConfig, BandConfig } from "./stream/types";
 export type { StreamRendererFn } from "./stream/renderers/types";
 export type { StreamOrdinalFrameProps, StreamOrdinalFrameHandle, OrdinalChartType, OrdinalScales, OrdinalSceneNode } from "./stream/ordinalTypes";
 export type { StreamNetworkFrameProps, StreamNetworkFrameHandle, NetworkChartType, NetworkSceneNode, NetworkSceneEdge, NetworkLabel, ThresholdAlertConfig } from "./stream/networkTypes";

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

@@ -22,6 +22,7 @@ import type { StreamGeoFrameProps } from "../stream/geoTypes";
 import { type ThemeInput } from "./themeResolver";
 import { CHART_CONFIGS } from "./serverChartConfigs";
 type FrameType = "xy" | "ordinal" | "network" | "geo";
+type StaticFrameProps = (StreamXYFrameProps | StreamNetworkFrameProps | StreamOrdinalFrameProps | StreamGeoFrameProps) & ThemeAwareProps;
 interface ThemeAwareProps {
     theme?: ThemeInput;
     showLegend?: boolean;
@@ -35,7 +36,7 @@ interface ThemeAwareProps {
     /** Prefix for SVG element IDs — used by renderDashboard to avoid collisions */
     _idPrefix?: string;
 }
-export declare function renderToStaticSVG(frameType: FrameType, props: (StreamXYFrameProps | StreamNetworkFrameProps | StreamOrdinalFrameProps | StreamGeoFrameProps) & ThemeAwareProps): string;
+export declare function renderToStaticSVG(frameType: FrameType, props: StaticFrameProps): string;
 export declare function renderXYToStaticSVG(props: StreamXYFrameProps & ThemeAwareProps): string;
 export declare function renderOrdinalToStaticSVG(props: StreamOrdinalFrameProps & ThemeAwareProps): string;
 export declare function renderNetworkToStaticSVG(props: StreamNetworkFrameProps & ThemeAwareProps): string;

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;
@@ -26,6 +27,7 @@ export declare const CHART_CONFIGS: {
         };
     };
     ConnectedScatterplot: ChartConfig;
+    QuadrantChart: ChartConfig;
     Heatmap: ChartConfig;
     BarChart: ChartConfig;
     StackedBarChart: ChartConfig;
@@ -44,6 +46,7 @@ export declare const CHART_CONFIGS: {
     GaugeChart: ChartConfig;
     ForceDirectedGraph: ChartConfig;
     SankeyDiagram: ChartConfig;
+    ProcessSankey: ChartConfig;
     ChordDiagram: ChartConfig;
     TreeDiagram: ChartConfig;
     Treemap: ChartConfig;

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

@@ -29,7 +29,7 @@ interface AnnotationLayout {
     height: number;
 }
 export interface StaticAnnotationConfig {
-    annotations: Datum[];
+    annotations?: Datum[];
     scales: AnnotationScales;
     layout: AnnotationLayout;
     theme: SemioticTheme;

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

@@ -6,7 +6,12 @@
  * No CSS custom properties — everything is concrete for inline SVG.
  */
 import type { SemioticTheme } from "../store/ThemeStore";
-export type ThemeInput = string | Partial<SemioticTheme> | undefined;
+type PartialThemeObject = Omit<Partial<SemioticTheme>, "colors" | "typography" | "tooltip"> & {
+    colors?: Partial<SemioticTheme["colors"]>;
+    typography?: Partial<SemioticTheme["typography"]>;
+    tooltip?: Partial<NonNullable<SemioticTheme["tooltip"]>>;
+};
+export type ThemeInput = string | PartialThemeObject | undefined;
 /**
  * Resolve a theme input to a full SemioticTheme object.
  *
@@ -37,3 +42,4 @@ export declare function themeStyles(theme: SemioticTheme): {
     titleFontSize: number;
     tickFontFamily: string;
 };
+export {};

package/dist/components/store/ThemeStore.d.ts

@@ -90,6 +90,12 @@ export interface ThemeStoreState {
     theme: SemioticTheme;
     setTheme: (theme: ThemeStoreUpdate) => void;
 }
-export type ThemeStoreUpdate = Partial<SemioticTheme> | "light" | "dark" | "high-contrast";
+export type SemioticThemeUpdate = Omit<Partial<SemioticTheme>, "colors" | "typography" | "tooltip" | "accessibility"> & {
+    colors?: Partial<SemioticTheme["colors"]>;
+    typography?: Partial<SemioticTheme["typography"]>;
+    tooltip?: Partial<NonNullable<SemioticTheme["tooltip"]>>;
+    accessibility?: Partial<NonNullable<SemioticTheme["accessibility"]>>;
+};
+export type ThemeStoreUpdate = SemioticThemeUpdate | "light" | "dark" | "high-contrast";
 export declare function resolveThemeUpdate(current: SemioticTheme, theme: ThemeStoreUpdate): SemioticTheme;
 export declare const ThemeProvider: import("react").FC<import("./createStore").StoreProviderProps<ThemeStoreState>>, useThemeSelector: <R>(selector: (state: ThemeStoreState) => R) => R;

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

@@ -1,14 +1,14 @@
 import * as React from "react";
 /** Scene node type used by the accessible data table — accepts any frame's scene nodes */
 type AnySceneNode = {
-    type: string;
+    type?: string;
     [key: string]: any;
 };
 declare const SR_ONLY_STYLE: React.CSSProperties;
 /**
  * Compute an aria-label describing the chart type and data shape from the scene graph.
  */
-export declare function computeCanvasAriaLabel(scene: AnySceneNode[], chartType: string): string;
+export declare function computeCanvasAriaLabel(scene: AnySceneNode[] | null | undefined, chartType: string): string;
 /**
  * Compute an aria-label for network charts from scene nodes and edges.
  */

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

@@ -1,8 +1,10 @@
 import type { Datum } from "../charts/shared/datumTypes";
 import { type Quadtree } from "d3-quadtree";
 import { RingBuffer } from "../realtime/RingBuffer";
-import type { Changeset, StreamChartType, StreamScales, StreamLayout, SceneNode, PointSceneNode, CandlestickStyle, Style, ArrowOfTime, WindowMode, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig, CurveType, BarStyle, ThemeSemanticColors } from "./types";
+import type { Changeset, StreamChartType, StreamScales, StreamLayout, SceneNode, PointSceneNode, CandlestickStyle, Style, ArrowOfTime, WindowMode, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig, CurveType, BarStyle, ThemeSemanticColors, BandConfig } from "./types";
+import { type CoercibleNumber } from "./accessorUtils";
 import type { ActiveTransition } from "./pipelineTransitionUtils";
+import type { ResolvedRibbon } from "./xySceneBuilders/ribbonScene";
 import type { CustomLayout } from "./customLayout";
 import type { MarginType } from "../types/marginType";
 export interface PipelineConfig {
@@ -14,13 +16,18 @@ 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);
-    timeAccessor?: string | ((d: Datum) => number);
-    valueAccessor?: string | ((d: Datum) => number);
+    xAccessor?: string | ((d: Datum) => CoercibleNumber);
+    yAccessor?: string | ((d: Datum) => CoercibleNumber);
+    timeAccessor?: string | ((d: Datum) => CoercibleNumber);
+    valueAccessor?: string | ((d: Datum) => CoercibleNumber);
     colorAccessor?: string | ((d: Datum) => string);
-    sizeAccessor?: string | ((d: Datum) => number);
+    sizeAccessor?: string | ((d: Datum) => CoercibleNumber);
     groupAccessor?: string | ((d: Datum) => string);
     categoryAccessor?: string | ((d: Datum) => string);
     lineDataAccessor?: string;
@@ -35,16 +42,17 @@ export interface PipelineConfig {
     baseline?: "zero" | "wiggle" | "silhouette";
     /** Stack order — see StreamXYFrameProps.stackOrder. */
     stackOrder?: "key" | "insideOut" | "asc" | "desc";
-    openAccessor?: string | ((d: Datum) => number);
-    highAccessor?: string | ((d: Datum) => number);
-    lowAccessor?: string | ((d: Datum) => number);
-    closeAccessor?: string | ((d: Datum) => number);
+    openAccessor?: string | ((d: Datum) => CoercibleNumber);
+    highAccessor?: string | ((d: Datum) => CoercibleNumber);
+    lowAccessor?: string | ((d: Datum) => CoercibleNumber);
+    closeAccessor?: string | ((d: Datum) => CoercibleNumber);
     candlestickStyle?: CandlestickStyle;
     /** Internal: set by PipelineStore when open/close accessors are both missing */
     candlestickRangeMode?: boolean;
-    boundsAccessor?: string | ((d: Datum) => number);
+    boundsAccessor?: string | ((d: Datum) => CoercibleNumber);
     boundsStyle?: any;
-    y0Accessor?: string | ((d: Datum) => number);
+    y0Accessor?: string | ((d: Datum) => CoercibleNumber);
+    band?: BandConfig | BandConfig[];
     gradientFill?: {
         topOpacity: number;
         bottomOpacity: number;
@@ -144,8 +152,12 @@ export declare class PipelineStore {
     private getCategory;
     private getSize;
     private getColor;
-    private getBounds;
     private getY0;
+    /** Unified ribbon list — `boundsAccessor` + `band` both compose into
+     *  this single array (see `resolveRibbons`). Read by the scene
+     *  builders, y-extent expansion, and tooltip enrichment (which
+     *  filters on `kind === "band"`). Empty when neither prop is set. */
+    resolvedRibbons: ResolvedRibbon[];
     private getOpen;
     private getHigh;
     private getLow;

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

@@ -1,25 +1,9 @@
 import type { Datum } from "../charts/shared/datumTypes";
-import type { StreamScales, MarginalGraphicsConfig } from "./types";
+import type { StreamScales, MarginalGraphicsConfig, XYFrameAxisConfig } from "./types";
 import type { AnnotationContext } from "../realtime/types";
 import type { ReactNode } from "react";
 import type { LegendGroup, GradientLegendConfig } from "../types/legendTypes";
-export interface AxisConfig {
-    orient: "left" | "right" | "top" | "bottom";
-    label?: string;
-    ticks?: number;
-    tickFormat?: (d: any, index?: number, allTicks?: number[]) => string | ReactNode;
-    baseline?: boolean | "under";
-    jaggedBase?: boolean;
-    /** 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. */
-    includeMax?: boolean;
-    /** Auto-rotate labels 45° when horizontal spacing is too tight. */
-    autoRotate?: boolean;
-    /** Highlight ticks at time boundaries (new month, year, etc.) with semibold text.
-     * `true` auto-detects Date boundaries. A function receives (value, index) and returns true for landmark ticks. */
-    landmarkTicks?: boolean | ((value: any, index: number) => boolean);
-}
+export type AxisConfig = XYFrameAxisConfig;
 interface SVGOverlayProps {
     width: number;
     height: number;
@@ -40,6 +24,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 +106,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/accessorUtils.d.ts

@@ -12,6 +12,7 @@
  * the variable in the dependency array so the reference changes when behavior changes.
  */
 export declare function accessorsEquivalent(a: string | ((...args: any[]) => any) | undefined, b: string | ((...args: any[]) => any) | undefined): boolean;
-export declare function resolveAccessor<T extends Record<string, unknown>>(accessor: string | ((d: T) => number) | undefined, fallback: string): (d: T) => number;
+export type CoercibleNumber = number | Date | string;
+export declare function resolveAccessor<T extends Record<string, unknown>>(accessor: string | ((d: T) => CoercibleNumber) | undefined, fallback: string): (d: T) => number;
 export declare function resolveRawAccessor<T extends Record<string, unknown>>(accessor: string | ((d: T) => unknown) | undefined, fallback: string): (d: T) => unknown;
 export declare function resolveStringAccessor<T extends Record<string, unknown>>(accessor: string | ((d: T) => string) | undefined, fallback?: string): ((d: T) => string) | undefined;

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/layouts/hierarchyLayoutPlugin.d.ts

@@ -5,7 +5,7 @@ import type { NetworkLayoutPlugin } from "../networkTypes";
  * Uses d3-hierarchy for all layout computations. This plugin is `hierarchical: true`,
  * meaning the input data is a single root node object rather than flat nodes+edges arrays.
  *
- * The hierarchy root is passed via `(config as any).__hierarchyRoot`, set by the store
+ * The hierarchy root is passed via `config.__hierarchyRoot`, set by the store
  * before calling computeLayout. The plugin builds the d3 hierarchy internally, runs the
  * appropriate layout algorithm, and populates the nodes/edges arrays.
  *

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

@@ -262,9 +262,20 @@ export interface NetworkLineEdge {
 export interface NetworkBezierEdge {
     type: "bezier";
     pathD: string;
+    /** When false, the hit tester skips this edge. Used for
+     *  decorative scene-edges like ProcessSankey's gradient stubs —
+     *  they paint visually but shouldn't intercept hover. */
+    interactive?: boolean;
     bezierCache?: BezierCache;
     style: Style;
     datum: SceneDatum;
+    /** Internal gradient used by circular sankey stub bands. */
+    _gradient?: {
+        x0: number;
+        x1: number;
+        from: number;
+        to: number;
+    };
     _pulseIntensity?: number;
     _pulseColor?: string;
     /** Lazily-built Path2D for hit testing; invalidated when pathD changes. */

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

@@ -21,8 +21,22 @@ export interface WedgeSceneNode {
     startAngle: number;
     /** End angle in radians, canvas convention */
     endAngle: number;
-    /** Corner radius for rounded wedge arcs (d3-shape arc.cornerRadius) */
+    /** Corner radius for rounded wedge arcs (d3-shape arc.cornerRadius).
+     *  When set on its own, rounds ALL FOUR corners (the d3-shape default).
+     *  Pair with `roundedEnds` to round only the gauge's outer endpoints —
+     *  the swimlane analogue for radial sectors: first wedge's start side
+     *  + last wedge's end side rounded, internal zone seams stay square. */
     cornerRadius?: number;
+    /** Selective per-end rounding. When omitted, `cornerRadius` rounds all
+     *  four corners. When provided, `cornerRadius` rounds ONLY the sides
+     *  marked `true` — `{ start: true }` rounds the wedge's startAngle
+     *  side (both inner and outer corners at that angle), `{ end: true }`
+     *  rounds the endAngle side. The gauge scene builder uses this to
+     *  paint outer endpoints rounded but internal zone seams square. */
+    roundedEnds?: {
+        start?: boolean;
+        end?: boolean;
+    };
     style: Style;
     datum: SceneDatum;
     category?: string;
@@ -156,6 +170,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 +334,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[];

package/dist/components/stream/renderers/cornerRadii.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Per-corner radius utilities shared between the canvas (`barCanvasRenderer`)
+ * and SVG (`SceneToSVG`) paint paths.
+ *
+ * Both paths previously carried the same `hasAnyCornerRadius` predicate
+ * and the same `min(radius, w/2, h/2)` clamp inline. Splitting them by
+ * renderer left two near-identical implementations that drifted in
+ * comments more than once; centralizing here keeps the swimlane rounding
+ * contract — and any future per-corner shape (cards, tab corners,
+ * partial-stack rounding) — in one place.
+ *
+ * The actual path-tracing primitives (canvas `arcTo` vs SVG `A`) stay in
+ * each renderer because their output formats differ — this module owns
+ * the geometry, the renderers own the drawing language.
+ */
+import type { RectSceneNode } from "../types";
+/** True when at least one corner has a positive radius. */
+export declare function hasAnyCornerRadius(c: NonNullable<RectSceneNode["cornerRadii"]>): boolean;
+export interface ClampedCornerRadii {
+    tl: number;
+    tr: number;
+    br: number;
+    bl: number;
+}
+/**
+ * Read each corner's radius and clamp to `[0, min(w, h) / 2]` so a
+ * corner never overdraws past the rect's center on thin lanes AND a
+ * negative input never leaks into the `moveTo` / `lineTo` math (where
+ * a negative radius would offset the start point into invalid space,
+ * producing visibly bent or escaping paths even though the `arcTo`
+ * is gated on `> 0`). Missing corners collapse to 0 (square).
+ */
+export declare function clampCornerRadii(node: RectSceneNode): ClampedCornerRadii;

package/dist/components/stream/renderers/wedgePathBuilder.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Annular sector path builder with selective per-end corner rounding.
+ *
+ * d3-shape's `arc().cornerRadius()` rounds ALL FOUR corners of an
+ * annular sector uniformly — there's no built-in per-corner control.
+ * For gauges with multiple zones we want the gauge's OUTER endpoints
+ * rounded (the swimlane convention applied radially) but internal zone
+ * seams to stay square. This helper builds the path manually so each
+ * end can be opted in independently.
+ *
+ * The geometry mirrors d3's algorithm: a corner circle of radius `cr`
+ * is inscribed tangent to both walls (the outer/inner arc and the
+ * radial line at the relevant angle). The angular setback from the
+ * radial line is `asin(cr / (R ± cr))` — `R - cr` for outer corners
+ * (corner centers sit `cr` inward of the outer arc), `R + cr` for
+ * inner corners.
+ *
+ * Returned shape is an SVG path `d` attribute, equivalently consumable
+ * by Path2D in canvas. Coordinates are wedge-local (centered at
+ * origin); the renderer translates to `(cx, cy)`.
+ *
+ * Inputs use the **canvas angle convention** (0 = 3 o'clock, positive
+ * clockwise) — same as `WedgeSceneNode.startAngle/endAngle`. d3-shape
+ * uses 0 = 12 o'clock, so callers that pre-rotated by `+π/2` to call
+ * d3-arc should NOT pre-rotate when calling this helper.
+ */
+export interface AnnularPathOptions {
+    innerRadius: number;
+    outerRadius: number;
+    startAngle: number;
+    endAngle: number;
+    cornerRadius?: number;
+    /** Round the side at startAngle (both inner + outer corners there). */
+    roundStart?: boolean;
+    /** Round the side at endAngle (both inner + outer corners there). */
+    roundEnd?: boolean;
+}
+/**
+ * Build the SVG path for an annular sector with per-end rounding.
+ *
+ * When `cornerRadius` is 0 or unset, OR neither `roundStart` nor
+ * `roundEnd` is true, the result is a plain unrounded sector — same
+ * shape `drawWedgeManual` would emit. When both ends are rounded with
+ * a single cornerRadius value, the output matches what d3-arc would
+ * produce. The novel case is mixed rounding: e.g. `roundStart: true,
+ * roundEnd: false` rounds only the gauge's leading edge.
+ *
+ * Defensive clamps:
+ *   - `cornerRadius` is clamped to `(outerRadius - innerRadius) / 2`
+ *     so the corner circles can't cross the ring's centerline (which
+ *     would invert the inner radial line).
+ *   - If the angular sweep is too small to fit two corner radii
+ *     end-to-end on the requested side, that side falls back to
+ *     unrounded so the path stays well-formed.
+ */
+export declare function annularSectorPath(opts: AnnularPathOptions): string;