semiotic 3.7.4 → 3.8.0

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

@@ -0,0 +1,32 @@
+import type { Datum } from "../charts/shared/datumTypes";
+import type { SemioticTheme } from "./ThemeStore";
+/**
+ * Convert a SemioticTheme to a CSS custom properties string.
+ * Useful for SSR or generating stylesheet content.
+ *
+ * @param theme - A SemioticTheme object
+ * @param selector - CSS selector to scope the variables (default: `:root`)
+ * @returns CSS string with custom properties
+ *
+ * @example
+ * ```ts
+ * const css = themeToCSS(TUFTE_LIGHT, ".my-charts")
+ * // .my-charts {
+ * //   --semiotic-bg: #fffff8;
+ * //   --semiotic-text: #111111;
+ * //   ...
+ * // }
+ * ```
+ */
+export declare function themeToCSS(theme: SemioticTheme, selector?: string): string;
+/**
+ * Convert a SemioticTheme to a design tokens JSON object.
+ * Compatible with Style Dictionary / Design Token Community Group format.
+ *
+ * @example
+ * ```ts
+ * const tokens = themeToTokens(TUFTE_LIGHT)
+ * // { semiotic: { bg: { $value: "#fffff8", $type: "color" }, ... } }
+ * ```
+ */
+export declare function themeToTokens(theme: SemioticTheme): Datum;

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

@@ -2,6 +2,7 @@ import type { Datum } from "../charts/shared/datumTypes";
 import { type DataSummary } from "../data/DataSummarizer";
 import type { ChartDataProfile, Suggestion } from "../ai/chartCapabilityTypes";
 import type { IntentId } from "../ai/intents";
+import { type ChartReaderGrounding, type ChartReaderGroundingOptions } from "../ai/readerGrounding";
 /**
  * Identifies a single point of interest on the chart — typically the datum
  * the user is currently hovering, clicked, or otherwise focused on. When
@@ -31,6 +32,8 @@ export interface InterrogationContext {
     componentName?: string;
     /** Optional caller-supplied chart props (accessor names, scales, etc.). */
     props?: Record<string, unknown>;
+    /** Optional reader-grounding payload for faithful chart interpretation. */
+    grounding?: ChartReaderGrounding;
     /**
      * The current focused datum — what the user is interactively pointing at.
      * Lets the LLM tailor responses to a specific point ("why is *this* one
@@ -82,6 +85,12 @@ export interface UseChartInterrogationOptions {
      * `onObservation` callback or the convenience `useChartFocus` hook.
      */
     focus?: InterrogationFocus | null;
+    /**
+     * Include `buildReaderGrounding()` in the interrogation context. Pass true
+     * for default grounding, or an options object for capability/audience,
+     * structure, and physics runtime grounding controls.
+     */
+    includeGrounding?: boolean | ChartReaderGroundingOptions;
 }
 export interface UseChartInterrogationResult {
     /** Ask a question. Updates history, annotations, loading, and error. */

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

@@ -1,9 +1,7 @@
 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;
-};
+import { type AccessibleSceneNode as AnySceneNode } from "./accessibleDataRows";
+export { extractAllRows } from "./accessibleDataRows";
+export type { DataRow } from "./accessibleDataRows";
 declare const SR_ONLY_STYLE: React.CSSProperties;
 /**
  * Compute an aria-label describing the chart type and data shape from the scene graph.
@@ -13,14 +11,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;

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/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/GeoPipelineStore.d.ts

@@ -4,11 +4,29 @@ 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";
+import type { GeoLayoutResult } from "./geoCustomLayout";
+import type { CustomLayoutSelection } from "./customLayoutSelection";
+import { type CustomLayoutFailureDiagnostic } from "./customLayoutFailure";
 export declare class GeoPipelineStore {
     config: GeoPipelineConfig;
     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
@@ -74,6 +92,16 @@ export declare class GeoPipelineStore {
      */
     removePoint(id: string | string[]): Datum[];
     clear(): void;
+    setLayoutSelection(selection: CustomLayoutSelection | null): void;
+    /**
+     * "Styles changed, repaint the data canvas without rebuilding the scene."
+     * Set by {@link restyleScene}; consumed once per frame by the paint loop, so a
+     * style-only selection change repaints without a projection/scene recompute.
+     */
+    private _stylePaintPending;
+    /** Consume the style-only repaint signal (see {@link _stylePaintPending}). */
+    consumeStylePaintPending(): boolean;
+    restyleScene(selection: CustomLayoutSelection | null): void;
     computeScene(layout: StreamLayout): void;
     private fitProjection;
     /**

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

@@ -0,0 +1,44 @@
+import * as React from "react";
+import type { NetworkHtmlMark } from "./networkCustomLayout";
+import type { CustomLayoutSelection } from "./customLayoutSelection";
+export interface NetworkHtmlMarksLayerProps {
+    /** Marks emitted by the custom layout (`NetworkLayoutResult.htmlMarks`). */
+    marks: NetworkHtmlMark[] | undefined;
+    /** The frame's margin — the layer is offset by it so marks align with the
+     *  canvas and SVG `overlays`, which translate their content by the same. */
+    margin: {
+        top: number;
+        left: number;
+    };
+    /** Shared-selection projection, provided so mark content can subscribe via
+     *  `useCustomLayoutSelection()` and restyle on selection change without a
+     *  relayout (parity with the SVG `overlays` subtree). `null` when unwired. */
+    selection?: CustomLayoutSelection | null;
+    /**
+     * Pixels beyond each visible edge of the scrolling viewport for which marks are
+     * still mounted (so a scroll reveals already-present DOM, not blank space).
+     * Marks farther than this off-screen are not rendered at all. Defaults to 400.
+     */
+    overscan?: number;
+}
+/**
+ * Renders a custom network layout's {@link NetworkHtmlMark}s into one
+ * absolutely-positioned DOM layer above the canvas and SVG `overlays`.
+ *
+ * Each mark is its own positioned element, keyed by `id`, so the browser can
+ * composite `opacity`/`transform`/`visibility` changes on the mark's content
+ * without re-rasterizing it (the win over SVG `<foreignObject>`), and a
+ * position-only layout re-run repositions without remounting. The wrapper sets
+ * only placement + sizing + `pointer-events`; everything visual comes from
+ * `content`.
+ *
+ * Marks are viewport-culled against the nearest scrollable ancestor (plus
+ * `overscan`): a mark more than `overscan` px outside the visible window is not
+ * in the DOM at all, so a large topology mounts only roughly a viewport's worth
+ * regardless of total size, and the per-hover/paint cost stays bounded. When
+ * there's no scrollable ancestor (the content fits) every mark renders.
+ *
+ * Returns `null` when there are no marks, so layouts that don't use the feature
+ * render no extra DOM.
+ */
+export declare function NetworkHtmlMarksLayer({ marks, margin, selection, overscan, }: NetworkHtmlMarksLayerProps): React.ReactElement | null;

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

@@ -1,4 +1,7 @@
 import { ParticlePool } from "./ParticlePool";
+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";
@@ -29,6 +32,27 @@ 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. */
+    customLayoutHtmlMarks: NetworkHtmlMark[];
+    private _customLayoutDiagnosticsWarned;
+    /** Per-frame restyle callbacks from the custom layout result. When set, the
+     *  frame routes selection changes through `restyleScene()` (style-only repaint)
+     *  instead of a full `buildScene()`. */
+    private _customRestyle;
+    private _customRestyleEdge;
+    /** True when the active custom layout supplied a `restyle`/`restyleEdge`. */
+    hasCustomRestyle: boolean;
+    /** Base (as-emitted) style per mark, so a restyle pass starts from the layout's
+     *  own style rather than compounding patches across selection changes. */
+    private _baseStyles;
     private _nodeQuadtree;
     private _maxNodeRadius;
     /** Bumped whenever sceneNodes is rebuilt; keys the quadtree cache. */
@@ -66,6 +90,7 @@ 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;
@@ -82,7 +107,19 @@ export declare class NetworkPipelineStore {
      * 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: any[], rawEdges: any[], size: [number, number], options?: {
+        deferLayout?: boolean;
+    }): void;
+    /**
+     * 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).
      */
@@ -108,6 +145,30 @@ 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.
+     * Does NOT bump the scene revision — positions are unchanged, so the quadtree
+     * 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;
     /**
      * Lazily (re)build the circle-node spatial index. Only built when the scene
@@ -166,37 +227,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/NetworkSVGOverlay.d.ts

@@ -5,6 +5,7 @@ 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";
 type AnnotationAnchorNode = {
     type: string;
     datum: Datum | null;
@@ -19,10 +20,24 @@ type AnnotationAnchorNode = {
     r?: number;
     /** Arc nodes (chord, radial) carry an outer radius. */
     outerR?: number;
+    /** 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[];
 };
+/** Anchor id for a scene node — used to resolve `pointId`-anchored annotations
+ *  to a mark a layout emitted (incl. custom-layout marks). Exported for tests. */
+export declare function nodeAnchorId(node: AnnotationAnchorNode): string | undefined;
+/** Center + effective radius of a scene node for annotation anchoring. Exported
+ *  for tests. */
+export declare function nodeCenter(node: AnnotationAnchorNode): {
+    x: number;
+    y: number;
+    r: number;
+} | null;
 export interface NetworkSVGOverlayProps {
     width: number;
     height: number;

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

@@ -16,16 +16,22 @@ import type { Datum } from "../charts/shared/datumTypes";
  * Consumed by: StreamOrdinalFrame (sole consumer).
  */
 import { type ScaleLinear } from "d3-scale";
-import { type Quadtree } from "d3-quadtree";
+import type { Quadtree } from "d3-quadtree";
 import type { OrdinalPipelineConfig, OrdinalScales, OrdinalSceneNode, OrdinalColumn, OrdinalLayout } from "./ordinalTypes";
 import type { Changeset, PointSceneNode } from "./types";
 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 {
     private buffer;
     private rExtent;
     /** Per-accessor extents for multiAxis mode */
     private rExtents;
     private config;
+    private windowSizeWarned;
+    private updateResults;
     private getO;
     private getR;
     /** All resolved rAccessors (length > 1 when multiAxis) */
@@ -33,6 +39,7 @@ export declare class OrdinalPipelineStore {
     private getStack;
     private getGroup;
     private getColor;
+    private getSymbol;
     private getConnector;
     private getDataId;
     /** Discovered categories in insertion order */
@@ -55,10 +62,27 @@ export declare class OrdinalPipelineStore {
     columns: Record<string, OrdinalColumn>;
     /** Overlays returned from customLayout (consumed by StreamOrdinalFrame). */
     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
+     *  keeps the last successful result while its scene remains recoverable. */
+    lastCustomLayoutResult: OrdinalLayoutResult | null;
+    /** Latest custom-layout failure for frame-handle readback. */
+    lastCustomLayoutFailure: CustomLayoutFailureDiagnostic | null;
+    /** Lets `computeScene` retain a prior scene without mutating it after an
+     * exception from `buildSceneNodes`. */
+    private _customLayoutFailedThisBuild;
+    private _customLayoutDiagnosticsWarned;
+    /** Per-frame restyle callback from the custom layout result (see OrdinalLayoutResult.restyle). */
+    private _customRestyle;
+    /** True when the active custom layout supplied a `restyle`. */
+    hasCustomRestyle: boolean;
+    /** Base (as-emitted) style per node, so restyle passes don't compound. */
+    private _baseStyles;
     version: number;
     /** Bumped whenever the buffer is mutated. Used to invalidate per-frame caches. */
     private _dataVersion;
-    private static readonly QUADTREE_THRESHOLD;
+    /** Materialized source data, cached for pulse/decay animation frames. */
+    private _bufferArrayCache;
     private _pointQuadtree;
     /** Largest visual point radius in the current scene. */
     private _maxPointRadius;
@@ -68,7 +92,14 @@ export declare class OrdinalPipelineStore {
     private _categoryIndexCache;
     private _hasRenderedOnce;
     constructor(config: OrdinalPipelineConfig);
+    /**
+     * Keep the optional pulse timestamp ring in lockstep with the datum ring.
+     * Enabling pulse after mount must seed timestamps for retained rows; an
+     * empty ring would associate later timestamps with the wrong datum index.
+     */
+    private syncPulseTimestampBuffer;
     ingest(changeset: Changeset): boolean;
+    ingestWithResult(changeset: Changeset): UpdateResult;
     private pushValueExtent;
     private evictValueExtent;
     /** For timeline type: resolve rAccessor as a [start, end] pair */
@@ -110,6 +141,12 @@ export declare class OrdinalPipelineStore {
     get maxPointRadius(): number;
     private applyDecay;
     private applyPulse;
+    /**
+     * Refresh only pulse-derived fields on the existing scene. This deliberately
+     * avoids a scene/layout rebuild on every rAF pulse tick.
+     */
+    refreshPulse(now: number): boolean;
+    hasActivePulsesAt(now: number): boolean;
     get hasActivePulses(): boolean;
     /** Synthesize a zero-state prevPositionMap for animated intro (first render). */
     private synthesizeIntroPositions;
@@ -127,7 +164,15 @@ export declare class OrdinalPipelineStore {
      * after the server already painted the chart.
      */
     cancelIntroAnimation(): void;
+    /**
+     * Materialize the ring buffer at most once per data version. Pulse decay
+     * ticks reuse this array and the datum/category index caches rather than
+     * allocating a fresh copy at animation-frame frequency.
+     */
+    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.
@@ -142,5 +187,22 @@ 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
+     * `selection`, off each node's base style — no relayout, no quadtree rebuild.
+     * No-op when the layout supplied no `restyle`.
+     */
+    restyleScene(selection: CustomLayoutSelection | null): void;
+    /**
+     * Re-derive every retained fact that depends on the category/value
+     * accessors. `updateConfig` can change an accessor without a subsequent
+     * ingest (the normal React path), so clearing only a cache would leave the
+     * next scene with an empty/stale domain against the existing buffer.
+     */
+    private rebuildAccessorDerivedState;
     updateConfig(config: Partial<OrdinalPipelineConfig>): void;
+    updateConfigWithResult(config: Partial<OrdinalPipelineConfig>): UpdateResult;
 }