semiotic 3.4.1 → 3.5.0

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

@@ -0,0 +1,15 @@
+import * as React from "react";
+/**
+ * Compose a stack of overlay ReactNodes into a single fragment, dropping
+ * null/undefined sources. Each frame paints its `resolvedForeground`
+ * (axes, legends, annotations, react overlay) and may layer additional
+ * sources on top — currently `customLayoutOverlays` from recipe-managed
+ * chrome, with brush UIs and recipe-owned legends planned. Centralising
+ * the merge here keeps SSR and client branches in sync and gives future
+ * overlay sources one obvious place to plug in.
+ *
+ * Returns the single non-null source as-is when only one is present
+ * (avoids an unnecessary fragment); returns `null` when every source is
+ * absent so callers can skip the overlay subtree entirely.
+ */
+export declare function composeOverlays(...sources: Array<React.ReactNode | null | undefined>): React.ReactNode;

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

@@ -0,0 +1,76 @@
+import type { ReactNode } from "react";
+import type { Datum } from "../charts/shared/datumTypes";
+import type { MarginType } from "../types/marginType";
+import type { SceneNode, StreamScales, Style, ThemeSemanticColors } from "./types";
+/**
+ * customLayout — escape hatch for bespoke chart geometry.
+ *
+ * A customLayout function receives the same context the built-in scene
+ * builders use (scales, theme, resolvers, dimensions) and returns scene
+ * nodes. The frame still owns hit testing, transitions, decay, theme
+ * cascade, and SSR — the layout owns geometry only.
+ *
+ * Surface is intentionally narrow. Resist adding fields until a real
+ * recipe demands them.
+ */
+export type CustomLayout<C extends object = Record<string, unknown>> = (ctx: LayoutContext<C>) => LayoutResult;
+/**
+ * Context handed to every customLayout invocation. Six fields:
+ * data, scales, dimensions, theme, resolveColor, config.
+ *
+ * `resolveColor` is the contract that makes user layouts theme-aware —
+ * always prefer it over hardcoded color literals. `--doctor` flags
+ * layouts that emit nodes with literal hex/rgb fills.
+ */
+export interface LayoutContext<C extends object = Record<string, unknown>> {
+    /** Buffered, post-filter data the frame is currently drawing. */
+    data: Datum[];
+    /** Scales constructed by the frame from the resolved x/y domains. */
+    scales: StreamScales;
+    /**
+     * Plot-area geometry. All scene-node coordinates are plot-relative —
+     * the canvas/SVG group already lives inside `margin.left`/`margin.top`,
+     * so `width`/`height` describe the plot rect (same as `plot.width`/
+     * `plot.height`). Read `margin` if you need the outer canvas size.
+     */
+    dimensions: {
+        width: number;
+        height: number;
+        margin: MarginType;
+        plot: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    };
+    /** Theme-resolved semantic colors + categorical palette. */
+    theme: {
+        semantic: ThemeSemanticColors;
+        categorical: string[];
+    };
+    /**
+     * Resolves a color for a given group/category, honoring
+     * CategoryColorProvider → colorScheme → theme cascade. Always prefer
+     * this over hardcoded literals.
+     */
+    resolveColor: (group: string, datum?: Datum) => string;
+    /** User-supplied config blob threaded through `layoutConfig`. */
+    config: C;
+}
+export interface LayoutResult {
+    /** Scene nodes to render. Get hit testing, transitions, decay, SSR for free. */
+    nodes?: SceneNode[];
+    /** SVG overlays composited above the canvas (labels, annotations). */
+    overlays?: ReactNode;
+}
+/**
+ * Note on extents: customLayout v1 does not return extents. Layouts that
+ * need to drive axis domains (e.g. horizon banding a continuous series)
+ * should pass `xExtent` / `yExtent` props on the chart — those flow into
+ * scale construction *before* the layout runs, so the layout sees correct
+ * scales. Layouts that don't use scales (waffle, calendar, treemap) can
+ * ignore extents entirely.
+ */
+/** Convenience helper: build a Style object that defers fill/stroke to the theme. */
+export declare function themedStyle(color: string, overrides?: Style): Style;

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

@@ -0,0 +1,29 @@
+import { STREAMING_PALETTE } from "../charts/shared/colorUtils";
+import { schemeCategory10 } from "../charts/shared/colorPalettes";
+/**
+ * Shared palette resolution for the network and ordinal customLayout
+ * escape hatches. XY's customLayout uses `PipelineStore.resolveGroupColor`
+ * (richer cascade with CategoryColorProvider integration) so it doesn't
+ * call this helper.
+ *
+ * Precedence:
+ *   1. Explicit `colorScheme` array — used as-is.
+ *   2. Named scheme string (e.g. "tableau10") — looked up in
+ *      `COLOR_SCHEMES`. Unknown names fall through.
+ *   3. Theme categorical (when non-empty).
+ *   4. The provided fallback palette.
+ *
+ * @param colorScheme   `colorScheme` from the chart's pipeline config
+ * @param themeCategorical  `themeCategorical` from theme resolution
+ * @param fallback      Palette to use when nothing else matches.
+ *                      Network passes `schemeCategory10`; ordinal passes
+ *                      `STREAMING_PALETTE`. Caller's choice.
+ */
+export declare function resolveCustomLayoutPalette(colorScheme: string | string[] | undefined, themeCategorical: string[] | undefined, fallback: readonly string[]): readonly string[];
+/**
+ * Build a stable hash → palette index resolver. Used by the network and
+ * ordinal customLayout contexts so the same key always returns the same
+ * color for the lifetime of the closure.
+ */
+export declare function buildResolveColor(palette: readonly string[]): (key: string) => string;
+export { schemeCategory10, STREAMING_PALETTE };

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

@@ -1,6 +1,7 @@
 import type { ReactNode } from "react";
 import type { GeoProjection, GeoPath, GeoPermissibleObjects } from "d3-geo";
-import type { Style, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig, PointSceneNode, LineSceneNode, ThemeSemanticColors } from "./types";
+import type { GradientLegendConfig, LegendGroup } from "../types/legendTypes";
+import type { Style, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig, SceneDatum, PointSceneNode, ThemeSemanticColors } from "./types";
 import type { AnimateProp } from "./pipelineTransitionUtils";
 import type { HoverAnnotationConfig, HoverData } from "../realtime/types";
 import type { GeoParticleStyle } from "./GeoParticlePool";
@@ -38,7 +39,7 @@ export interface GeoAreaSceneNode {
     /** Screen-space area in px² */
     screenArea: number;
     style: Style;
-    datum: any;
+    datum: SceneDatum;
     group?: string;
     interactive?: boolean;
     /** Lazily-cached Path2D parsed from pathData (avoids re-parsing on every hit test) */
@@ -47,8 +48,15 @@ export interface GeoAreaSceneNode {
     _pulseIntensity?: number;
     _pulseColor?: string;
 }
+export interface GeoLineSceneNode {
+    type: "line";
+    path: [number, number][];
+    style: Style;
+    datum: SceneDatum;
+    group?: string;
+}
 /** Union of all scene node types that GeoFrame produces */
-export type GeoSceneNode = GeoAreaSceneNode | PointSceneNode | LineSceneNode;
+export type GeoSceneNode = GeoAreaSceneNode | PointSceneNode | GeoLineSceneNode;
 export interface GeoScales {
     projection: GeoProjection;
     geoPath: GeoPath<any, GeoPermissibleObjects>;
@@ -62,7 +70,7 @@ export interface GeoPipelineConfig {
     fitPadding?: number;
     xAccessor?: string | ((d: Datum) => number);
     yAccessor?: string | ((d: Datum) => number);
-    lineDataAccessor?: string | ((d: Datum) => any[]);
+    lineDataAccessor?: string | ((d: Datum) => Datum[]);
     lineType?: "geo" | "line";
     /** Flow rendering style: "basic" (straight/great-circle), "offset" (bidirectional offset), "arc" (curved arcs) @default "basic" */
     flowStyle?: "basic" | "offset" | "arc";
@@ -70,7 +78,7 @@ export interface GeoPipelineConfig {
     pointStyle?: (d: Datum) => Style & {
         r?: number;
     };
-    lineStyle?: Style | ((d: any, group?: string) => Style);
+    lineStyle?: Style | ((d: Datum, group?: string) => Style);
     colorScheme?: string | string[];
     /** Theme-resolved semantic role colors — default fallback before hardcoded hex. See `ThemeSemanticColors` in ./types. */
     themeSemantic?: ThemeSemanticColors;
@@ -98,7 +106,7 @@ export interface StreamGeoFrameProps<T = Datum> {
     lines?: T[];
     xAccessor?: string | ((d: T) => number);
     yAccessor?: string | ((d: T) => number);
-    lineDataAccessor?: string | ((d: T) => any[]);
+    lineDataAccessor?: string | ((d: T) => Datum[]);
     pointIdAccessor?: string | ((d: T) => string);
     lineType?: "geo" | "line";
     /** Flow rendering style: "basic" (straight/great-circle), "offset" (bidirectional offset), "arc" (curved arcs) @default "basic" */
@@ -145,8 +153,17 @@ export interface StreamGeoFrameProps<T = Datum> {
     pointStyle?: (d: Datum) => Style & {
         r?: number;
     };
-    lineStyle?: Style | ((d: any, group?: string) => Style);
+    lineStyle?: Style | ((d: Datum, group?: string) => Style);
     colorScheme?: string | string[];
+    /**
+     * Categorical color field. For ChoroplethMap reads from area `properties`
+     * (or top-level fallback); for ProportionalSymbolMap reads from each point.
+     * Server-side legend auto-build groups by this field when `showLegend` is
+     * set and no explicit `legend` prop is provided. The function form accepts
+     * either the point datum `T` or a GeoJSON Feature so choropleth callers can
+     * write `(f) => f.properties.region` without a cast.
+     */
+    colorBy?: string | ((d: T | GeoJSON.Feature) => string);
     enableHover?: boolean;
     hoverAnnotation?: boolean | HoverAnnotationConfig;
     tooltipContent?: (d: HoverData) => ReactNode;
@@ -164,7 +181,11 @@ export interface StreamGeoFrameProps<T = Datum> {
     backgroundGraphics?: ReactNode;
     foregroundGraphics?: ReactNode;
     title?: string | ReactNode;
-    legend?: any;
+    legend?: ReactNode | {
+        legendGroups: LegendGroup[];
+    } | {
+        gradient: GradientLegendConfig;
+    };
     legendPosition?: "right" | "left" | "top" | "bottom";
     legendHoverBehavior?: (item: {
         label: string;
@@ -174,6 +195,10 @@ export interface StreamGeoFrameProps<T = Datum> {
     }) => void;
     legendHighlightedCategory?: string | null;
     legendIsolatedCategories?: Set<string>;
+    /** Accessor used to report the current legend category domain in push mode. */
+    legendCategoryAccessor?: string | ((d: T) => string);
+    /** Fires when the current legend category domain changes after scene rebuilds. */
+    onCategoriesChange?: (categories: string[]) => void;
     showAxes?: boolean;
     /** Render a visually-hidden data table from the scene graph for screen readers */
     accessibleTable?: boolean;

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

@@ -1,4 +1,3 @@
-import type { Datum } from "../charts/shared/datumTypes";
 /**
  * Shared hover data utilities for stream frames.
  *
@@ -20,16 +19,11 @@ export interface HoverPointerCoords {
     clientX: number;
     clientY: number;
 }
-/**
- * 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): Datum;
 /**
  * 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).
+ * The raw datum is preserved as `hover.data` for tooltip / callback
+ * consumers; pixel coordinates land on `x` / `y`. Anything else
+ * relevant to a specific frame family — `category`, `stats`,
+ * `nodeOrEdge`, `xValue`, etc. — is layered in via `extra`.
  */
 export declare function buildHoverData(rawDatum: any, x: number, y: number, extra?: Partial<HoverData>): HoverData;

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

@@ -10,10 +10,15 @@
  * HoverData state that mouse hover does.
  */
 import type { HoverData } from "../realtime/types";
+import type { Datum } from "../charts/shared/datumTypes";
+import type { NetworkSceneEdge, NetworkSceneNode } from "./networkTypes";
+import type { SceneNode } from "./types";
+import type { OrdinalSceneNode } from "./ordinalTypes";
+import type { GeoSceneNode } from "./geoTypes";
 export interface NavPoint {
     x: number;
     y: number;
-    datum: any;
+    datum: Datum | null;
     /** Shape hint for focus ring rendering */
     shape?: "circle" | "rect" | "wedge";
     /** Width of rect-shaped elements (bars, sankey nodes) */
@@ -73,18 +78,18 @@ export declare function nextGraphIndex(key: string, pos: NavPosition, graph: Nav
  * Lines/areas carry a `group` field identifying the series.
  * ArrowRight/Left = within series, ArrowUp/Down = switch series.
  */
-export declare function extractXYNavPoints(scene: any[]): NavPoint[];
+export declare function extractXYNavPoints(scene: SceneNode[]): NavPoint[];
 /**
  * Extract navigable points from ordinal scene nodes.
  * 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[];
+export declare function extractOrdinalNavPoints(scene: OrdinalSceneNode[]): NavPoint[];
 /**
  * Extract navigable points from network scene nodes.
  * Each node's group is its own id, enabling neighbor traversal via edges.
  */
-export declare function extractNetworkNavPoints(scene: any[]): NavPoint[];
+export declare function extractNetworkNavPoints(scene: NetworkSceneNode[]): NavPoint[];
 /**
  * Network-specific navigation: spatial arrow keys + edge following.
  *
@@ -94,14 +99,20 @@ export declare function extractNetworkNavPoints(scene: any[]): NavPoint[];
  *
  * 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: {
+export declare function nextNetworkIndex(key: string, pos: NavPosition, graph: NavGraph, edges: EdgeLike[], neighborIndexRef: {
     current: number;
 }): number | null;
+/** Collect neighbor node ids from edge list for a given node. */
+type EdgeLike = NetworkSceneEdge | {
+    source?: unknown;
+    target?: unknown;
+    datum?: Datum | null;
+};
 /**
  * Extract navigable points from geo scene nodes.
  * Flat navigation only (no meaningful grouping for geo).
  */
-export declare function extractGeoNavPoints(scene: any[]): NavPoint[];
+export declare function extractGeoNavPoints(scene: GeoSceneNode[]): NavPoint[];
 /**
  * Compute the next focus index given a key and current index.
  * Returns -1 to clear focus. Returns null for unhandled keys.
@@ -113,3 +124,4 @@ export declare function nextIndex(key: string, current: number, total: number):
  * Convert a NavPoint to HoverData for the tooltip system.
  */
 export declare function navPointToHover(point: NavPoint): HoverData;
+export {};

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

@@ -0,0 +1,67 @@
+import type { ReactNode } from "react";
+import type { NetworkSceneNode, NetworkSceneEdge, NetworkLabel, RealtimeNode, RealtimeEdge } from "./networkTypes";
+import type { ThemeSemanticColors } from "./types";
+/**
+ * customLayout escape hatch for `StreamNetworkFrame`.
+ *
+ * A network layout is a pure function: given raw nodes/edges plus the
+ * frame's dimensions/theme, return positioned scene primitives — circles,
+ * rects, lines, beziers — and optional labels/overlays. The frame still
+ * owns hit testing, decay, accessibility, and SSR.
+ *
+ * Mirrors the XY `CustomLayout` pattern. Reach for it when the catalog
+ * (force, sankey, chord, tree, treemap, circle-pack, orbit) doesn't fit
+ * — e.g. `d3-flextree`, `dagre`, custom radial layouts.
+ */
+export type NetworkCustomLayout<C extends object = Record<string, unknown>> = (ctx: NetworkLayoutContext<C>) => NetworkLayoutResult;
+export interface NetworkLayoutContext<C extends object = Record<string, unknown>> {
+    /** Raw nodes from the data prop / push API. May or may not have positions. */
+    nodes: RealtimeNode[];
+    /** Raw edges. Source/target may be id strings or node references. */
+    edges: RealtimeEdge[];
+    /**
+     * Plot-area geometry. All scene-node coordinates are plot-relative —
+     * the canvas/SVG group already lives inside `margin.left`/`margin.top`.
+     */
+    dimensions: {
+        width: number;
+        height: number;
+        plot: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    };
+    /** Theme-resolved semantic + categorical colors. */
+    theme: {
+        semantic: ThemeSemanticColors;
+        categorical: string[];
+    };
+    /**
+     * Resolves a stable color for a given key (typically a node id or
+     * category) by hashing into the frame-resolved categorical palette.
+     * The palette comes from `colorScheme` (array or named d3 scheme like
+     * `"tableau10"` / `"set3"`), then the active theme's `categorical`,
+     * then a fallback. The same key always returns the same color for the
+     * lifetime of this store.
+     *
+     * Note: this does *not* honor `CategoryColorProvider` — network charts
+     * don't currently thread that into the pipeline. If you need
+     * cross-chart category color sync, pass a matching `colorScheme` to
+     * each chart instead.
+     */
+    resolveColor: (key: string) => string;
+    /** User-supplied config blob threaded through `layoutConfig`. */
+    config: C;
+}
+export interface NetworkLayoutResult {
+    /** Positioned scene primitives. Circles, rects, or arcs. */
+    sceneNodes?: NetworkSceneNode[];
+    /** Positioned edges. Lines, beziers, ribbons, or curved. */
+    sceneEdges?: NetworkSceneEdge[];
+    /** Optional labels placed at arbitrary plot-relative positions. */
+    labels?: NetworkLabel[];
+    /** SVG overlays composited above the canvas. */
+    overlays?: ReactNode;
+}

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

@@ -2,7 +2,7 @@ import type { ReactNode } from "react";
 import type { OnObservationCallback } from "../store/ObservationStore";
 import type { HoverData, AnnotationContext } from "../realtime/types";
 import type { LegendGroup } from "../types/legendTypes";
-import type { Style, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig, ThemeSemanticColors } from "./types";
+import type { Style, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig, ThemeSemanticColors, SceneDatum } from "./types";
 import type { AnimateProp } from "./pipelineTransitionUtils";
 import type { Datum } from "../charts/shared/datumTypes";
 export interface TensionConfig {
@@ -40,6 +40,29 @@ export interface RealtimeNode {
     _pulseIntensity?: number;
     _pulseColor?: string;
     _pulseGlowRadius?: number;
+    /**
+     * @internal Hierarchy-layout-only extension fields. Set by
+     * `hierarchyLayoutPlugin` / `orbitLayoutPlugin` during layout and
+     * read by `hierarchySceneBuilders`. Typed `unknown` because the d3
+     * `HierarchyNode` shape is layout-specific (rectangular, circular,
+     * point) — consumers narrow with the structural fields they need.
+     */
+    __hierarchyNode?: unknown;
+    /** @internal Circle-pack layout radius. Set by `hierarchyLayoutPlugin`. */
+    __radius?: number;
+    /**
+     * @internal Chord-layout extension. Carries the start/end angles
+     * for the arc segment representing this node, computed by
+     * `chordLayoutPlugin` and read by its `buildScene`. Concretely
+     * typed (unlike `__hierarchyNode`) because chord is the only
+     * layout that writes this field, so the shape is fixed — no
+     * narrowing-at-read needed. `__` prefix matches the convention
+     * used by `__hierarchyNode` / `__radius` on this same interface.
+     */
+    __arcData?: {
+        startAngle: number;
+        endAngle: number;
+    };
 }
 export interface RealtimeEdge {
     source: RealtimeNode | string;
@@ -58,7 +81,7 @@ export interface RealtimeEdge {
     _introFromZero?: boolean;
     direction?: string;
     circular?: boolean;
-    circularPathData?: any;
+    circularPathData?: CircularPathData;
     bezier?: BezierCache;
     data?: Datum;
     /** Unique key for this edge (supports parallel edges between same node pair) */
@@ -69,6 +92,17 @@ export interface RealtimeEdge {
     /** @internal Circular sankey layout fields */
     _circularWidth?: number;
     _circularStub?: boolean;
+    /**
+     * @internal Chord-layout extension. Carries the d3-chord-generated
+     * source/target arc spans for this edge, set by `chordLayoutPlugin`
+     * during `computeLayout` and read by its `buildScene`. Typed
+     * `unknown` because the d3 `Chord` interface lives in `d3-chord`
+     * and importing the type here would couple `networkTypes` to that
+     * dep — consumers narrow at the read site. `__` prefix matches the
+     * `_circularWidth` / `_circularStub` internal-field convention on
+     * this same interface.
+     */
+    __chordData?: unknown;
 }
 export interface BezierPoint {
     x: number;
@@ -80,6 +114,27 @@ export interface BezierCache {
     segments?: Array<[BezierPoint, BezierPoint, BezierPoint, BezierPoint]>;
     halfWidth: number;
 }
+export interface CircularPathData {
+    sourceX: number;
+    targetX: number;
+    sourceY: number;
+    targetY: number;
+    rightFullExtent: number;
+    leftFullExtent: number;
+    verticalFullExtent: number;
+    rightInnerExtent: number;
+    leftInnerExtent: number;
+    verticalRightInnerExtent: number;
+    verticalLeftInnerExtent: number;
+    rightSmallArcRadius: number;
+    rightLargeArcRadius: number;
+    leftSmallArcRadius: number;
+    leftLargeArcRadius: number;
+    sourceWidth: number;
+    rightNodeBuffer: number;
+    leftNodeBuffer: number;
+    arcRadius: number;
+}
 export interface Particle {
     t: number;
     offset: number;
@@ -133,7 +188,7 @@ export interface RealtimeNetworkFrameProps {
     enableHover?: boolean;
     tooltipContent?: (d: {
         type: "node" | "edge";
-        data: any;
+        data: Datum | null;
     }) => ReactNode;
     onTopologyChange?: (nodes: RealtimeNode[], edges: RealtimeEdge[]) => void;
     background?: string;
@@ -147,7 +202,7 @@ export interface NetworkCircleNode {
     cy: number;
     r: number;
     style: Style;
-    datum: any;
+    datum: SceneDatum;
     id?: string;
     label?: string;
     depth?: number;
@@ -163,7 +218,7 @@ export interface NetworkRectNode {
     w: number;
     h: number;
     style: Style;
-    datum: any;
+    datum: SceneDatum;
     id?: string;
     label?: string;
     depth?: number;
@@ -184,7 +239,7 @@ export interface NetworkArcNode {
     /** End angle in radians, canvas convention */
     endAngle: number;
     style: Style;
-    datum: any;
+    datum: SceneDatum;
     id?: string;
     label?: string;
     _pulseIntensity?: number;
@@ -199,7 +254,7 @@ export interface NetworkLineEdge {
     x2: number;
     y2: number;
     style: Style;
-    datum: any;
+    datum: SceneDatum;
     _pulseIntensity?: number;
     _pulseColor?: string;
 }
@@ -209,7 +264,7 @@ export interface NetworkBezierEdge {
     pathD: string;
     bezierCache?: BezierCache;
     style: Style;
-    datum: any;
+    datum: SceneDatum;
     _pulseIntensity?: number;
     _pulseColor?: string;
     /** Lazily-built Path2D for hit testing; invalidated when pathD changes. */
@@ -221,7 +276,7 @@ export interface NetworkRibbonEdge {
     type: "ribbon";
     pathD: string;
     style: Style;
-    datum: any;
+    datum: SceneDatum;
     _pulseIntensity?: number;
     _pulseColor?: string;
     _cachedPath2D?: Path2D;
@@ -232,7 +287,7 @@ export interface NetworkCurvedEdge {
     type: "curved";
     pathD: string;
     style: Style;
-    datum: any;
+    datum: SceneDatum;
     _pulseIntensity?: number;
     _pulseColor?: string;
     _cachedPath2D?: Path2D;
@@ -306,18 +361,18 @@ export interface NetworkPipelineConfig {
     valueAccessor?: string | ((d: Datum) => number);
     /** Edge ID accessor for removeEdge(edgeId) — enables single-ID edge removal */
     edgeIdAccessor?: string | ((d: Datum) => string);
-    childrenAccessor?: string | ((d: Datum) => any[]);
+    childrenAccessor?: string | ((d: Datum) => Datum[]);
     hierarchySum?: string | ((d: Datum) => number);
     orientation?: "horizontal" | "vertical";
     nodeAlign?: "justify" | "left" | "right" | "center";
     nodePaddingRatio?: number;
     nodeWidth?: number;
-    edgeSort?: (a: any, b: any) => number;
+    edgeSort?: (a: unknown, b: unknown) => number;
     iterations?: number;
     forceStrength?: number;
     padAngle?: number;
     groupWidth?: number;
-    sortGroups?: (a: any, b: any) => number;
+    sortGroups?: (a: unknown, b: unknown) => number;
     treeOrientation?: "vertical" | "horizontal" | "radial";
     edgeType?: "line" | "curve";
     padding?: number;
@@ -352,11 +407,11 @@ export interface NetworkPipelineConfig {
      *  "atomic" ([2,8] electron shell), or custom capacities. @default "flat" */
     orbitMode?: "flat" | "solar" | "atomic" | number[];
     /** Ring size divisor per depth. Larger = tighter orbits. @default 2.95 */
-    orbitSize?: number | ((node: any) => number);
+    orbitSize?: number | ((node: Datum) => number);
     /** Orbit speed multiplier (higher = faster rotation). @default 0.25 */
     orbitSpeed?: number;
     /** Per-node speed modifier. @default (node) => 1 / (node.depth + 1) */
-    orbitRevolution?: (node: any) => number;
+    orbitRevolution?: (node: Datum) => number;
     /**
      * Built-in revolution style presets:
      * - "locked": children rotate with parent at decreasing speed (default)
@@ -367,7 +422,7 @@ export interface NetworkPipelineConfig {
      */
     orbitRevolutionStyle?: "locked" | "decay" | "alternate";
     /** Vertical squash for elliptical orbits. 1 = circle. @default 1 */
-    orbitEccentricity?: number | ((node: any) => number);
+    orbitEccentricity?: number | ((node: Datum) => number);
     /** Show orbital ring ellipses as foreground graphics. @default true */
     orbitShowRings?: boolean;
     /** Enable orbit animation. @default true */
@@ -381,6 +436,11 @@ export interface NetworkPipelineConfig {
         x: number;
         y: number;
     }>;
+    /** When provided, replaces both layout dispatch and scene building.
+     *  Receives raw nodes/edges and returns positioned scene primitives. */
+    customNetworkLayout?: import("./networkCustomLayout").NetworkCustomLayout;
+    /** User-supplied config blob threaded through to NetworkLayoutContext.config. */
+    layoutConfig?: object;
 }
 export interface StreamNetworkFrameProps<T = Datum> {
     chartType: NetworkChartType;
@@ -405,8 +465,8 @@ export interface StreamNetworkFrameProps<T = Datum> {
     forceStrength?: number;
     padAngle?: number;
     groupWidth?: number;
-    sortGroups?: (a: any, b: any) => number;
-    edgeSort?: (a: any, b: any) => number;
+    sortGroups?: (a: unknown, b: unknown) => number;
+    edgeSort?: (a: unknown, b: unknown) => number;
     treeOrientation?: "vertical" | "horizontal" | "radial";
     edgeType?: "line" | "curve";
     padding?: number;
@@ -473,11 +533,11 @@ export interface StreamNetworkFrameProps<T = Datum> {
     staleness?: StalenessConfig;
     thresholds?: ThresholdAlertConfig;
     orbitMode?: "flat" | "solar" | "atomic" | number[];
-    orbitSize?: number | ((node: any) => number);
+    orbitSize?: number | ((node: Datum) => number);
     orbitSpeed?: number;
-    orbitRevolution?: (node: any) => number;
+    orbitRevolution?: (node: Datum) => number;
     orbitRevolutionStyle?: "locked" | "decay" | "alternate";
-    orbitEccentricity?: number | ((node: any) => number);
+    orbitEccentricity?: number | ((node: Datum) => number);
     orbitShowRings?: boolean;
     orbitAnimated?: boolean;
     /** Render a visually-hidden data table from the scene graph for screen readers */
@@ -486,6 +546,12 @@ export interface StreamNetworkFrameProps<T = Datum> {
     description?: string;
     /** Accessible summary rendered as a screen-reader-only note */
     summary?: string;
+    /** Replaces network layout + scene dispatch with a user-supplied function.
+     *  Receives raw nodes/edges + dimensions/theme, returns positioned scene
+     *  primitives. See `semiotic/recipes` for reference layouts (flextree, dagre). */
+    customNetworkLayout?: import("./networkCustomLayout").NetworkCustomLayout;
+    /** User-supplied config blob threaded through to NetworkLayoutContext.config. */
+    layoutConfig?: object;
 }
 export interface StreamNetworkFrameHandle {
     push(edge: EdgePush): void;