semiotic 3.2.0 → 3.2.1

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

@@ -106,6 +106,8 @@ export declare class PipelineStore {
     /** Separate group→color map for resolveGroupColor (insertion-order based, never invalidates _colorMapCache) */
     private _groupColorMap;
     private _barCategoryCache;
+    /** Sorted bin boundary values from the last bar scene build (for data-driven brush snapping) */
+    private _binBoundaries;
     /** Cache stacked area cumulative sums to skip recalculation when buffer hasn't changed */
     private _stackExtentCache;
     /** Monotonic counter incremented on each ingest — used as part of cache keys */
@@ -149,60 +151,14 @@ export declare class PipelineStore {
      */
     private remapScene;
     private buildSceneNodes;
-    private buildLineScene;
-    private buildAreaScene;
-    private buildStackedAreaScene;
-    private buildPointScene;
-    private buildHeatmapScene;
-    /**
-     * Streaming heatmap: discretize continuous x/y into a grid and aggregate.
-     */
-    private buildStreamingHeatmapScene;
-    private buildBarScene;
-    private buildSwarmScene;
-    private buildWaterfallScene;
-    private buildCandlestickScene;
-    private buildBoundsForGroup;
     private resolveBoundsStyle;
-    /**
-     * Compute decay opacity for a datum at `bufferIndex` out of `bufferSize` items.
-     * Index 0 = oldest, bufferSize-1 = newest. Returns 0–1.
-     */
     computeDecayOpacity(bufferIndex: number, bufferSize: number): number;
-    /**
-     * Apply decay opacity to a list of discrete scene nodes.
-     * Uses the datum's index in the buffer data array.
-     */
     private applyDecay;
-    /**
-     * Compute pulse intensity for a datum inserted at `insertTime`.
-     * Returns 0–1 (1 = just inserted, 0 = pulse expired).
-     */
-    private computePulseIntensity;
-    /**
-     * Apply pulse glow to discrete scene nodes.
-     */
     private applyPulse;
-    /**
-     * Returns true if there are active pulse animations that need continuous rendering.
-     */
     get hasActivePulses(): boolean;
-    /**
-     * Snapshot current scene node positions before rebuild.
-     */
+    private get transitionContext();
     private snapshotPositions;
-    /**
-     * Get a stable identity key for a scene node.
-     */
-    private getNodeIdentity;
-    /**
-     * After scene rebuild, set up transition from old to new positions.
-     * Detects entering nodes (new, no prev match) and exiting nodes (prev, no new match).
-     */
     private startTransition;
-    /**
-     * Advance the transition animation. Returns true if still animating.
-     */
     advanceTransition(now: number): boolean;
     private groupData;
     /**
@@ -225,6 +181,8 @@ export declare class PipelineStore {
      */
     private getBufferArray;
     getData(): Record<string, any>[];
+    /** Returns sorted bin boundary values from the last bar scene build. Persists until clear() or the next bar scene build. */
+    getBinBoundaries(): number[];
     getExtents(): {
         x: [number, number];
         y: [number, number];

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

@@ -75,6 +75,10 @@ interface SVGOverlayProps {
     curve?: string;
     /** When true, grid lines and axis baselines are skipped (rendered by SVGUnderlay instead) */
     underlayRendered?: boolean;
+    /** Name of the linked crosshair store entry to read */
+    linkedCrosshairName?: string;
+    /** Source chart ID — crosshair line is suppressed on the source to avoid double rendering */
+    linkedCrosshairSourceId?: string;
     children?: ReactNode;
 }
 interface SVGUnderlayProps {

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

@@ -1,10 +1,15 @@
 import type { SceneNode, LineSceneNode, AreaSceneNode, PointSceneNode, RectSceneNode, HeatcellSceneNode, Style, StreamScales, CurveType } from "./types";
 export declare function buildLineNode(data: Record<string, any>[], scales: StreamScales, xGet: (d: Record<string, any>) => number, yGet: (d: Record<string, any>) => number, style: Style, group?: string): LineSceneNode;
 export declare function buildAreaNode(data: Record<string, any>[], scales: StreamScales, xGet: (d: Record<string, any>) => number, yGet: (d: Record<string, any>) => number, baselineY: number, style: Style, group?: string, y0Get?: (d: Record<string, any>) => number): AreaSceneNode;
+/** Per-group-per-x stacked top values, keyed by group then x */
+export type StackedTops = Map<string, Map<number, number>>;
 export declare function buildStackedAreaNodes(groups: {
     key: string;
     data: Record<string, any>[];
-}[], scales: StreamScales, xGet: (d: Record<string, any>) => number, yGet: (d: Record<string, any>) => number, styleFn: (group: string, sampleDatum?: Record<string, any>) => Style, normalize?: boolean, curve?: CurveType): AreaSceneNode[];
+}[], scales: StreamScales, xGet: (d: Record<string, any>) => number, yGet: (d: Record<string, any>) => number, styleFn: (group: string, sampleDatum?: Record<string, any>) => Style, normalize?: boolean, curve?: CurveType): {
+    nodes: AreaSceneNode[];
+    stackedTops: StackedTops;
+};
 export declare function buildPointNode(datum: Record<string, any>, scales: StreamScales, xGet: (d: Record<string, any>) => number, yGet: (d: Record<string, any>) => number, r: number, style: Style, pointId?: string): PointSceneNode | null;
 export declare function buildRectNode(x: number, y: number, w: number, h: number, style: Style, datum: any, group?: string): RectSceneNode;
 export declare function buildHeatcellNode(x: number, y: number, w: number, h: number, fill: string, datum: any, options?: {

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

@@ -0,0 +1,47 @@
+/**
+ * XYBrushOverlay — d3-brush SVG overlay for XY frames.
+ *
+ * Renders a transparent SVG positioned above the canvas. Supports x, y, and
+ * xy brush dimensions, bin snapping, and streaming brush tracking (shrinks/
+ * clears the brush as data scrolls past the selected range).
+ *
+ * Key design decisions:
+ *   - d3-brush lifecycle depends on [width, height, dimension, snap, binSize, snapDuring]
+ *     only — scales and binBoundaries are read from refs to avoid teardown mid-drag.
+ *   - Data-driven snapping (binBoundaries) uses binary search to snap to actual bin
+ *     edges. Falls back to uniform grid math (binSize) when no boundaries are provided.
+ *   - Bin snapping applies on "end" events by default. Set snapDuring=true to also
+ *     snap during drag (the "brush" event).
+ *   - Streaming tracking guards against y-only dimension (no x-domain to track).
+ *   - isProgrammaticMoveRef prevents re-entrant brush events from .move() calls.
+ *
+ * Consumed by: StreamXYFrame (rendered when brush prop is set).
+ */
+import * as React from "react";
+import type { StreamScales } from "./types";
+export interface XYBrushOverlayProps {
+    width: number;
+    height: number;
+    totalWidth: number;
+    totalHeight: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    dimension: "x" | "y" | "xy";
+    scales: StreamScales | null;
+    onBrush: (extent: {
+        x: [number, number];
+        y: [number, number];
+    } | null) => void;
+    binSize?: number;
+    snap?: "continuous" | "bin";
+    /** Sorted bin boundary values for data-driven snapping (overrides uniform grid math when snap="bin"). Defensively sorted internally. */
+    binBoundaries?: number[];
+    /** When true, snap during drag (not just on release). Default false. */
+    snapDuring?: boolean;
+    streaming?: boolean;
+}
+export declare function XYBrushOverlay({ width, height, totalWidth, totalHeight, margin, dimension, scales, onBrush, binSize, snap, binBoundaries, snapDuring, streaming }: XYBrushOverlayProps): React.JSX.Element;

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

@@ -161,8 +161,12 @@ export interface StreamGeoFrameProps<T = Record<string, any>> {
     legendHighlightedCategory?: string | null;
     legendIsolatedCategories?: Set<string>;
     showAxes?: boolean;
-    /** Render a visually-hidden data table from the scene graph for screen readers (first 50 rows) */
+    /** Render a visually-hidden data table from the scene graph for screen readers */
     accessibleTable?: boolean;
+    /** Accessible description overriding the auto-generated aria-label on the chart container */
+    description?: string;
+    /** Accessible summary rendered as a screen-reader-only note */
+    summary?: string;
 }
 export interface StreamGeoFrameHandle {
     push(datum: Record<string, any>): void;

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

@@ -1,36 +1,112 @@
 /**
  * Keyboard navigation utilities for Stream Frames.
  *
- * Extracts navigable data points from the scene graph, sorts them
- * spatially, and provides an index-based iteration API for arrow-key
- * navigation. Reuses the existing hover/tooltip system — keyboard
- * focus sets the same HoverData state that mouse hover does.
+ * Supports two navigation modes:
+ * - **Flat**: ArrowRight/Left and ArrowUp/Down both advance linearly (geo, simple charts)
+ * - **Graph**: ArrowRight/Left navigates within a series/group, ArrowUp/Down switches
+ *   between series/groups at a similar position (XY lines, stacked bars, networks)
+ *
+ * Reuses the existing hover/tooltip system — keyboard focus sets the same
+ * HoverData state that mouse hover does.
  */
 import type { HoverData } from "../realtime/types";
 export interface NavPoint {
     x: number;
     y: number;
     datum: any;
+    /** Shape hint for focus ring rendering */
+    shape?: "circle" | "rect" | "wedge";
+    /** Width of rect-shaped elements (bars, sankey nodes) */
+    w?: number;
+    /** Height of rect-shaped elements */
+    h?: number;
+    /** Group identifier for graph navigation (series name, category, node id) */
+    group?: string;
+    /** Index in NavGraph.flat — set by buildNavGraph for O(1) lookup */
+    _flatIndex?: number;
+    /** Index within its group — set by buildNavGraph for O(1) resolvePosition */
+    _groupIndex?: number;
+}
+/**
+ * A navigation graph that organizes NavPoints into groups (series/categories)
+ * and positions within each group, enabling 2D keyboard navigation.
+ *
+ * ArrowRight/Left = next/prev within the current group (e.g. along a line series)
+ * ArrowUp/Down = switch to the nearest point in an adjacent group (e.g. switch series)
+ */
+export interface NavGraph {
+    /** All points in flat order (for PageUp/Down, Home/End) */
+    flat: NavPoint[];
+    /** Group names in stable order */
+    groups: string[];
+    /** Points per group, in position order */
+    byGroup: Map<string, NavPoint[]>;
+    /** Precomputed node id → flat index lookup (for network navigation) */
+    idToIdx: Map<string, number>;
 }
+export interface NavPosition {
+    /** Index into NavGraph.flat */
+    flatIndex: number;
+    /** Current group name */
+    group: string;
+    /** Index within the current group */
+    indexInGroup: number;
+}
+/**
+ * Build a navigation graph from grouped NavPoints.
+ * Points within each group are sorted by x then y.
+ * Groups are sorted by their first-point y position (top to bottom).
+ */
+export declare function buildNavGraph(points: NavPoint[]): NavGraph;
+/**
+ * Resolve the current NavPosition from a flat index.
+ * Clamps to valid range if the index is stale (e.g. scene changed between key presses).
+ */
+export declare function resolvePosition(graph: NavGraph, flatIndex: number): NavPosition;
+/**
+ * Compute the next navigation position given a key press and current position.
+ * Returns the flat index into graph.flat, -1 to clear, or null for unhandled keys.
+ */
+export declare function nextGraphIndex(key: string, pos: NavPosition, graph: NavGraph): number | null;
 /**
  * Extract navigable data points from XY scene nodes.
- * Points/rects yield one point each. Lines/areas yield their path points
- * paired with the underlying data. Sorted left-to-right by x.
+ * Lines/areas carry a `group` field identifying the series.
+ * ArrowRight/Left = within series, ArrowUp/Down = switch series.
  */
 export declare function extractXYNavPoints(scene: any[]): NavPoint[];
 /**
  * Extract navigable points from ordinal scene nodes.
- * Sorted left-to-right (horizontal) or top-to-bottom (vertical).
+ * Bars use `node.group` (stack/group key) falling back to `datum.category`.
+ * ArrowRight/Left = across categories, ArrowUp/Down = within stacked segments.
  */
 export declare function extractOrdinalNavPoints(scene: any[]): NavPoint[];
 /**
  * Extract navigable points from network scene nodes.
- * Node-only (edges are not individually navigable).
+ * Each node's group is its own id, enabling neighbor traversal via edges.
  */
 export declare function extractNetworkNavPoints(scene: any[]): NavPoint[];
+/**
+ * Network-specific navigation: spatial arrow keys + edge following.
+ *
+ * ArrowRight/Left/Up/Down: move to the nearest node in that direction.
+ * Enter: follow an edge to a connected neighbor of the current node.
+ * PageUp/Down, Home/End, Escape: flat navigation.
+ *
+ * Returns the flat index of the target node, -1 to clear, or null for unhandled keys.
+ */
+export declare function nextNetworkIndex(key: string, pos: NavPosition, graph: NavGraph, edges: any[], neighborIndexRef: {
+    current: number;
+}): number | null;
+/**
+ * Extract navigable points from geo scene nodes.
+ * Flat navigation only (no meaningful grouping for geo).
+ */
+export declare function extractGeoNavPoints(scene: any[]): NavPoint[];
 /**
  * Compute the next focus index given a key and current index.
- * Returns -1 to clear focus.
+ * Returns -1 to clear focus. Returns null for unhandled keys.
+ *
+ * Used by Geo frame (flat navigation) and as fallback.
  */
 export declare function nextIndex(key: string, current: number, total: number): number | null;
 /**

package/dist/components/stream/layouts/hierarchySceneBuilders.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Scene builders for hierarchy layouts (tree, treemap, circlepack).
+ *
+ * Converts RealtimeNode/Edge arrays (positioned by d3-hierarchy) into
+ * NetworkSceneNode/Edge arrays for canvas rendering.
+ *
+ * Three builder functions, one per visual form:
+ *   buildTreeScene    — circle nodes + curved edges (tree/cluster)
+ *   buildRectScene    — rect nodes, no edges (treemap/partition)
+ *   buildCircleScene  — circle nodes, no edges (circlepack)
+ *
+ * Dependencies: hierarchyUtils (palette, contrast, label resolution)
+ * Consumed by: hierarchyLayoutPlugin.ts (buildScene dispatcher)
+ */
+import type { NetworkPipelineConfig, NetworkSceneNode, NetworkSceneEdge, NetworkLabel, RealtimeNode, RealtimeEdge } from "../networkTypes";
+export declare function buildTreeScene(nodes: RealtimeNode[], edges: RealtimeEdge[], config: NetworkPipelineConfig, size: [number, number], nodeStyleFn: (d: any) => Record<string, any>, edgeStyleFn: (d: any) => Record<string, any>): {
+    sceneNodes: NetworkSceneNode[];
+    sceneEdges: NetworkSceneEdge[];
+    labels: NetworkLabel[];
+};
+export declare function buildRectScene(nodes: RealtimeNode[], config: NetworkPipelineConfig, size: [number, number], nodeStyleFn: (d: any) => Record<string, any>): {
+    sceneNodes: NetworkSceneNode[];
+    sceneEdges: NetworkSceneEdge[];
+    labels: NetworkLabel[];
+};
+export declare function buildCircleScene(nodes: RealtimeNode[], config: NetworkPipelineConfig, size: [number, number], nodeStyleFn: (d: any) => Record<string, any>): {
+    sceneNodes: NetworkSceneNode[];
+    sceneEdges: NetworkSceneEdge[];
+    labels: NetworkLabel[];
+};
+/**
+ * Generate a cubic bezier path string for a tree/cluster edge.
+ * Uses different curve strategies based on tree orientation.
+ */
+export declare function generateTreeEdgePath(sx: number, sy: number, tx: number, ty: number, orientation: string): string;

package/dist/components/stream/layouts/hierarchyUtils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared utilities for hierarchy layout plugins.
+ *
+ * CSS color parsing, contrast text, depth palette, and accessor resolution
+ * used across tree, treemap, and circlepack scene builders.
+ *
+ * Consumed by: hierarchyLayoutPlugin.ts, hierarchySceneBuilders.ts
+ */
+import type { NetworkPipelineConfig } from "../networkTypes";
+/** Depth-based color palette shared across all hierarchy scene builders */
+export declare const DEPTH_PALETTE: string[];
+/**
+ * Parse a CSS color string (hex or rgb/rgba) into [r, g, b].
+ * Falls back to mid-gray if the format is unrecognized.
+ */
+export declare function parseColor(color: string): [number, number, number];
+/**
+ * Return a high-contrast text color (white or near-black) for the given background.
+ * Uses perceived luminance (ITU-R BT.601).
+ */
+export declare function contrastTextColor(bgColor: string): string;
+export declare function resolveChildrenAccessor(accessor: string | ((d: any) => any[]) | undefined): ((d: any) => any[]) | undefined;
+export declare function resolveNodeId(d: any, config: NetworkPipelineConfig, index: number): string;
+export declare function resolveLabelFn(nodeLabel: string | ((d: any) => string) | undefined): ((d: any) => string) | null;
+export declare function resolveDefaultNodeSize(nodeSize: number | string | ((d: any) => number) | undefined): number;

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

@@ -440,8 +440,12 @@ export interface StreamNetworkFrameProps<T = Record<string, any>> {
     orbitEccentricity?: number | ((node: any) => number);
     orbitShowRings?: boolean;
     orbitAnimated?: boolean;
-    /** Render a visually-hidden data table from the scene graph for screen readers (first 50 rows) */
+    /** Render a visually-hidden data table from the scene graph for screen readers */
     accessibleTable?: boolean;
+    /** Accessible description overriding the auto-generated aria-label on the chart container */
+    description?: string;
+    /** Accessible summary rendered as a screen-reader-only note */
+    summary?: string;
 }
 export interface StreamNetworkFrameHandle {
     push(edge: EdgePush): void;

package/dist/components/stream/ordinalSceneBuilders/swimlaneScene.d.ts

@@ -0,0 +1,12 @@
+import type { OrdinalSceneNode, OrdinalLayout } from "../ordinalTypes";
+import type { OrdinalSceneContext } from "./types";
+/**
+ * Swimlane scene builder.
+ *
+ * Each category (oAccessor) defines a horizontal lane.
+ * Items within a lane are stacked left-to-right (or bottom-to-top in vertical),
+ * colored by subcategory (stackBy/colorBy). Unlike a standard stacked bar,
+ * multiple items with the same subcategory can appear in the same lane —
+ * they simply stack sequentially.
+ */
+export declare function buildSwimlaneScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];

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

@@ -3,7 +3,7 @@ import type { ScaleLinear, ScaleBand } from "d3-scale";
 import type { ArrowOfTime, WindowMode, HoverAnnotationConfig, HoverData, AnnotationContext } from "../realtime/types";
 import type { Style, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig } from "./types";
 import type { LegendGroup } from "../types/legendTypes";
-export type OrdinalChartType = "bar" | "clusterbar" | "point" | "swarm" | "pie" | "donut" | "boxplot" | "violin" | "histogram" | "ridgeline" | "timeline" | "funnel" | "bar-funnel";
+export type OrdinalChartType = "bar" | "clusterbar" | "point" | "swarm" | "pie" | "donut" | "boxplot" | "violin" | "histogram" | "ridgeline" | "timeline" | "funnel" | "bar-funnel" | "swimlane";
 export interface OrdinalScales {
     o: ScaleBand<string>;
     r: ScaleLinear<number, number>;
@@ -219,7 +219,7 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
     showCategoryTicks?: boolean;
     oLabel?: string;
     rLabel?: string;
-    oFormat?: (d: string) => string;
+    oFormat?: (d: string, index?: number) => string;
     rFormat?: (d: number | string) => string;
     enableHover?: boolean;
     hoverAnnotation?: boolean | HoverAnnotationConfig;
@@ -248,12 +248,24 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
     className?: string;
     background?: string;
     centerContent?: ReactNode;
+    /** Brush configuration. "r" brushes the value axis. */
+    brush?: boolean | "r" | {
+        dimension?: "r";
+    };
+    /** Callback when brush selection changes. Extent is in data coordinates, or null when cleared. */
+    onBrush?: (extent: {
+        r: [number, number];
+    } | null) => void;
     decay?: DecayConfig;
     pulse?: PulseConfig;
     transition?: TransitionConfig;
     staleness?: StalenessConfig;
-    /** Render a visually-hidden data table from the scene graph for screen readers (first 50 rows) */
+    /** Render a visually-hidden data table from the scene graph for screen readers */
     accessibleTable?: boolean;
+    /** Accessible description overriding the auto-generated aria-label on the chart container */
+    description?: string;
+    /** Accessible summary rendered as a screen-reader-only note */
+    summary?: string;
 }
 export interface StreamOrdinalFrameHandle<T = Record<string, any>> {
     push(datum: T): void;

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

@@ -0,0 +1,20 @@
+/**
+ * Decay encoding for XY pipeline scene nodes.
+ *
+ * Applies age-based opacity fade to scene nodes — linear, exponential, or step.
+ * Per-vertex decay for line/area nodes, uniform for discrete nodes (point, rect, etc.).
+ *
+ * Dependencies: types (SceneNode, DecayConfig)
+ * Consumed by: PipelineStore.computeScene (after scene build, before transitions)
+ */
+import type { SceneNode, DecayConfig } from "./types";
+/**
+ * Compute decay opacity for a datum at `bufferIndex` out of `bufferSize` items.
+ * Index 0 = oldest, bufferSize-1 = newest. Returns 0–1.
+ */
+export declare function computeDecayOpacity(decay: DecayConfig, bufferIndex: number, bufferSize: number): number;
+/**
+ * Apply decay opacity to a list of scene nodes.
+ * Uses the datum's index in the buffer data array.
+ */
+export declare function applyDecay(decay: DecayConfig, nodes: SceneNode[], data: Record<string, any>[]): void;

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

@@ -0,0 +1,24 @@
+/**
+ * Pulse encoding for XY pipeline scene nodes.
+ *
+ * Applies time-based glow to recently-inserted data points. Intensity fades
+ * from 1 (just inserted) to 0 (pulse expired) over a configurable duration.
+ *
+ * Dependencies: types (SceneNode, PulseConfig), RingBuffer (timestamp buffer)
+ * Consumed by: PipelineStore.computeScene (after decay, before transitions)
+ */
+import type { SceneNode, PulseConfig } from "./types";
+import type { RingBuffer } from "../realtime/RingBuffer";
+/**
+ * Compute pulse intensity for a datum inserted at `insertTime`.
+ * Returns 0–1 (1 = just inserted, 0 = pulse expired).
+ */
+export declare function computePulseIntensity(pulse: PulseConfig, insertTime: number, now: number): number;
+/**
+ * Apply pulse glow to scene nodes using insertion timestamps.
+ */
+export declare function applyPulse(pulse: PulseConfig, nodes: SceneNode[], data: Record<string, any>[], timestampBuffer: RingBuffer<number>): void;
+/**
+ * Check whether there are active pulse animations needing continuous rendering.
+ */
+export declare function hasActivePulses(pulse: PulseConfig, timestampBuffer: RingBuffer<number> | null): boolean;

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

@@ -0,0 +1,59 @@
+/**
+ * Transition animation for XY pipeline scene nodes.
+ *
+ * Handles identity-based enter/update/exit transitions:
+ *   - snapshotPositions: captures current scene state before rebuild
+ *   - getNodeIdentity: stable key generation per node type
+ *   - startTransition: sets up interpolation from old→new positions
+ *   - advanceTransition: per-frame tick with easing
+ *
+ * Dependencies: pipelineTransitionUtils (lerp, easing, ActiveTransition)
+ * Consumed by: PipelineStore.computeScene (after decay/pulse)
+ */
+import type { SceneNode, TransitionConfig } from "./types";
+import type { ActiveTransition } from "./pipelineTransitionUtils";
+export type PrevPosition = {
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    r?: number;
+    opacity?: number;
+};
+export type PrevPath = {
+    topPath?: [number, number][];
+    bottomPath?: [number, number][];
+    path?: [number, number][];
+    opacity?: number;
+};
+/** Context needed from PipelineStore for identity resolution */
+export interface TransitionContext {
+    runtimeMode?: "streaming" | "bounded";
+    getX: (d: any) => number;
+    getY: (d: any) => number;
+    getCategory?: (d: any) => string;
+}
+/**
+ * Get a stable identity key for a scene node.
+ */
+export declare function getNodeIdentity(ctx: TransitionContext, node: SceneNode, index: number): string | null;
+/**
+ * Snapshot current scene node positions before rebuild.
+ */
+export declare function snapshotPositions(ctx: TransitionContext, scene: SceneNode[], prevPositionMap: Map<string, PrevPosition>, prevPathMap: Map<string, PrevPath>): void;
+export interface TransitionState {
+    scene: SceneNode[];
+    exitNodes: SceneNode[];
+    activeTransition: ActiveTransition | null;
+}
+/**
+ * After scene rebuild, set up transition from old to new positions.
+ * Detects entering nodes (new, no prev match) and exiting nodes (prev, no new match).
+ * Mutates scene and exitNodes in place. Returns updated state.
+ */
+export declare function startTransition(ctx: TransitionContext, transition: TransitionConfig, state: TransitionState, prevPositionMap: Map<string, PrevPosition>, prevPathMap: Map<string, PrevPath>): TransitionState;
+/**
+ * Advance the transition animation. Returns true if still animating.
+ * Mutates scene nodes in place.
+ */
+export declare function advanceTransition(now: number, transition: TransitionConfig, state: TransitionState, prevPositionMap: Map<string, PrevPosition>, prevPathMap: Map<string, PrevPath>): boolean;

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

@@ -1,7 +1,8 @@
 import type { StreamRendererFn } from "./types";
 /**
  * Canvas point renderer.
- * Renders PointSceneNode as circles. Used for Scatterplot, BubbleChart, and SwarmChart.
+ * Renders PointSceneNode as circles. Used by Scatterplot, BubbleChart, SwarmChart,
+ * and showPoints on LineChart, AreaChart, and StackedAreaChart.
  * Supports pulse glow effect via _pulseIntensity/_pulseColor fields.
  */
 export declare const pointCanvasRenderer: StreamRendererFn;

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

@@ -92,6 +92,8 @@ export interface LineSceneNode {
     _decayOpacities?: number[];
     /** Animation target opacity (set during enter/exit transitions) */
     _targetOpacity?: number;
+    /** Captured start opacity for linear interpolation (avoids compounding from per-tick mutation) */
+    _startOpacity?: number;
     /** Stable identity key for transition tracking */
     _transitionKey?: string;
     /** Previous path coordinates for interpolation during transitions */
@@ -123,6 +125,8 @@ export interface AreaSceneNode {
     _decayOpacities?: number[];
     /** Animation target opacity (set during enter/exit transitions) */
     _targetOpacity?: number;
+    /** Captured start opacity for linear interpolation (avoids compounding from per-tick mutation) */
+    _startOpacity?: number;
     /** Stable identity key for transition tracking */
     _transitionKey?: string;
     /** Previous top path coordinates for interpolation during transitions */
@@ -363,6 +367,12 @@ export interface StreamXYFrameProps<T = Record<string, any>> {
     brush?: {
         /** Which dimension(s) to brush: "x", "y", or "xy" (default "xy") */
         dimension?: "x" | "y" | "xy";
+        /** Snap mode: "continuous" (default) for pixel-precise, "bin" to snap to bin boundaries */
+        snap?: "continuous" | "bin";
+        /** Actual bin boundary values for data-driven snapping (overrides uniform grid math) */
+        binBoundaries?: number[];
+        /** When true, snap during drag (not just on release). Default false. */
+        snapDuring?: boolean;
     };
     /** Callback when brush selection changes. Called with data-space extent, or null when cleared. */
     onBrush?: (extent: {
@@ -418,8 +428,16 @@ export interface StreamXYFrameProps<T = Record<string, any>> {
     showValues?: boolean;
     /** Format function for heatmap cell value labels */
     heatmapValueFormat?: (v: number) => string;
-    /** Render a visually-hidden data table from the scene graph for screen readers (first 50 rows) */
+    /** Render a visually-hidden data table from the scene graph for screen readers */
     accessibleTable?: boolean;
+    /** Accessible description overriding the auto-generated aria-label on the chart container */
+    description?: string;
+    /** Accessible summary rendered as a screen-reader-only note */
+    summary?: string;
+    /** Name of the linked crosshair store entry — enables coordinate-based crosshair rendering */
+    linkedCrosshairName?: string;
+    /** Source chart ID — crosshair is suppressed on the source chart to avoid double rendering */
+    linkedCrosshairSourceId?: string;
 }
 export interface StreamXYFrameHandle<T = Record<string, any>> {
     push(datum: T): void;

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

@@ -0,0 +1,11 @@
+/** Safari 14 fallback for MediaQueryList listener registration */
+export declare function addMqlListener(mql: MediaQueryList, handler: (e: MediaQueryListEvent) => void): () => void;
+/**
+ * SSR-safe hook that returns true when the user prefers reduced motion.
+ * Initializes from matchMedia synchronously to avoid a flash of animation.
+ */
+export declare function useReducedMotion(): boolean;
+/**
+ * SSR-safe hook that returns true when forced-colors or high-contrast mode is active.
+ */
+export declare function useHighContrast(): boolean;

package/dist/components/stream/xySceneBuilders/areaScene.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Area and stacked area scene builders.
+ *
+ * buildAreaScene — single/multi-group areas with gradient fill and curve support.
+ * buildStackedAreaScene — stable-order stacking with optional normalization.
+ *
+ * Dependencies: SceneGraph (buildAreaNode, buildStackedAreaNodes)
+ * Consumed by: PipelineStore.buildSceneNodes (chartTypes "area", "stackedarea")
+ */
+import type { SceneNode } from "../types";
+import type { XYSceneContext } from "./types";
+export declare function buildAreaScene(ctx: XYSceneContext, data: Record<string, any>[]): SceneNode[];
+export declare function buildStackedAreaScene(ctx: XYSceneContext, data: Record<string, any>[]): SceneNode[];

package/dist/components/stream/xySceneBuilders/barScene.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Realtime histogram bar scene builder.
+ *
+ * Builds binned bars with optional category stacking. Maintains stable
+ * category order via barColors keys + alphabetical fallback to prevent
+ * flicker when bins partially exit the sliding window.
+ *
+ * Dependencies: BinAccumulator (computeBins), SceneGraph (buildRectNode)
+ * Consumed by: PipelineStore.buildSceneNodes (chartType "bar")
+ */
+import type { SceneNode } from "../types";
+import type { XYSceneContext } from "./types";
+export interface BarSceneResult {
+    nodes: SceneNode[];
+    /** Sorted bin boundary values (edges of all bins) for data-driven brush snapping */
+    binBoundaries: number[];
+}
+export declare function buildBarScene(ctx: XYSceneContext, data: Record<string, any>[]): BarSceneResult;

package/dist/components/stream/xySceneBuilders/boundsScene.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bounds scene builder — produces an AreaSceneNode for confidence bands/envelopes.
+ *
+ * Consumed by: lineScene (renders bounds behind lines)
+ */
+import type { AreaSceneNode } from "../types";
+import type { XYSceneContext } from "./types";
+export declare function buildBoundsForGroup(ctx: XYSceneContext, data: Record<string, any>[], group: string): AreaSceneNode | null;