semiotic 3.2.3 → 3.3.1

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

@@ -0,0 +1,39 @@
+/**
+ * Static legend rendering for server-side SVG.
+ *
+ * Builds legend SVG elements from data + colorScheme without React hooks.
+ * Used by renderToStaticSVG when showLegend is true.
+ */
+import * as React from "react";
+import type { SemioticTheme } from "../store/ThemeStore";
+export interface StaticLegendConfig {
+    /** Category labels to show in legend */
+    categories: string[];
+    /** Color scheme — array of colors or d3-scale-chromatic name */
+    colorScheme?: string | string[];
+    /** Theme for text/font colors */
+    theme: SemioticTheme;
+    /** Legend position */
+    position?: "right" | "left" | "top" | "bottom";
+    /** Chart dimensions for positioning */
+    totalWidth: number;
+    totalHeight: number;
+    /** Chart margins */
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /** Title presence (affects top-position offset) */
+    hasTitle?: boolean;
+}
+/**
+ * Render a static legend as SVG elements.
+ * Returns null if no categories to show.
+ */
+export declare function renderStaticLegend(config: StaticLegendConfig): React.ReactNode;
+/**
+ * Extract unique categories from data using an accessor.
+ */
+export declare function extractCategories(data: any[], accessor: string | ((d: any) => string) | undefined): string[];

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

@@ -0,0 +1,26 @@
+/**
+ * SVG hatch pattern for server-side rendering.
+ *
+ * Creates a <pattern> element that can be referenced via url(#id) fill.
+ * The SVG equivalent of createHatchPattern() which produces CanvasPatterns.
+ */
+import * as React from "react";
+export interface SVGHatchOptions {
+    /** Pattern ID — must be unique within the SVG */
+    id: string;
+    /** Background color */
+    background?: string;
+    /** Line color */
+    stroke?: string;
+    /** Line width @default 1.5 */
+    lineWidth?: number;
+    /** Spacing between lines @default 6 */
+    spacing?: number;
+    /** Angle in degrees @default 45 */
+    angle?: number;
+}
+/**
+ * Create an SVG <pattern> element for diagonal hatch fills.
+ * Place inside <defs> and reference with fill="url(#id)".
+ */
+export declare function createSVGHatchPattern(options: SVGHatchOptions): React.ReactElement;

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

@@ -0,0 +1,39 @@
+/**
+ * Theme resolution for server-side rendering.
+ *
+ * Resolves theme presets and partial theme objects to concrete
+ * SemioticTheme instances with all color/font values resolved.
+ * No CSS custom properties — everything is concrete for inline SVG.
+ */
+import type { SemioticTheme } from "../store/ThemeStore";
+export type ThemeInput = string | Partial<SemioticTheme> | undefined;
+/**
+ * Resolve a theme input to a full SemioticTheme object.
+ *
+ * - undefined → LIGHT_THEME
+ * - string → named preset ("dark", "tufte", "carbon-dark", etc.)
+ * - object with mode → merge onto matching base theme
+ * - object without mode → merge onto LIGHT_THEME
+ */
+export declare function resolveTheme(theme: ThemeInput): SemioticTheme;
+/**
+ * Extract concrete style values from a resolved theme for use in SVG attributes.
+ * Returns a flat object of commonly-needed values.
+ */
+export declare function themeStyles(theme: SemioticTheme): {
+    background: string;
+    text: string;
+    textSecondary: string;
+    grid: string;
+    border: string;
+    primary: string;
+    fontFamily: string;
+    titleSize: number;
+    labelSize: number;
+    tickSize: number;
+    categorical: string[];
+    annotation: string;
+    legendSize: number;
+    titleFontSize: number;
+    tickFontFamily: string;
+};

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

@@ -16,12 +16,20 @@ export interface SemioticTheme {
         selection?: string;
         /** Opacity for non-selected (dimmed) elements, 0–1 */
         selectionOpacity?: number;
+        /** Default annotation text/marker color. Falls back to `text` if unset. */
+        annotation?: string;
     };
     typography: {
         fontFamily: string;
         titleSize: number;
         labelSize: number;
         tickSize: number;
+        /** Font size for legend text. Falls back to `labelSize` if unset. */
+        legendSize?: number;
+        /** Font family for axis tick labels. Use monospace for aligned numerics. Falls back to `fontFamily`. */
+        tickFontFamily?: string;
+        /** Font size for chart title. Falls back to `titleSize` if unset. */
+        titleFontSize?: number;
     };
     tooltip?: {
         background?: string;
@@ -31,6 +39,12 @@ export interface SemioticTheme {
         shadow?: string;
     };
     borderRadius?: string;
+    accessibility?: {
+        /** Auto-swap to color-blind safe palette when true */
+        colorBlindSafe?: boolean;
+        /** Enforce minimum 3:1 contrast ratios */
+        highContrast?: boolean;
+    };
 }
 /** Color-blind safe categorical palette (8 colors).
  *  Derived from Wong (2011) "Points of view: Color blindness" — safe for

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

@@ -39,6 +39,11 @@ export declare class GeoPipelineStore {
     pushPoint(datum: Record<string, any>): void;
     /** Push multiple streaming points */
     pushMany(data: Record<string, any>[]): void;
+    /**
+     * Remove points by ID. Requires pointIdAccessor to be configured.
+     * Returns the removed items.
+     */
+    removePoint(id: string | string[]): Record<string, any>[];
     clear(): void;
     computeScene(layout: StreamLayout): void;
     private fitProjection;
@@ -70,7 +75,7 @@ export declare class GeoPipelineStore {
         scale: number;
         translate: [number, number];
     };
-    private getPoints;
+    getPoints(): Record<string, any>[];
     private buildSceneNodes;
     private applyCartogramTransform;
     private applyDecay;

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

@@ -126,5 +126,31 @@ export declare class NetworkPipelineStore {
         nodes: RealtimeNode[];
         edges: RealtimeEdge[];
     };
+    /**
+     * Update a node's data by ID. Returns the previous data, or null if not found.
+     */
+    updateNode(id: string, updater: (data: Record<string, any>) => Record<string, any>): Record<string, any> | null;
+    /**
+     * Update all edges between source and target. Handles parallel edges.
+     * Returns array of previous data values (one per updated edge), or empty array.
+     */
+    updateEdge(sourceId: string, targetId: string, updater: (data: Record<string, any>) => Record<string, any>): Record<string, any>[];
+    /**
+     * Remove a node by ID. Also removes all edges connected to this node.
+     * Returns true if the node was found and removed.
+     */
+    removeNode(id: string): boolean;
+    /**
+     * Remove all edges between source and target node IDs.
+     * Handles parallel edges (multiple edges between the same pair).
+     * Returns true if at least one edge was removed.
+     */
+    /**
+     * Remove edges by source+target IDs, or by edge ID when edgeIdAccessor is configured.
+     *
+     * - `removeEdge(sourceId, targetId)` — removes all parallel edges between endpoints
+     * - `removeEdge(edgeId)` — removes the edge matching edgeIdAccessor (requires config.edgeIdAccessor)
+     */
+    removeEdge(sourceIdOrEdgeId: string, targetId?: string): boolean;
     clear(): void;
 }

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

@@ -32,6 +32,7 @@ export declare class OrdinalPipelineStore {
     private getGroup;
     private getColor;
     private getConnector;
+    private getDataId;
     /** Discovered categories in insertion order */
     private categories;
     /** True once a non-bounded (push) changeset has been ingested */
@@ -77,6 +78,16 @@ export declare class OrdinalPipelineStore {
     private startTransition;
     advanceTransition(now: number): boolean;
     getData(): Record<string, any>[];
+    /**
+     * Remove data items by ID. Requires dataIdAccessor to be configured.
+     * Returns the removed items. Marks the store dirty for scene rebuild.
+     */
+    remove(id: string | string[]): Record<string, any>[];
+    /**
+     * Update data items by ID. Requires dataIdAccessor.
+     * Returns the previous values. Categories and extents are rebuilt.
+     */
+    update(id: string | string[], updater: (d: Record<string, any>) => Record<string, any>): Record<string, any>[];
     clear(): void;
     get size(): number;
     getOAccessor(): (d: any) => string;

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

@@ -21,6 +21,10 @@ interface OrdinalSVGOverlayProps {
     rLabel?: string;
     oFormat?: (d: string, index?: number) => string | React.ReactNode;
     rFormat?: (d: number) => string;
+    /** Custom tick values for the value (r) axis */
+    rTickValues?: number[];
+    /** Align first tick label to start, last to end */
+    tickLabelEdgeAlign?: boolean;
     showGrid?: boolean;
     title?: string | ReactNode;
     legend?: ReactNode | {
@@ -63,6 +67,7 @@ interface OrdinalSVGUnderlayProps {
     showAxes?: boolean;
     showGrid?: boolean;
     rFormat?: (d: number) => string;
+    rTickValues?: number[];
 }
 export declare function OrdinalSVGUnderlay(props: OrdinalSVGUnderlayProps): React.JSX.Element | null;
 export declare function OrdinalSVGOverlay(props: OrdinalSVGOverlayProps): React.JSX.Element | null;

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

@@ -197,6 +197,17 @@ export declare class PipelineStore {
      */
     private getBufferArray;
     getData(): Record<string, any>[];
+    /**
+     * Remove data points by ID. Requires pointIdAccessor to be configured.
+     * Returns the removed items. Marks the store dirty for scene rebuild.
+     */
+    remove(id: string | string[]): Record<string, any>[];
+    /**
+     * Update data points by ID. Requires pointIdAccessor.
+     * The updater receives the current datum and returns the replacement.
+     * Returns the previous values. Extents and scene are marked dirty.
+     */
+    update(id: string | string[], updater: (d: Record<string, any>) => Record<string, any>): 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(): {

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

@@ -12,6 +12,6 @@
  * 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>(accessor: string | ((d: T) => number) | undefined, fallback: string): (d: T) => number;
-export declare function resolveRawAccessor<T>(accessor: string | ((d: T) => any) | undefined, fallback: string): (d: T) => any;
-export declare function resolveStringAccessor<T>(accessor: string | ((d: T) => string) | undefined, fallback?: string): ((d: T) => string) | undefined;
+export declare function resolveAccessor<T extends Record<string, unknown>>(accessor: string | ((d: T) => number) | 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/geoTypes.d.ts

@@ -1,7 +1,7 @@
 import type { ReactNode } from "react";
 import type { GeoProjection, GeoPath, GeoPermissibleObjects } from "d3-geo";
 import type { Style, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig, PointSceneNode, LineSceneNode } from "./types";
-import type { HoverAnnotationConfig } from "../realtime/types";
+import type { HoverAnnotationConfig, HoverData } from "../realtime/types";
 import type { GeoParticleStyle } from "./GeoParticlePool";
 export type ProjectionProp = GeoProjection | ProjectionName | ProjectionConfig;
 export type ProjectionName = "mercator" | "equalEarth" | "albersUsa" | "orthographic" | "naturalEarth" | "equirectangular";
@@ -139,9 +139,9 @@ export interface StreamGeoFrameProps<T = Record<string, any>> {
     colorScheme?: string | string[];
     enableHover?: boolean;
     hoverAnnotation?: boolean | HoverAnnotationConfig;
-    tooltipContent?: (d: any) => ReactNode;
-    customClickBehavior?: (d: any) => void;
-    customHoverBehavior?: (d: any) => void;
+    tooltipContent?: (d: HoverData) => ReactNode;
+    customClickBehavior?: (d: HoverData | null) => void;
+    customHoverBehavior?: (d: HoverData | null) => void;
     annotations?: Record<string, any>[];
     decay?: DecayConfig;
     pulse?: PulseConfig;
@@ -171,6 +171,8 @@ export interface StreamGeoFrameProps<T = Record<string, any>> {
 export interface StreamGeoFrameHandle {
     push(datum: Record<string, any>): void;
     pushMany(data: Record<string, any>[]): void;
+    /** Remove points by ID. Requires pointIdAccessor. */
+    removePoint(id: string | string[]): Record<string, any>[];
     clear(): void;
     getProjection(): GeoProjection | null;
     getGeoPath(): GeoPath<any, GeoPermissibleObjects> | null;

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

@@ -0,0 +1,22 @@
+/**
+ * Shared hover data utilities for stream frames.
+ *
+ * Centralizes the common HoverData construction pattern used by
+ * XY, Ordinal, and Network stream frames for hover and click events.
+ * Geo frame and keyboard navigation use variants with additional
+ * property flattening that are handled at the call site.
+ */
+import type { HoverData } from "../realtime/types";
+/**
+ * Spread raw datum properties onto HoverData if it's a non-null,
+ * non-array object. Class instances (Date, etc.) are included —
+ * this matches the historical behavior where all datum fields are
+ * accessible directly on the hover object (d.fieldName).
+ */
+export declare function spreadDatum(rawDatum: any): Record<string, any>;
+/**
+ * Build a HoverData object from a raw datum and pixel coordinates.
+ * Spreads plain-object datum properties for backwards compatibility
+ * (consumers can access d.fieldName directly in addition to d.data.fieldName).
+ */
+export declare function buildHoverData(rawDatum: any, x: number, y: number, extra?: Partial<HoverData>): HoverData;

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

@@ -35,6 +35,9 @@ export interface RealtimeNode {
     createdByFrame?: boolean;
     sourceLinks?: RealtimeEdge[];
     targetLinks?: RealtimeEdge[];
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+    _pulseGlowRadius?: number;
 }
 export interface RealtimeEdge {
     source: RealtimeNode | string;
@@ -56,6 +59,12 @@ export interface RealtimeEdge {
     data?: Record<string, any>;
     /** Unique key for this edge (supports parallel edges between same node pair) */
     _edgeKey?: string;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+    _pulseGlowRadius?: number;
+    /** @internal Circular sankey layout fields */
+    _circularWidth?: number;
+    _circularStub?: boolean;
 }
 export interface BezierPoint {
     x: number;
@@ -159,18 +168,24 @@ export interface NetworkRectNode {
     _pulseGlowRadius?: number;
 }
 /** Arc node — used by chord */
+/** Arc node — used by chord. Angles in canvas convention (0 = 3 o'clock). */
 export interface NetworkArcNode {
     type: "arc";
     cx: number;
     cy: number;
     innerR: number;
     outerR: number;
+    /** Start angle in radians, canvas convention (0 = 3 o'clock, positive = clockwise) */
     startAngle: number;
+    /** End angle in radians, canvas convention */
     endAngle: number;
     style: Style;
     datum: any;
     id?: string;
     label?: string;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+    _pulseGlowRadius?: number;
 }
 /** Line edge — used by force */
 export interface NetworkLineEdge {
@@ -200,6 +215,8 @@ export interface NetworkRibbonEdge {
     pathD: string;
     style: Style;
     datum: any;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
 }
 /** Curved edge — used by tree, cluster */
 export interface NetworkCurvedEdge {
@@ -207,6 +224,8 @@ export interface NetworkCurvedEdge {
     pathD: string;
     style: Style;
     datum: any;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
 }
 export type NetworkSceneNode = NetworkCircleNode | NetworkRectNode | NetworkArcNode;
 export type NetworkSceneEdge = NetworkLineEdge | NetworkBezierEdge | NetworkRibbonEdge | NetworkCurvedEdge;
@@ -274,8 +293,10 @@ export interface NetworkPipelineConfig {
     sourceAccessor?: string | ((d: any) => string);
     targetAccessor?: string | ((d: any) => string);
     valueAccessor?: string | ((d: any) => number);
+    /** Edge ID accessor for removeEdge(edgeId) — enables single-ID edge removal */
+    edgeIdAccessor?: string | ((d: any) => string);
     childrenAccessor?: string | ((d: any) => any[]);
-    hierarchySum?: (d: any) => number;
+    hierarchySum?: string | ((d: any) => number);
     orientation?: "horizontal" | "vertical";
     nodeAlign?: "justify" | "left" | "right" | "center";
     nodePaddingRatio?: number;
@@ -333,6 +354,15 @@ export interface NetworkPipelineConfig {
     orbitShowRings?: boolean;
     /** Enable orbit animation. @default true */
     orbitAnimated?: boolean;
+    /** @internal Hierarchy root stashed for tree/treemap/circlepack plugins */
+    __hierarchyRoot?: unknown;
+    /** @internal Orbit animation state preserved across config updates */
+    __orbitState?: unknown;
+    /** @internal Previous node positions for warm-start force layout */
+    __previousPositions?: Map<string, {
+        x: number;
+        y: number;
+    }>;
 }
 export interface StreamNetworkFrameProps<T = Record<string, any>> {
     chartType: NetworkChartType;
@@ -345,8 +375,10 @@ export interface StreamNetworkFrameProps<T = Record<string, any>> {
     sourceAccessor?: string | ((d: T) => string);
     targetAccessor?: string | ((d: T) => string);
     valueAccessor?: string | ((d: T) => number);
+    /** Edge ID accessor for removeEdge(edgeId) single-ID removal */
+    edgeIdAccessor?: string | ((d: any) => string);
     childrenAccessor?: string | ((d: T) => T[]);
-    hierarchySum?: (d: T) => number;
+    hierarchySum?: string | ((d: T) => number);
     orientation?: "horizontal" | "vertical";
     nodeAlign?: "justify" | "left" | "right" | "center";
     nodePaddingRatio?: number;
@@ -388,24 +420,9 @@ export interface StreamNetworkFrameProps<T = Record<string, any>> {
     className?: string;
     background?: string;
     enableHover?: boolean;
-    tooltipContent?: (d: {
-        type: "node" | "edge";
-        data: any;
-        x: number;
-        y: number;
-    }) => ReactNode;
-    customHoverBehavior?: (d: {
-        type: "node" | "edge";
-        data: any;
-        x: number;
-        y: number;
-    } | null) => void;
-    customClickBehavior?: (d: {
-        type: "node" | "edge";
-        data: any;
-        x: number;
-        y: number;
-    } | null) => void;
+    tooltipContent?: (d: HoverData) => ReactNode;
+    customHoverBehavior?: (d: HoverData | null) => void;
+    customClickBehavior?: (d: HoverData | null) => void;
     /** Observation callback — emits hover/click events to the ObservationStore and this callback */
     onObservation?: OnObservationCallback;
     /** Chart instance identifier for observation filtering */
@@ -450,6 +467,14 @@ export interface StreamNetworkFrameProps<T = Record<string, any>> {
 export interface StreamNetworkFrameHandle {
     push(edge: EdgePush): void;
     pushMany(edges: EdgePush[]): void;
+    /** Remove a node by ID. Also removes connected edges. */
+    removeNode(id: string): boolean;
+    /** Remove edges by source+target, or by edge ID when edgeIdAccessor is configured. */
+    removeEdge(sourceIdOrEdgeId: string, targetId?: string): boolean;
+    /** Update a node's data by ID. Returns previous data. */
+    updateNode(id: string, updater: (data: Record<string, any>) => Record<string, any>): Record<string, any> | null;
+    /** Update all edges between source+target. Returns array of previous data. */
+    updateEdge(sourceId: string, targetId: string, updater: (data: Record<string, any>) => Record<string, any>): Record<string, any>[];
     clear(): void;
     getTopology(): {
         nodes: RealtimeNode[];

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

@@ -15,17 +15,20 @@ export interface WedgeSceneNode {
     cy: number;
     innerRadius: number;
     outerRadius: number;
+    /** Start angle in radians, canvas convention (0 = 3 o'clock, positive = clockwise) */
     startAngle: number;
+    /** End angle in radians, canvas convention */
     endAngle: number;
+    /** Corner radius for rounded wedge arcs (d3-shape arc.cornerRadius) */
+    cornerRadius?: number;
     style: Style;
     datum: any;
     category?: string;
-    /** Pulse intensity 0–1 (set when aggregated category value changes) */
     _pulseIntensity?: number;
-    /** Pulse color */
     _pulseColor?: string;
-    /** Animation target opacity (set during enter/exit transitions) */
+    _pulseGlowRadius?: number;
     _targetOpacity?: number;
+    _transitionKey?: string;
 }
 export interface BoxplotSceneNode {
     type: "boxplot";
@@ -51,7 +54,11 @@ export interface BoxplotSceneNode {
         value: number;
         datum: any;
     }[];
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+    _pulseGlowRadius?: number;
     _targetOpacity?: number;
+    _transitionKey?: string;
 }
 export interface DistributionStats {
     n: number;
@@ -89,7 +96,11 @@ export interface ViolinSceneNode {
     style: Style;
     datum: any;
     category?: string;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+    _pulseGlowRadius?: number;
     _targetOpacity?: number;
+    _transitionKey?: string;
 }
 export interface ConnectorSceneNode {
     type: "connector";
@@ -100,7 +111,11 @@ export interface ConnectorSceneNode {
     style: Style;
     datum: any;
     group?: string;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+    _pulseGlowRadius?: number;
     _targetOpacity?: number;
+    _transitionKey?: string;
 }
 export interface TrapezoidSceneNode {
     type: "trapezoid";
@@ -109,7 +124,11 @@ export interface TrapezoidSceneNode {
     style: Style;
     datum: any;
     category?: string;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+    _pulseGlowRadius?: number;
     _targetOpacity?: number;
+    _transitionKey?: string;
 }
 export type { Style, PointSceneNode, RectSceneNode } from "./types";
 import type { PointSceneNode, RectSceneNode } from "./types";
@@ -146,9 +165,13 @@ export interface OrdinalPipelineConfig {
     rExtent?: [number?, number?];
     oExtent?: string[];
     barPadding?: number;
+    /** Rounded top corner radius for bar charts. Only the end away from the baseline is rounded. For stacked bars, only the topmost segment gets rounded. */
+    roundedTop?: number;
     /** When true, adds padding below the 0 baseline. When false (default), bars are flush with the axis line. */
     baselinePadding?: boolean;
     innerRadius?: number;
+    /** Corner radius for rounded wedge arcs (pie/donut) */
+    cornerRadius?: number;
     normalize?: boolean;
     startAngle?: number;
     /** Total arc sweep in degrees (default 360 = full circle). Used by GaugeChart for partial arcs. */
@@ -167,6 +190,8 @@ export interface OrdinalPipelineConfig {
     summaryStyle?: (d: any, category?: string) => Style;
     colorScheme?: string | string[];
     barColors?: Record<string, string>;
+    /** ID accessor for remove() — extracts a unique identifier from each datum */
+    dataIdAccessor?: string | ((d: any) => string);
     decay?: DecayConfig;
     pulse?: PulseConfig;
     transition?: TransitionConfig;
@@ -196,8 +221,10 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
         left?: number;
     };
     barPadding?: number;
+    roundedTop?: number;
     baselinePadding?: boolean;
     innerRadius?: number;
+    cornerRadius?: number;
     normalize?: boolean;
     startAngle?: number;
     sweepAngle?: number;
@@ -217,6 +244,12 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
     windowSize?: number;
     connectorAccessor?: string | ((d: T) => string);
     connectorStyle?: Style | ((d: any) => Style);
+    /** ID accessor for remove()/update() — extracts a unique identifier from each datum */
+    dataIdAccessor?: string | ((d: any) => string);
+    /** Custom tick values for the value (r) axis. Overrides the default d3 ticks. */
+    rTickValues?: number[];
+    /** Align first tick label to start and last tick label to end. Default false. */
+    tickLabelEdgeAlign?: boolean;
     pieceStyle?: (d: any, category?: string) => Style;
     summaryStyle?: (d: any, category?: string) => Style;
     colorScheme?: string | string[];
@@ -276,6 +309,10 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
 export interface StreamOrdinalFrameHandle<T = Record<string, any>> {
     push(datum: T): void;
     pushMany(data: T[]): void;
+    /** Remove data items by ID. Requires dataIdAccessor. */
+    remove(id: string | string[]): T[];
+    /** Update data items by ID in place. Requires dataIdAccessor. Returns previous values. */
+    update(id: string | string[], updater: (d: T) => T): T[];
     clear(): void;
     getData(): T[];
     getScales(): OrdinalScales | null;

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

@@ -1,11 +1,12 @@
 /**
- * Decay encoding for XY pipeline scene nodes.
+ * Shared decay encoding utilities for all pipeline stores.
  *
- * 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.).
+ * `computeDecayOpacity()` — core algorithm used by all four pipeline stores
+ * (XY, Ordinal, Network, Geo) to compute age-based opacity.
  *
- * Dependencies: types (SceneNode, DecayConfig)
- * Consumed by: PipelineStore.computeScene (after scene build, before transitions)
+ * `applyDecay()` — XY-specific application that handles per-vertex decay
+ * for line/area nodes. Other stores call `computeDecayOpacity()` directly
+ * with their own node iteration logic.
  */
 import type { SceneNode, DecayConfig } from "./types";
 /**

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

@@ -0,0 +1,17 @@
+/**
+ * Resolve a CSS custom property value to a concrete color string.
+ *
+ * If the input is a `var(--name)` or `var(--name, fallback)` string,
+ * reads the computed value from the canvas element. Otherwise returns
+ * the input unchanged.
+ *
+ * Per-canvas cache avoids repeated getComputedStyle calls within a single
+ * paint cycle. The cache is cleared on theme changes via clearCSSColorCache(),
+ * which each Stream Frame calls in its theme-change useEffect.
+ */
+export declare function resolveCSSColor(ctx: CanvasRenderingContext2D, value: string | undefined): string | undefined;
+/**
+ * Clear the per-canvas CSS variable cache. Called by Stream Frames
+ * when the theme changes so the next paint reads fresh computed values.
+ */
+export declare function clearCSSColorCache(canvas: HTMLCanvasElement): void;

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

@@ -187,6 +187,10 @@ export interface RectSceneNode {
     y: number;
     w: number;
     h: number;
+    /** Rounded corner radius on the end away from the baseline */
+    roundedTop?: number;
+    /** Which edge to round: "top"/"bottom" (vertical), "right"/"left" (horizontal) */
+    roundedEdge?: "top" | "bottom" | "right" | "left";
     style: Style;
     datum: any;
     group?: string;
@@ -491,6 +495,10 @@ export interface StreamXYFrameProps<T = Record<string, any>> {
 export interface StreamXYFrameHandle<T = Record<string, any>> {
     push(datum: T): void;
     pushMany(data: T[]): void;
+    /** Remove data points by ID. Requires pointIdAccessor. */
+    remove(id: string | string[]): T[];
+    /** Update data points by ID in place. Requires pointIdAccessor. Returns previous values. */
+    update(id: string | string[], updater: (d: T) => T): T[];
     clear(): void;
     getData(): T[];
     getScales(): StreamScales | null;