semiotic 3.7.5 → 3.8.1

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

@@ -1,10 +1,9 @@
 import * as React from "react";
-/** Scene node type used by the accessible data table — accepts any frame's scene nodes */
-type AnySceneNode = {
-    type?: string;
-    [key: string]: any;
-};
-declare const SR_ONLY_STYLE: React.CSSProperties;
+import type { Datum } from "../charts/shared/datumTypes";
+import { type AccessibleSceneNode as AnySceneNode } from "./accessibleDataRows";
+export { extractAllRows } from "./accessibleDataRows";
+export type { DataRow } from "./accessibleDataRows";
+export { AriaLiveTooltip, SR_ONLY_STYLE } from "./AriaLiveTooltip";
 /**
  * Compute an aria-label describing the chart type and data shape from the scene graph.
  */
@@ -13,14 +12,6 @@ export declare function computeCanvasAriaLabel(scene: AnySceneNode[] | null | un
  * Compute an aria-label for network charts from scene nodes and edges.
  */
 export declare function computeNetworkAriaLabel(nodeCount: number, edgeCount: number, chartType: string): string;
-interface DataRow {
-    label: string;
-    values: Record<string, string | number>;
-}
-/** Extract a flat list of typed rows from scene nodes, surfacing the raw datum
- *  fields (not pixel coordinates). Defensively handles missing/malformed data —
- *  never throws. Exported for direct testing. */
-export declare function extractAllRows(scene: AnySceneNode[]): DataRow[];
 interface AccessibleDataTableProps {
     scene: AnySceneNode[];
     chartType: string;
@@ -38,7 +29,7 @@ interface AccessibleDataTableProps {
 export declare function AccessibleDataTable({ scene, chartType, tableId, chartTitle }: AccessibleDataTableProps): React.JSX.Element | null;
 interface NetworkAccessibleDataTableProps {
     nodes: Array<{
-        datum?: any;
+        datum?: Datum | null;
         id?: string;
         cx?: number;
         cy?: number;
@@ -46,7 +37,7 @@ interface NetworkAccessibleDataTableProps {
         y?: number;
     }>;
     edges: Array<{
-        datum?: any;
+        datum?: Datum | null;
         source?: string;
         target?: string;
     }>;
@@ -72,10 +63,3 @@ export declare function ScreenReaderSummary({ summary }: {
 export declare function SkipToTableLink({ tableId }: {
     tableId: string;
 }): React.JSX.Element;
-/**
- * Visually-hidden aria-live region that mirrors tooltip text for screen readers.
- */
-export declare function AriaLiveTooltip({ hoverPoint }: {
-    hoverPoint: any;
-}): React.JSX.Element;
-export { SR_ONLY_STYLE };

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

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { HoverData } from "../realtime/types";
+export declare const SR_ONLY_STYLE: React.CSSProperties;
+/** Visually-hidden aria-live region that mirrors tooltip text for screen readers. */
+export declare function AriaLiveTooltip({ hoverPoint }: {
+    hoverPoint: Pick<HoverData, "data"> | {
+        data: object;
+    } | null;
+}): React.JSX.Element;

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

@@ -1,17 +1,17 @@
-import type { SceneNode, PointSceneNode } from "./types";
+import type { SceneNode, SceneDatum, PointSceneNode } from "./types";
+import type { Datum } from "../charts/shared/datumTypes";
 import type { RingBuffer } from "../realtime/RingBuffer";
 import type { Quadtree } from "d3-quadtree";
-import type { Datum } from "../charts/shared/datumTypes";
 export interface HitResult {
     node: SceneNode;
-    datum: any;
+    datum: SceneDatum;
     x: number;
     y: number;
     distance: number;
 }
 export interface XHitResult {
     node: SceneNode;
-    datum: any;
+    datum: SceneDatum;
     x: number;
     y: number;
     y0?: number;

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

@@ -1,7 +1,7 @@
 import type { Changeset } from "./types";
 import type { Datum } from "../charts/shared/datumTypes";
 export type ChangesetCallback<T> = (changeset: Changeset<T>) => void;
-export declare class DataSourceAdapter<T = Datum> {
+export declare class DataSourceAdapter<T extends object = Datum> {
     private callback;
     private lastBoundedData;
     private chunkTimer;

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

@@ -24,10 +24,12 @@ export interface FocusRingProps {
     /** Total chart size */
     size: [number, number];
     /** Shape hint from the focused nav point */
-    shape?: "circle" | "rect" | "wedge";
+    shape?: "circle" | "rect" | "wedge" | "geoarea" | "path";
     /** Width of rect-shaped focus target */
     width?: number;
     /** Height of rect-shaped focus target */
     height?: number;
+    /** SVG path (plot-relative) outlined for a geoarea focus. */
+    pathData?: string;
 }
-export declare function FocusRing({ active, hoverPoint, margin, size, shape, width, height }: FocusRingProps): React.JSX.Element | null;
+export declare function FocusRing({ active, hoverPoint, margin, size, shape, width, height, pathData }: FocusRingProps): React.JSX.Element | null;

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

@@ -0,0 +1,57 @@
+/**
+ * Shared timing and randomness policy for frame hosts.
+ *
+ * A runtime converts a wall clock into logical frame time. Logical time moves
+ * forward only while the frame is active, so a paused or hidden chart resumes
+ * from its previous animation state instead of fast-forwarding through the
+ * elapsed wall-clock interval.
+ */
+export type FrameClock = () => number;
+export type FrameRandom = () => number;
+export interface FrameRuntimeOptions {
+    /** Monotonic wall-clock milliseconds. Defaults to performance.now/Date.now. */
+    clock?: FrameClock;
+    /** Injectable random source for tests or an embedding runtime. */
+    random?: FrameRandom;
+    /** Serializable deterministic random seed. Ignored when `random` is provided. */
+    seed?: number;
+    paused?: boolean;
+    visible?: boolean;
+}
+export interface FrameRuntimeSnapshot {
+    now: number;
+    paused: boolean;
+    seed?: number;
+    visible: boolean;
+}
+/** Mulberry32 is small, deterministic, and accepts the serializable integer seed surface. */
+export declare function createSeededFrameRandom(seed: number): FrameRandom;
+export declare class FrameRuntime {
+    private clock;
+    private lastWallTime;
+    private logicalTime;
+    private randomInput;
+    private randomSource;
+    private seedValue;
+    private pausedValue;
+    private subscribers;
+    private visibleValue;
+    /** Stable callable seam for stores and render loops. */
+    readonly now: () => number;
+    /** Stable callable seam for stochastic renderers. */
+    readonly random: () => number;
+    constructor(options?: FrameRuntimeOptions);
+    get isActive(): boolean;
+    get paused(): boolean;
+    get seed(): number | undefined;
+    get visible(): boolean;
+    configure(options: Pick<FrameRuntimeOptions, "clock" | "random" | "seed">): void;
+    setPaused(paused: boolean): void;
+    setVisible(visible: boolean): void;
+    snapshot(): FrameRuntimeSnapshot;
+    subscribe(listener: () => void): () => void;
+    private advance;
+    private emit;
+    private setClock;
+    private setRandomSource;
+}

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

@@ -16,4 +16,4 @@ export interface GeoHitResult {
  * The `hitCtx` parameter is a shared offscreen canvas context used for
  * isPointInPath checks without polluting the visible canvas.
  */
-export declare function findNearestGeoNode(nodes: GeoSceneNode[], mouseX: number, mouseY: number, maxDistance: number, hitCtx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, pointQuadtree?: Quadtree<PointSceneNode> | null, maxPointRadius?: number): GeoHitResult | null;
+export declare function findNearestGeoNode(nodes: GeoSceneNode[], mouseX: number, mouseY: number, maxDistance: number, hitCtx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, pointQuadtree?: Quadtree<PointSceneNode> | null, maxPointRadius?: number, lineMaxDistance?: number): GeoHitResult | null;

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

@@ -35,7 +35,7 @@ export declare class GeoParticlePool {
     particles: GeoParticle[];
     private capacity;
     constructor(capacity: number);
-    spawn(lineIndex: number): GeoParticle | null;
+    spawn(lineIndex: number, random?: () => number): GeoParticle | null;
     /**
      * Advance all active particles.
      * @param paths - array of polyline paths, one per line index

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

@@ -4,11 +4,38 @@ import type { GeoPipelineConfig, GeoScales, GeoSceneNode } from "./geoTypes";
 import type { PointSceneNode, StreamLayout } from "./types";
 import type { ActiveTransition } from "./pipelineTransitionUtils";
 import type { Datum } from "../charts/shared/datumTypes";
-export declare class GeoPipelineStore {
+import type { GeoLayoutResult } from "./geoCustomLayout";
+import type { CustomLayoutSelection } from "./customLayoutSelection";
+import { type CustomLayoutFailureDiagnostic } from "./customLayoutFailure";
+import { GeoPipelineUpdateResults } from "./geoPipelineUpdateResults";
+import { type UpdateResult, type UpdateResultStore } from "./pipelineUpdateStore";
+export declare class GeoPipelineStore implements UpdateResultStore {
+    getLastUpdateResult: () => UpdateResult;
+    getUpdateSnapshot: () => UpdateResult;
+    subscribeUpdateResult: (listener: () => void) => () => void;
+    setLayoutSelection: (selection: CustomLayoutSelection | null) => void;
+    markStylePaintPending: () => void;
+    consumeStylePaintPending: () => boolean;
     config: GeoPipelineConfig;
+    protected updateResults: GeoPipelineUpdateResults;
     scene: GeoSceneNode[];
     scales: GeoScales | null;
     version: number;
+    /** SVG overlays returned from the active custom layout. */
+    customLayoutOverlays: import("react").ReactNode;
+    /** Most recent custom layout result for host readback (`getCustomLayout()`).
+     *  Null before the first layout or without a custom layout. A failed
+     *  re-layout retains the prior good result alongside its diagnostic. */
+    lastCustomLayoutResult: GeoLayoutResult | null;
+    /** Most recent exception from a custom layout invocation, for host readback. */
+    lastCustomLayoutFailure: CustomLayoutFailureDiagnostic | null;
+    private _customLayoutDiagnosticsWarned;
+    private _customRestyle;
+    hasCustomRestyle: boolean;
+    private _baseStyles;
+    /** Set only while a custom-layout invocation throws. The rebuild callers use
+     *  it to retain the previous scene and projection state without mutating it. */
+    private _customLayoutFailedThisBuild;
     private static readonly QUADTREE_THRESHOLD;
     private _quadtree;
     /** Largest visual point radius in the current scene; used to widen quadtree
@@ -37,18 +64,47 @@ export declare class GeoPipelineStore {
     private prevPositions;
     private _hasRenderedOnce;
     constructor(config: GeoPipelineConfig);
+    /** Keep Geo transitions and pulse lifecycle on the host's logical clock
+     *  when one is supplied, while preserving the existing wall-clock default. */
+    private currentTime;
+    /** Resolve the one configuration-owned retention bound for both streaming
+     *  points and flow lines. Keeping it here prevents imperative push paths
+     *  from silently allocating a differently sized window. */
+    private getConfiguredWindowSize;
+    /** Trim the array-backed line collection only while it participates in a
+     *  stream. Bounded `setLines` snapshots remain complete until conversion. */
+    private retainNewestLines;
+    /** Rebuild both point resources from the same retained suffix so pulse
+     *  timestamps remain indexed to their matching point after a resize. */
+    private resizeStreamingWindow;
     updateConfig(config: Partial<GeoPipelineConfig>): void;
+    /** Additive explicit-result form of {@link updateConfig}. */
+    updateConfigWithResult(config: Partial<GeoPipelineConfig>): UpdateResult;
     setAreas(features: GeoJSON.Feature[]): void;
+    /** Additive explicit-result form of {@link setAreas}. */
+    setAreasWithResult(features: GeoJSON.Feature[]): UpdateResult;
     setPoints(data: Datum[]): void;
+    /** Additive explicit-result form of {@link setPoints}. */
+    setPointsWithResult(data: Datum[]): UpdateResult;
     setLines(data: Datum[]): void;
-    /** Initialize streaming mode with a ring buffer */
+    /** Additive explicit-result form of {@link setLines}. */
+    setLinesWithResult(data: Datum[]): UpdateResult;
+    /**
+     * Enter streaming mode while retaining the newest configured window from a
+     * bounded snapshot. The optional legacy argument is immediately reflected
+     * in config so the config remains the sole owner of the active capacity.
+     */
     initStreaming(windowSize?: number): void;
     /** Push a single streaming point */
     pushPoint(datum: Datum): void;
+    /** Additive explicit-result form of {@link pushPoint}. */
+    pushPointWithResult(datum: Datum): UpdateResult;
     /** Push multiple streaming points */
     pushMany(data: Datum[]): void;
+    /** Additive explicit-result form of {@link pushMany}. */
+    pushManyWithResult(data: Datum[]): UpdateResult;
     /** Append a single line/flow record (coordinates pre-resolved). Lines
-     *  aren't ring-buffered — the bounded set is the geography.
+     *  use array storage, then retain the active configured window in streaming mode.
      *  Mutates `lineData` in place to avoid the O(n) GC churn of an
      *  array spread per push. The mutation is invisible to callers
      *  because `setLines` defensive-copies on entry and `getLines`
@@ -74,6 +130,7 @@ export declare class GeoPipelineStore {
      */
     removePoint(id: string | string[]): Datum[];
     clear(): void;
+    restyleScene(selection: CustomLayoutSelection | null): void;
     computeScene(layout: StreamLayout): void;
     private fitProjection;
     /**
@@ -120,6 +177,8 @@ export declare class GeoPipelineStore {
     private applyCartogramTransform;
     private applyDecay;
     private applyPulse;
+    refreshPulse(now: number): boolean;
+    hasActivePulsesAt(now: number): boolean;
     get hasActivePulses(): boolean;
     private startTransition;
     /**

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

@@ -0,0 +1,64 @@
+import type { Datum } from "../charts/shared/datumTypes";
+import type { OnObservationCallback } from "../store/ObservationStore";
+import { type OnAnnotationActivateCallback } from "../charts/shared/annotationActivation";
+import * as React from "react";
+import type { ReactNode } from "react";
+import type { GradientLegendConfig, LegendGroup, LegendLayout } from "../types/legendTypes";
+import { type AutoPlaceAnnotations } from "../recipes/annotationLayout";
+interface GeoSVGOverlayProps {
+    width: number;
+    height: number;
+    totalWidth: number;
+    totalHeight: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /**
+     * Geo has no Cartesian axis scale, but this remains part of the internal
+     * contract because StreamGeoFrame historically used it to request an empty
+     * accessible overlay shell.
+     */
+    showAxes?: boolean;
+    title?: string | ReactNode;
+    legend?: ReactNode | {
+        legendGroups: LegendGroup[];
+    } | {
+        gradient: GradientLegendConfig;
+    };
+    legendHoverBehavior?: (item: {
+        label: string;
+    } | null) => void;
+    legendClickBehavior?: (item: {
+        label: string;
+    }) => void;
+    legendHighlightedCategory?: string | null;
+    legendIsolatedCategories?: Set<string>;
+    legendPosition?: "right" | "left" | "top" | "bottom";
+    legendLayout?: LegendLayout;
+    foregroundGraphics?: ReactNode;
+    annotations?: Datum[];
+    onAnnotationActivate?: OnAnnotationActivateCallback;
+    onObservation?: OnObservationCallback;
+    chartId?: string;
+    chartType?: string;
+    autoPlaceAnnotations?: AutoPlaceAnnotations;
+    pointNodes?: {
+        pointId?: string;
+        x: number;
+        y: number;
+        r: number;
+    }[];
+}
+/**
+ * The SVG chrome used by StreamGeoFrame.
+ *
+ * Geo previously imported the Cartesian SVGOverlay even though it never
+ * supplies scales, marginal graphics, grids, or linked-crosshair state. Keep
+ * the subset Geo actually exercises here so those XY-only dependencies do not
+ * enter the Geo bundle.
+ */
+export declare function GeoSVGOverlay(props: GeoSVGOverlayProps): React.JSX.Element | null;
+export {};

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

@@ -1,8 +1,9 @@
 import type { NetworkSceneNode, NetworkSceneEdge, NetworkCircleNode } from "./networkTypes";
 import type { Quadtree } from "d3-quadtree";
+import type { SceneDatum } from "./types";
 export interface NetworkHitResult {
     type: "node" | "edge";
-    datum: any;
+    datum: SceneDatum;
     x: number;
     y: number;
     distance: number;

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

@@ -1,10 +1,13 @@
 import { ParticlePool } from "./ParticlePool";
-import type { NetworkHtmlMark } from "./networkCustomLayout";
+import type { NetworkLayoutResult, NetworkHtmlMark } from "./networkCustomLayout";
 import type { CustomLayoutSelection } from "./customLayoutSelection";
+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.
  *
@@ -14,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;
@@ -31,6 +40,12 @@ export declare class NetworkPipelineStore {
     labels: NetworkLabel[];
     /** Overlays returned from customNetworkLayout (consumed by StreamNetworkFrame). */
     customLayoutOverlays: import("react").ReactNode;
+    /** Most recent custom layout result for host readback (`getCustomLayout()`).
+     *  Null before the first layout or without a custom layout. A failed rerun
+     *  retains this last successful result when its rendered scene is reusable. */
+    lastCustomLayoutResult: NetworkLayoutResult | null;
+    /** Latest custom-layout failure for frame-handle readback. */
+    lastCustomLayoutFailure: CustomLayoutFailureDiagnostic | null;
     /** HTML marks returned from customNetworkLayout — positioned DOM nodes the
      *  frame renders in a layer above the canvas/overlays (consumed by
      *  StreamNetworkFrame). Empty for built-in chart types. */
@@ -58,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 */
@@ -83,23 +101,42 @@ export declare class NetworkPipelineStore {
     lastTopologyChangeTime: number;
     private previousNodeIds;
     private previousEdgeKeys;
+    private _networkDecayCache;
     /** Snapshot of node positions from the last layout — used for force warm-start */
     _lastPositionSnapshot: Map<string, {
         x: number;
         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]): void;
+    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
+     * topology diffs, snapshots positions, and prepares transitions; it only
+     * skips the expensive simulation itself.
+     */
+    applyForceLayoutPositions(positions: Record<string, {
+        x: number;
+        y: number;
+    }>, size: [number, number]): void;
     /**
      * Unique key for an edge (same as TopologyStore).
      */
@@ -109,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.
      */
@@ -125,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.
@@ -198,37 +230,13 @@ export declare class NetworkPipelineStore {
     private restorePreviousPositions;
     private snapToTargets;
     private updateEdgeBezier;
-    private buildStandardBezier;
-    private buildCircularBezier;
     rebuildAllBeziers(): void;
-    /**
-     * Apply pulse glow to scene nodes/edges based on their creation timestamps.
-     */
     applyPulse(now: number): void;
-    /**
-     * Apply decay opacity to scene nodes based on topology age order.
-     * Older nodes (created earlier) are more faded.
-     */
     applyDecay(): void;
-    /**
-     * Apply topology diff highlight — newly added nodes glow briefly.
-     * Duration: 2 seconds from lastTopologyChangeTime.
-     */
     applyTopologyDiff(now: number): void;
-    /** Whether there is an active topology diff animation */
     get hasActiveTopologyDiff(): boolean;
-    /**
-     * Apply threshold alerting to scene nodes.
-     * Overrides fill color and adds pulse for nodes exceeding thresholds.
-     */
     applyThresholds(now: number): void;
-    /**
-     * Whether there are active threshold alerts on any node.
-     */
     get hasActiveThresholds(): boolean;
-    /**
-     * Whether there are active pulse animations (recent ingests within pulse duration).
-     */
     get hasActivePulses(): boolean;
     getLayoutData(): {
         nodes: RealtimeNode[];

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

@@ -5,6 +5,9 @@ import type { NetworkLabel } from "./networkTypes";
 import type { LegendGroup, GradientLegendConfig, LegendLayout } from "../types/legendTypes";
 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;
@@ -19,8 +22,10 @@ type AnnotationAnchorNode = {
     r?: number;
     /** Arc nodes (chord, radial) carry an outer radius. */
     outerR?: number;
-    /** Symbol nodes (the per-datum glyph channel) carry a d3-symbol area. */
+    /** Symbol nodes carry a d3-symbol area; glyph nodes reuse `size` as rendered height. */
     size?: number;
+    /** Glyph nodes (the composite-pictogram channel) carry a definition. */
+    glyph?: GlyphDef;
 };
 type NetworkAnnotationContext = AnnotationContext & {
     sceneNodes?: AnnotationAnchorNode[];
@@ -72,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/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;