semiotic 3.8.0 → 3.8.2

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

@@ -1,11 +1,13 @@
 import { ParticlePool } from "./ParticlePool";
 import type { NetworkLayoutResult, NetworkHtmlMark } from "./networkCustomLayout";
 import type { CustomLayoutSelection } from "./customLayoutSelection";
-import { type CustomLayoutFailureDiagnostic } from "./customLayoutFailure";
+import type { CustomLayoutFailureDiagnostic } from "./customLayoutFailure";
 import type { ActiveTransition } from "./pipelineTransitionUtils";
 import { type Quadtree } from "d3-quadtree";
 import type { NetworkPipelineConfig, NetworkSceneNode, NetworkSceneEdge, NetworkCircleNode, NetworkLabel, RealtimeNode, RealtimeEdge, EdgePush } from "./networkTypes";
 import type { Datum } from "../charts/shared/datumTypes";
+import { NetworkPipelineUpdateResults } from "./networkPipelineUpdateResults";
+import { type UpdateResult, type UpdateResultStore } from "./pipelineUpdateStore";
 /**
  * NetworkPipelineStore — stateful store for the StreamNetworkFrame.
  *
@@ -15,7 +17,13 @@ import type { Datum } from "../charts/shared/datumTypes";
  * For bounded data: ingests nodes/edges arrays, runs layout once, builds scene.
  * For streaming data: ingests edge pushes, tracks tension, relayouts on threshold.
  */
-export declare class NetworkPipelineStore {
+export declare class NetworkPipelineStore implements UpdateResultStore {
+    getLastUpdateResult: () => UpdateResult;
+    getUpdateSnapshot: () => UpdateResult;
+    subscribeUpdateResult: (listener: () => void) => () => void;
+    setLayoutSelection: (selection: CustomLayoutSelection | null) => void;
+    markStylePaintPending: () => void;
+    consumeStylePaintPending: () => boolean;
     nodes: Map<string, RealtimeNode>;
     edges: Map<string, RealtimeEdge>;
     tension: number;
@@ -65,6 +73,9 @@ export declare class NetworkPipelineStore {
     particlePool: ParticlePool | null;
     private config;
     private tensionConfig;
+    protected updateResults: NetworkPipelineUpdateResults;
+    /** Keep ingest, live encodings, staleness, and transitions on one clock. */
+    private currentTime;
     transition: ActiveTransition | null;
     private _hasRenderedOnce;
     /** Snapshot of node positions from before bounded re-ingestion cleared the maps */
@@ -97,19 +108,25 @@ export declare class NetworkPipelineStore {
         y: number;
     }> | null;
     constructor(config: NetworkPipelineConfig);
-    updateConfig(config: NetworkPipelineConfig): void;
+    updateConfig(config: Partial<NetworkPipelineConfig>): void;
+    /** Additive explicit-result form of {@link updateConfig}. */
+    updateConfigWithResult(config: Partial<NetworkPipelineConfig>): UpdateResult;
     /**
      * Ingest hierarchy root data for tree/treemap/circlepack/partition layouts.
      * The hierarchy root is passed to the layout plugin via config.__hierarchyRoot.
      */
-    ingestHierarchy(rootData: any, size: [number, number]): void;
+    ingestHierarchy(rootData: Datum, size: [number, number]): void;
     /**
      * Ingest bounded node/edge arrays (from props).
      * Clears existing topology and rebuilds from scratch.
      */
-    ingestBounded(rawNodes: any[], rawEdges: any[], size: [number, number], options?: {
+    ingestBounded(rawNodes: Datum[], rawEdges: Datum[], size: [number, number], options?: {
         deferLayout?: boolean;
     }): void;
+    /** Additive explicit-result form of {@link ingestBounded}. */
+    ingestBoundedWithResult(rawNodes: Datum[], rawEdges: Datum[], size: [number, number], options?: {
+        deferLayout?: boolean;
+    }): UpdateResult;
     /**
      * Apply worker-computed force positions through the normal layout finalizer.
      * The force plugin still resolves edge endpoints, clamps bounds, records
@@ -129,6 +146,8 @@ export declare class NetworkPipelineStore {
      * Returns true if a relayout is needed.
      */
     ingestEdge(push: EdgePush): boolean;
+    /** Additive explicit-result form of {@link ingestEdge}. */
+    ingestEdgeWithResult(push: EdgePush): UpdateResult;
     /**
      * Run the layout algorithm via the appropriate plugin.
      */
@@ -145,13 +164,6 @@ export declare class NetworkPipelineStore {
     /**
      * Build the scene graph from current layout positions.
      */
-    /** Update the selection the layout reads at the next `buildScene`, without
-     *  triggering a rebuild. The frame calls this on selection change; whether it
-     *  then repaints (restyle) or rebuilds is the frame's decision. */
-    setLayoutSelection(selection: CustomLayoutSelection | null): void;
-    /** Snapshot each mark's as-emitted style so {@link restyleScene} can re-apply
-     *  patches from the original rather than compounding. */
-    private snapshotBaseStyles;
     /**
      * Re-apply the custom layout's `restyle`/`restyleEdge` to the existing scene
      * for `selection`, mutating styles **in place** off each mark's base style.
@@ -159,15 +171,6 @@ export declare class NetworkPipelineStore {
      * stays valid and no relayout/repack happens. The frame repaints the canvas
      * after calling this. No-op when the layout supplied no restyle callbacks.
      */
-    /**
-     * "Styles changed, repaint the data canvas without rebuilding the scene."
-     * Set by {@link restyleScene}; consumed once per frame by the paint loop.
-     * Deliberately separate from `_sceneNodesRevision` (the quadtree-invalidation
-     * counter) so a style-only selection change repaints without a relayout.
-     */
-    private _stylePaintPending;
-    /** Consume the style-only repaint signal (see {@link _stylePaintPending}). */
-    consumeStylePaintPending(): boolean;
     restyleScene(selection: CustomLayoutSelection | null): void;
     buildScene(size: [number, number]): void;
     /**

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

@@ -0,0 +1,17 @@
+import * as React from "react";
+import type { StreamNetworkFrameProps } from "./networkTypes";
+import { NetworkPipelineStore } from "./NetworkPipelineStore";
+import { NetworkSVGOverlay } from "./NetworkSVGOverlay";
+interface NetworkSSRFrameProps {
+    props: StreamNetworkFrameProps;
+    store: NetworkPipelineStore | null;
+    responsiveRef: React.Ref<HTMLDivElement>;
+    size: [number, number];
+    margin: React.ComponentProps<typeof NetworkSVGOverlay>["margin"];
+    adjustedWidth: number;
+    adjustedHeight: number;
+    resolvedBackground: React.ReactNode;
+    resolvedForeground: React.ReactNode;
+}
+export declare function NetworkSSRFrame({ props, store, responsiveRef, size, margin, adjustedWidth, adjustedHeight, resolvedBackground, resolvedForeground }: NetworkSSRFrameProps): React.JSX.Element;
+export {};

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

@@ -6,6 +6,8 @@ import type { LegendGroup, GradientLegendConfig, LegendLayout } from "../types/l
 import { type AutoPlaceAnnotations } from "../recipes/annotationLayout";
 import type { AnnotationContext } from "../realtime/types";
 import { type GlyphDef } from "./glyphDef";
+import type { OnObservationCallback } from "../store/ObservationStore";
+import { type OnAnnotationActivateCallback } from "../charts/shared/annotationActivation";
 type AnnotationAnchorNode = {
     type: string;
     datum: Datum | null;
@@ -75,6 +77,10 @@ export interface NetworkSVGOverlayProps {
     sceneNodes?: AnnotationAnchorNode[];
     /** Annotations */
     annotations?: Datum[];
+    onAnnotationActivate?: OnAnnotationActivateCallback;
+    onObservation?: OnObservationCallback;
+    chartId?: string;
+    chartType?: string;
     autoPlaceAnnotations?: AutoPlaceAnnotations;
     svgAnnotationRules?: (annotation: Datum, index: number, context: NetworkAnnotationContext) => ReactNode;
     annotationFrame?: number;

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

@@ -17,7 +17,7 @@
  */
 import * as React from "react";
 import type { OrdinalScales } from "./ordinalTypes";
-interface OrdinalBrushOverlayProps {
+export interface OrdinalBrushOverlayProps {
     width: number;
     height: number;
     totalWidth: number;
@@ -40,4 +40,3 @@ interface OrdinalBrushOverlayProps {
  * In vertical projection, r maps to y-pixels → uses brushY.
  */
 export declare function OrdinalBrushOverlay({ width, height, totalWidth, totalHeight, margin, scales, onBrush }: OrdinalBrushOverlayProps): React.JSX.Element;
-export {};

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

@@ -0,0 +1,9 @@
+/**
+ * Lazy-loaded wrapper for OrdinalBrushOverlay.
+ *
+ * Same rationale as XYBrushOverlayLazy: d3-brush is only needed when brushing
+ * is enabled. Keep it off the default ordinal cold path (BarChart, PieChart…).
+ */
+import * as React from "react";
+import type { OrdinalBrushOverlayProps } from "./OrdinalBrushOverlay";
+export declare function OrdinalBrushOverlayLazy(props: OrdinalBrushOverlayProps): React.JSX.Element | null;

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

@@ -1,8 +1,8 @@
 import type { OrdinalSceneNode } from "./ordinalTypes";
-import type { PointSceneNode } from "./types";
+import type { SceneDatum, PointSceneNode } from "./types";
 import type { Quadtree } from "d3-quadtree";
 export interface OrdinalHitResult {
-    datum: any;
+    datum: SceneDatum;
     x: number;
     y: number;
     distance: number;

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

@@ -23,15 +23,22 @@ import type { ActiveTransition } from "./pipelineTransitionUtils";
 import type { OrdinalLayoutResult } from "./ordinalCustomLayout";
 import type { CustomLayoutSelection } from "./customLayoutSelection";
 import { type CustomLayoutFailureDiagnostic } from "./customLayoutFailure";
-import type { UpdateResult } from "./pipelineUpdateContract";
-export declare class OrdinalPipelineStore {
+import { type UpdateResult, type UpdateResultStore } from "./pipelineUpdateStore";
+import { OrdinalPipelineUpdateResults } from "./ordinalPipelineUpdateResults";
+export declare class OrdinalPipelineStore implements UpdateResultStore {
+    getLastUpdateResult: () => UpdateResult;
+    getUpdateSnapshot: () => UpdateResult;
+    subscribeUpdateResult: (listener: () => void) => () => void;
+    setLayoutSelection: (selection: CustomLayoutSelection | null) => void;
+    markStylePaintPending: () => void;
+    consumeStylePaintPending: () => boolean;
     private buffer;
     private rExtent;
     /** Per-accessor extents for multiAxis mode */
     private rExtents;
     private config;
     private windowSizeWarned;
-    private updateResults;
+    protected updateResults: OrdinalPipelineUpdateResults;
     private getO;
     private getR;
     /** All resolved rAccessors (length > 1 when multiAxis) */
@@ -46,9 +53,7 @@ export declare class OrdinalPipelineStore {
     private categories;
     /** True once a non-bounded (push) changeset has been ingested */
     private _hasStreamingData;
-    /** Lazy color map built from colorScheme for resolvePieceStyle */
-    private _colorSchemeMap;
-    private _colorSchemeIndex;
+    private styleResolver;
     private timestampBuffer;
     activeTransition: ActiveTransition | null;
     private prevPositionMap;
@@ -98,6 +103,8 @@ export declare class OrdinalPipelineStore {
      * empty ring would associate later timestamps with the wrong datum index.
      */
     private syncPulseTimestampBuffer;
+    /** Keep ingest, pulse, staleness, and transition timestamps on one clock. */
+    private currentTime;
     ingest(changeset: Changeset): boolean;
     ingestWithResult(changeset: Changeset): UpdateResult;
     private pushValueExtent;
@@ -112,9 +119,6 @@ export declare class OrdinalPipelineStore {
     private getSceneContext;
     private buildSceneNodes;
     private buildLayoutContext;
-    private resolvePieceStyle;
-    private getColorFromScheme;
-    private resolveSummaryStyle;
     computeDecayOpacity(bufferIndex: number, bufferSize: number): number;
     /**
      * Build (or return cached) datum→buffer-index map. Cached against
@@ -171,8 +175,6 @@ export declare class OrdinalPipelineStore {
      */
     private getBufferArray;
     getData(): Datum[];
-    /** Most recent additive update result for revision-aware hosts and tests. */
-    getLastUpdateResult(): UpdateResult;
     /**
      * Remove data items by ID. Requires dataIdAccessor to be configured.
      * Returns the removed items. Marks the store dirty for scene rebuild.
@@ -187,8 +189,6 @@ export declare class OrdinalPipelineStore {
     get size(): number;
     getOAccessor(): (d: Datum) => string;
     getRAccessor(): (d: Datum) => number;
-    /** Update the selection the layout reads at the next rebuild, without one. */
-    setLayoutSelection(selection: CustomLayoutSelection | null): void;
     private applyCustomRestyle;
     /**
      * Re-apply the custom layout's `restyle` to the existing scene for

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

@@ -4,6 +4,8 @@ import type { OrdinalScales } from "./ordinalTypes";
 import type { AnnotationContext } from "../realtime/types";
 import type { ReactNode } from "react";
 import type { LegendGroup, GradientLegendConfig, LegendLayout } from "../types/legendTypes";
+import type { OnObservationCallback } from "../store/ObservationStore";
+import { type OnAnnotationActivateCallback } from "../charts/shared/annotationActivation";
 import { type AutoPlaceAnnotations } from "../recipes/annotationLayout";
 import { type AxisExtentMode } from "../charts/shared/axisExtent";
 interface OrdinalSVGOverlayProps {
@@ -53,14 +55,20 @@ interface OrdinalSVGOverlayProps {
     legendLayout?: LegendLayout;
     foregroundGraphics?: ReactNode;
     annotations?: Datum[];
+    onAnnotationActivate?: OnAnnotationActivateCallback;
+    onObservation?: OnObservationCallback;
+    chartId?: string;
+    chartType?: string;
     autoPlaceAnnotations?: AutoPlaceAnnotations;
     svgAnnotationRules?: (annotation: Datum, index: number, context: AnnotationContext) => ReactNode;
     annotationFrame?: number;
     xAccessor?: string;
     yAccessor?: string;
     annotationData?: Datum[];
-    /** When true, grid lines and axis baselines are skipped (rendered by OrdinalSVGUnderlay instead) */
+    /** When true, grid lines and axis baselines are also rendered by OrdinalSVGUnderlay. */
     underlayRendered?: boolean;
+    /** Whether an opaque canvas hides the SVG underlay and needs an overlay copy. */
+    canvasObscuresUnderlay?: boolean;
     children?: ReactNode;
 }
 interface OrdinalSVGUnderlayProps {

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

@@ -0,0 +1,12 @@
+import type { Datum } from "../charts/shared/datumTypes";
+import type { OrdinalPipelineConfig } from "./ordinalTypes";
+import type { Style } from "./types";
+/** Resolves ordinal mark styles while retaining stable category colors. */
+export declare class OrdinalStyleResolver {
+    private colorSchemeMap;
+    private colorSchemeIndex;
+    resetColors(): void;
+    resolvePieceStyle(config: OrdinalPipelineConfig, datum: Datum | null, category?: string): Style;
+    resolveSummaryStyle(config: OrdinalPipelineConfig, datum: Datum | null, category?: string): Style;
+    private getColorFromScheme;
+}

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

@@ -17,7 +17,7 @@ export declare class ParticlePool {
      * Spawn a new particle on the given edge.
      * Returns the particle if a free slot was found, null otherwise.
      */
-    spawn(edgeIndex: number): Particle | null;
+    spawn(edgeIndex: number, random?: () => number): Particle | null;
     /**
      * Advance all active particles by deltaTime.
      * Recycles particles that have completed their journey (t >= 1).

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

@@ -26,10 +26,18 @@ import type { CustomLayoutSelection } from "./customLayoutSelection";
 import { type CustomLayoutFailureDiagnostic } from "./customLayoutFailure";
 import { type PipelineConfig } from "./pipelineConfig";
 import type { UpdateResult } from "./pipelineUpdateContract";
+import { type UpdateResultStore } from "./pipelineUpdateStore";
+import { PipelineStoreUpdateResults } from "./pipelineStoreUpdateResults";
 export type { PipelineConfig } from "./pipelineConfig";
 export type { ChangeSet, Invalidation, RevisionSet, UpdateResult, } from "./pipelineUpdateContract";
 export { DEFAULT_GROWING_MAX_CAPACITY, GROWING_CAPACITY_WARN_THRESHOLD } from "./pipelineConfig";
-export declare class PipelineStore {
+export declare class PipelineStore implements UpdateResultStore {
+    getLastUpdateResult: () => UpdateResult;
+    getUpdateSnapshot: () => UpdateResult;
+    subscribeUpdateResult: (listener: () => void) => () => void;
+    setLayoutSelection: (selection: CustomLayoutSelection | null) => void;
+    markStylePaintPending: () => void;
+    consumeStylePaintPending: () => boolean;
     private buffer;
     private xExtent;
     private yExtent;
@@ -64,6 +72,8 @@ export declare class PipelineStore {
     /** Exit nodes awaiting fade-out removal */
     exitNodes: SceneNode[];
     lastIngestTime: number;
+    /** Keep ingest, pulse, staleness, and transition timestamps on one clock. */
+    private currentTime;
     /** Unified color map cache keyed by sorted category set — shared across point, swarm, etc. */
     private _colorMapCache;
     /** groupData() result cache. The line/area/stacked-area builders all re-bucket
@@ -96,7 +106,7 @@ export declare class PipelineStore {
     private _bufferDirty;
     private needsFullRebuild;
     private lastLayout;
-    private updateResults;
+    protected updateResults: PipelineStoreUpdateResults;
     scales: StreamScales | null;
     scene: SceneNode[];
     version: number;
@@ -230,8 +240,6 @@ export declare class PipelineStore {
      */
     private getBufferArray;
     getData(): Datum[];
-    /** Most recent additive update result for revision-aware hosts and tests. */
-    getLastUpdateResult(): UpdateResult;
     /**
      * Remove data points by ID. Requires pointIdAccessor to be configured.
      * Returns the removed items. Marks the store dirty for scene rebuild.
@@ -255,19 +263,7 @@ export declare class PipelineStore {
     getXAccessor(): (d: Datum) => number;
     getYAccessor(): (d: Datum) => number;
     getCategoryAccessor(): ((d: Datum) => string) | undefined;
-    /** Update the selection the layout reads at the next rebuild, without
-     *  triggering one. The frame then either repaints (restyle) or rebuilds. */
-    setLayoutSelection(selection: CustomLayoutSelection | null): void;
     private applyCustomRestyle;
-    /**
-     * "Styles changed, repaint the data canvas without rebuilding the scene."
-     * Set by {@link restyleScene}; consumed once per frame by the render loop.
-     * Kept separate from the dirty flag so a style-only selection change repaints
-     * without forcing a layout/scene rebuild (the point of the restyle fast path).
-     */
-    private _stylePaintPending;
-    /** Consume the style-only repaint signal (see {@link _stylePaintPending}). */
-    consumeStylePaintPending(): boolean;
     /**
      * Re-apply the custom layout's `restyle` to the existing scene for
      * `selection`, off each node's base style — no relayout, no quadtree rebuild

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

@@ -5,6 +5,8 @@ import type { AnnotationContext } from "../realtime/types";
 import type { ReactNode } from "react";
 import type { LegendGroup, GradientLegendConfig, LegendLayout } from "../types/legendTypes";
 import { type AutoPlaceAnnotations } from "../recipes/annotationLayout";
+import type { OnObservationCallback } from "../store/ObservationStore";
+import { type OnAnnotationActivateCallback } from "../charts/shared/annotationActivation";
 export type AxisConfig = XYFrameAxisConfig;
 interface SVGOverlayProps {
     width: number;
@@ -59,6 +61,10 @@ interface SVGOverlayProps {
     xValues?: number[];
     yValues?: number[];
     annotations?: Datum[];
+    onAnnotationActivate?: OnAnnotationActivateCallback;
+    onObservation?: OnObservationCallback;
+    chartId?: string;
+    chartType?: string;
     autoPlaceAnnotations?: AutoPlaceAnnotations;
     svgAnnotationRules?: (annotation: Datum, index: number, context: AnnotationContext) => ReactNode;
     annotationFrame?: number;

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

@@ -1,4 +1,4 @@
-import type { SceneNode, LineSceneNode, AreaSceneNode, PointSceneNode, SymbolSceneNode, RectSceneNode, HeatcellSceneNode, Style, StreamScales, CurveType } from "./types";
+import type { SceneNode, SceneDatum, LineSceneNode, AreaSceneNode, PointSceneNode, SymbolSceneNode, RectSceneNode, HeatcellSceneNode, Style, StreamScales, CurveType } from "./types";
 import type { SymbolName } from "./symbolPath";
 import type { Datum } from "../charts/shared/datumTypes";
 export declare function buildLineNode(data: Datum[], scales: StreamScales, xGet: (d: Datum) => number, yGet: (d: Datum) => number, style: Style, group?: string): LineSceneNode;
@@ -38,8 +38,8 @@ export declare function buildPointNode(datum: Datum, scales: StreamScales, xGet:
 /** Build a {@link SymbolSceneNode} — the glyph sibling of {@link buildPointNode}.
  *  `size` is the d3-symbol area (px²); convert from a target radius with πr². */
 export declare function buildSymbolNode(datum: Datum, scales: StreamScales, xGet: (d: Datum) => number, yGet: (d: Datum) => number, size: number, symbolType: SymbolName, style: Style, pointId?: string): SymbolSceneNode | 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?: {
+export declare function buildRectNode(x: number, y: number, w: number, h: number, style: Style, datum: SceneDatum, group?: string): RectSceneNode;
+export declare function buildHeatcellNode(x: number, y: number, w: number, h: number, fill: string, datum: Datum, options?: {
     value?: number;
     showValues?: boolean;
     valueFormat?: (v: number) => string;

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

@@ -0,0 +1,17 @@
+/**
+ * Lazy-loaded wrapper for XYBrushOverlay.
+ *
+ * d3-brush pulls d3-selection + d3-drag + d3-transition (~14 KB gz). Most XY
+ * charts never enable brushing, so keep that graph out of the default cold path
+ * and only load it when `brush` / `onBrush` is actually used.
+ *
+ * Pattern mirrors `statisticalOverlaysLazy.ts`.
+ */
+import * as React from "react";
+import type { XYBrushOverlayProps } from "./XYBrushOverlay";
+/**
+ * Renders nothing until the brush module resolves, then mounts the real overlay.
+ * Acceptable: brush is interaction-driven; the first paint of the SVG layer can
+ * lag one tick without affecting chart layout or data marks.
+ */
+export declare function XYBrushOverlayLazy(props: XYBrushOverlayProps): React.JSX.Element | null;

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

@@ -24,8 +24,8 @@
  * its identity changing, bump the pipeline config's `accessorRevision` to force
  * re-derivation.
  */
-export declare function accessorsEquivalent(a: string | ((...args: any[]) => any) | undefined, b: string | ((...args: any[]) => any) | undefined): boolean;
+export declare function accessorsEquivalent<TDatum, TResult>(a: string | ((datum: TDatum, index?: number) => TResult) | undefined, b: string | ((datum: TDatum, index?: number) => TResult) | undefined): boolean;
 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 resolveRawAccessor<T extends Record<string, unknown>, TResult>(accessor: string | ((d: T) => TResult) | undefined, fallback: string): (d: T) => TResult;
 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

@@ -9,14 +9,14 @@
  * `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";
+import type { Datum, DatumValue } 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;
+    fn: ((d: Datum) => DatumValue) | null;
 }
 /**
  * Resolve an accessor pair to the (key, fn) shape the annotation

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

@@ -0,0 +1,4 @@
+import type { ReactNode } from "react";
+import type { FrameGraphicsContext, FrameGraphicsProp } from "./types";
+/** Resolve a static or scale-aware SVG graphics layer for a frame family. */
+export declare function resolveFrameGraphics<S>(graphics: FrameGraphicsProp<S> | undefined, size: number[], margin: FrameGraphicsContext<S>["margin"], scales: S | null): ReactNode;

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

@@ -0,0 +1,45 @@
+import type { Dispatch, KeyboardEvent, SetStateAction } from "react";
+import type { HoverData } from "../realtime/types";
+import type { SemanticClickBehavior, SemanticHoverBehavior } from "../charts/shared/semanticInteractions";
+import type { PipelineStore } from "./PipelineStore";
+import type { OrdinalPipelineStore } from "./OrdinalPipelineStore";
+import type { GeoPipelineStore } from "./GeoPipelineStore";
+import type { SceneNode } from "./types";
+import type { OrdinalSceneNode } from "./ordinalTypes";
+import type { GeoSceneNode } from "./geoTypes";
+import { type NavPoint } from "./keyboardNav";
+type RefValue<Value> = {
+    current: Value;
+};
+type SetHoverPoint = Dispatch<SetStateAction<HoverData | null>>;
+type FocusedNavPoint = Pick<NavPoint, "shape" | "w" | "h" | "pathData">;
+interface KeyboardInteractionParams<Store, Node = unknown> {
+    storeRef: RefValue<Store | null>;
+    hoverRef: RefValue<HoverData | null>;
+    hoveredNodeRef?: RefValue<Node | null>;
+    setHoverPoint: SetHoverPoint;
+    customHoverBehavior: SemanticHoverBehavior<HoverData>;
+    customClickBehavior: SemanticClickBehavior<HoverData>;
+    scheduleRender: () => void;
+}
+export declare function useXYKeyboardNavigation(params: KeyboardInteractionParams<PipelineStore, SceneNode>): {
+    kbFocusIndexRef: import("react").RefObject<number>;
+    focusedNavPointRef: import("react").RefObject<FocusedNavPoint | null>;
+    onKeyDown: (event: KeyboardEvent) => void;
+};
+interface OrdinalKeyboardParams extends KeyboardInteractionParams<OrdinalPipelineStore, OrdinalSceneNode> {
+    chartType: string;
+    oAccessor: unknown;
+    rAccessor: unknown;
+}
+export declare function useOrdinalKeyboardNavigation({ chartType, oAccessor, rAccessor, ...params }: OrdinalKeyboardParams): {
+    kbFocusIndexRef: import("react").RefObject<number>;
+    focusedNavPointRef: import("react").RefObject<FocusedNavPoint | null>;
+    onKeyDown: (event: KeyboardEvent) => void;
+};
+export declare function useGeoKeyboardNavigation({ storeRef, hoverRef, hoveredNodeRef, setHoverPoint, customHoverBehavior, customClickBehavior, scheduleRender }: KeyboardInteractionParams<GeoPipelineStore, GeoSceneNode>): {
+    kbFocusIndexRef: import("react").RefObject<number>;
+    focusedNavPointRef: import("react").RefObject<FocusedNavPoint | null>;
+    onKeyDown: (event: KeyboardEvent) => void;
+};
+export {};

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

@@ -9,8 +9,8 @@ import type { Style } from "./types";
 import type { Datum } from "../charts/shared/datumTypes";
 export declare function resolveProjection(prop: ProjectionProp | undefined): GeoProjection;
 export declare function makeGeoNumericAccessor(acc: string | ((d: Datum) => number) | undefined, fallback: string): (d: Datum) => number;
-export declare function makeLineDataAccessor(acc: string | ((d: Datum) => any[]) | undefined): (d: Datum) => any[];
-export declare function resolveGeoStyle(styleProp: Style | ((d: Datum) => Style) | undefined, datum: any, defaults: Style): Style;
+export declare function makeLineDataAccessor(acc: string | ((d: Datum) => Datum[]) | undefined): (d: Datum) => Datum[];
+export declare function resolveGeoStyle<TDatum extends object>(styleProp: Style | ((d: TDatum) => Style) | undefined, datum: TDatum, defaults: Style): Style;
 export declare function themedDefaultArea(config: GeoPipelineConfig): Style;
 export declare function themedDefaultPoint(config: GeoPipelineConfig): Style & {
     r?: number;
@@ -43,4 +43,4 @@ export declare function buildOffsetGeoPath(screenPath: [number, number][], strok
  * Bidirectional pairs (A->B and B->A) naturally separate because their
  * left-hand normals point to opposite sides.
  */
-export declare function buildOffsetPath(start: [number, number], end: [number, number], _flow: any, _allFlows: any[], strokeWidth: number): [number, number][];
+export declare function buildOffsetPath(start: [number, number], end: [number, number], _flow: Datum, _allFlows: Datum[], strokeWidth: number): [number, number][];

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

@@ -0,0 +1,34 @@
+import { type ChangeSet, type Invalidation, type UpdateResult } from "./pipelineUpdateContract";
+/** Whether a config patch must re-derive its retained Geo data resources. */
+export type GeoRetainedDataEffect = "preserve" | "rebuild";
+export interface GeoConfigPatchDependency {
+    readonly retainedData: GeoRetainedDataEffect;
+    readonly invalidations: readonly Invalidation[];
+}
+/**
+ * Geo's key-level config-patch dependency table. `windowSize` is a retained
+ * resource rebuild: its `data` revision is added only when an active stream
+ * actually resizes, so a bounded config-only patch is never reported as an
+ * ingest.
+ */
+export declare const GEO_CONFIG_PATCH_DEPENDENCIES: Readonly<Record<string, GeoConfigPatchDependency>>;
+export interface GeoConfigPatchClassification {
+    readonly retainedData: GeoRetainedDataEffect;
+    readonly invalidations: ReadonlySet<Invalidation>;
+}
+/** Union the declared effects for a patch after its effective keys are known. */
+export declare function classifyGeoConfigPatch(keys: readonly string[]): GeoConfigPatchClassification;
+type DataChangeKind = Extract<ChangeSet["kind"], "ingest" | "replace" | "remove" | "update" | "clear">;
+/** Result bookkeeping and explicit config-patch dependency policy for Geo. */
+export declare class GeoPipelineUpdateResults {
+    private tracker;
+    get last(): UpdateResult;
+    subscribe(listener: () => void): () => void;
+    recordData(kind: DataChangeKind, count?: number): UpdateResult;
+    recordNoop(kind: DataChangeKind | "restyle"): UpdateResult;
+    recordRestyle(hasCustomRestyle: boolean): UpdateResult;
+    recordConfig(keys: readonly string[], options?: {
+        retainedDataChanged?: boolean;
+    }): UpdateResult;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import type { GeoPath, GeoPermissibleObjects, GeoProjection } from "d3-geo";
+import type { GeoPipelineConfig, GeoSceneNode } from "./geoTypes";
+import type { StreamLayout } from "./types";
+import type { Datum } from "../charts/shared/datumTypes";
+interface GeoSceneBuildInput {
+    config: GeoPipelineConfig;
+    projection: GeoProjection;
+    path: GeoPath<void, GeoPermissibleObjects>;
+    areas: GeoJSON.Feature[];
+    points: Datum[];
+    lines: Datum[];
+    layout: StreamLayout;
+}
+/** Builds the built-in geo scene independently of store-owned custom layout state. */
+export declare function buildBuiltInGeoScene({ config, projection, path, areas, points, lines, layout }: GeoSceneBuildInput): GeoSceneNode[];
+export {};