semiotic 3.8.3 → 3.8.5

package/dist/components/recipes/netEnsembleOverlays.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+import type { BandInfo } from "./netEnsembleLayout";
+export interface NetEnsembleOverlayOptions {
+    convergeColor: string;
+    branchColor: string;
+    edgeColor: string;
+    plot: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    showBandLabels: boolean;
+    showExemplars: boolean;
+    showLegend: boolean;
+    textColor: string;
+    subText: string;
+}
+/** Render presentation-only band labels, exemplars, and the directedness key. */
+export declare function buildNetEnsembleOverlays(bands: BandInfo[], o: NetEnsembleOverlayOptions): ReactNode;

package/dist/components/recipes/recipeChrome.d.ts

@@ -44,6 +44,30 @@ export declare function boundsOf(points: ReadonlyArray<{
     width: number;
     height: number;
 } | null;
+/** Axis-aligned box with a top-left origin (chip, card, scene rect). */
+export interface HullBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type HullPadding = number | {
+    x?: number;
+    y?: number;
+};
+/**
+ * Axis-aligned hull of discrete mark boxes, with optional padding. Use this when
+ * marks are chips/cards with known extents (not just points): the result fully
+ * surrounds the marks so a stroke drawn *after* the marks reads as a true
+ * enclosure (fill under, stroke over). Returns null for an empty set.
+ *
+ * @example
+ * ```ts
+ * const hull = hullFromBoxes(chips, { x: 12, y: 10 })
+ * // overlays: fill rect (under) then marks then stroke-only rect (over)
+ * ```
+ */
+export declare function hullFromBoxes(boxes: ReadonlyArray<HullBox>, padding?: HullPadding): HullBox | null;
 export interface BandLabelProps {
     text: string;
     x: number;

package/dist/components/recipes/sequenceLayout.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Sequence diagram kit — linear spines, span-arc packing, and shared-edge
+ * partition helpers for custom charts that treat a row of marks as a baseline
+ * (dependency arcs, co-reference, genomic links, alternate-hypothesis overlays).
+ *
+ * Pure / SSR-safe. Complements {@link packIntervals} (time tracks) and the
+ * edge-router kit (network S-curves): here the domain is an ordered index on a
+ * baseline and the mark is a vertical-band arc between two anchors.
+ */
+export interface SequenceItem {
+    /** Stable identity used as the position map key. */
+    id: string;
+}
+export interface SequencePosition {
+    id: string;
+    x: number;
+    y: number;
+    /** Zero-based order on the baseline. */
+    index: number;
+}
+export interface LayoutSequenceOptions {
+    width: number;
+    y: number;
+    /** @default min(74, max(34, width * 0.08)) */
+    paddingLeft?: number;
+    /** @default min(74, max(34, width * 0.08)) */
+    paddingRight?: number;
+}
+/**
+ * Place ordered items evenly along a horizontal baseline. Returns a Map keyed
+ * by `id` so callers can look up either end of a span arc in O(1).
+ */
+export declare function layoutSequence(items: readonly SequenceItem[], options: LayoutSequenceOptions): Map<string, SequencePosition>;
+export interface ChipStripItem extends SequenceItem {
+    /** Optional label used by the default width estimator. */
+    label?: string;
+}
+export interface LayoutChipStripOptions extends LayoutSequenceOptions {
+    /** Gap between chips when packing by content width. @default 8 */
+    gap?: number;
+    /**
+     * When true (default), distribute free horizontal space evenly between chips
+     * so the strip still spans the baseline. When false, pack left-to-right.
+     */
+    distribute?: boolean;
+    /** Override per-chip width. Defaults to {@link estimateLabelWidth} of `label`/`id`. */
+    estimateWidth?: (item: ChipStripItem, index: number) => number;
+}
+export interface ChipStripPosition extends SequencePosition {
+    /** Chip width in px (for hulls / hit targets). */
+    width: number;
+}
+/**
+ * Place ordered chips along a baseline, sizing each by estimated label width.
+ * Prefer {@link layoutSequence} when marks are equal-spaced points rather than
+ * variable-width chips.
+ */
+export declare function layoutChipStrip(items: readonly ChipStripItem[], options: LayoutChipStripOptions): Map<string, ChipStripPosition>;
+/**
+ * Rough text width for chip / arc labels. Matches the heuristic used by the
+ * sentence-structure stage and is good enough for layout before paint.
+ */
+export declare function estimateLabelWidth(text: unknown, minimum?: number, charWidth?: number, pad?: number): number;
+export interface SpanInterval {
+    /** Stable identity for the packed result. */
+    id: string;
+    /** Inclusive left index on the sequence baseline. */
+    a: number;
+    /** Inclusive right index on the sequence baseline. */
+    b: number;
+}
+export interface PackedSpanLevel<T extends SpanInterval = SpanInterval> {
+    span: T;
+    /** Zero-based height level (0 = closest to the baseline). */
+    level: number;
+}
+export interface PackSpanLevelsResult<T extends SpanInterval = SpanInterval> {
+    packed: PackedSpanLevel<T>[];
+    /** Number of distinct levels used (`maxLevel + 1`, at least 1). */
+    levelCount: number;
+    maxLevel: number;
+}
+/**
+ * Greedy span packing: assign each interval to the lowest level whose last
+ * right edge is already left of this span's left edge. Short spans are packed
+ * first so long arcs stack above them — the classic dependency-arc layout.
+ *
+ * Indices are treated as inclusive; a span with `a === b` is a zero-width hop.
+ */
+export declare function packSpanLevels<T extends SpanInterval>(spans: readonly T[]): PackSpanLevelsResult<T>;
+export interface ScaleArcBandOptions {
+    /** Y of the sequence baseline (token line). */
+    baselineY: number;
+    /** Top of the free vertical band arcs may occupy. */
+    ceilingY: number;
+    /** From {@link packSpanLevels}. */
+    levelCount: number;
+    /** Vertical room reserved under each peak for a mid-arc label. @default 18 */
+    labelRoom?: number;
+}
+export interface ScaleArcBandResult {
+    /** Height of the shortest (level 0) arc above the baseline foot. */
+    arcLift: number;
+    /** Vertical spacing between successive levels. */
+    levelStep: number;
+}
+/**
+ * Stretch packed arc levels across the free band between `ceilingY` and the
+ * baseline so short plots are not a cramped nest under a blank canvas.
+ */
+export declare function scaleArcBand(options: ScaleArcBandOptions): ScaleArcBandResult;
+export interface SpanArcPathOptions {
+    /**
+     * How far above `baselineY` the arc feet attach (keeps arcs off token chips).
+     * @default 26
+     */
+    footLift?: number;
+}
+/**
+ * Quadratic span arc between two x-positions on a baseline. Pure path `d`
+ * string for SVG overlays / scene edge emission.
+ */
+export declare function spanArcPath(x0: number, x1: number, baselineY: number, peakY: number, options?: SpanArcPathOptions): string;
+/**
+ * Peak y for a packed span level given band metrics from {@link scaleArcBand}.
+ */
+export declare function spanArcPeakY(baselineY: number, level: number, metrics: ScaleArcBandResult): number;
+export type EdgeKeyFn<T> = (edge: T) => string;
+/**
+ * Partition several edge lists into the shared intersection (present in every
+ * set under `keyOf`) and the per-set exclusive remainder. Used by compare views
+ * that paint common topology once and disputed links per hypothesis.
+ *
+ * Shared edges are taken from the first set (stable identity for paint keys).
+ */
+export declare function partitionSharedEdges<T>(edgeSets: readonly (readonly T[])[], keyOf?: EdgeKeyFn<T>): {
+    shared: T[];
+    exclusive: T[][];
+};

package/dist/components/recipes/wordTrails.d.ts

@@ -0,0 +1,156 @@
+import type { OrdinalCustomLayout } from "../stream/ordinalCustomLayout";
+import type { Datum } from "../charts/shared/datumTypes";
+export { wordTrailsProgressiveReveal, type WordTrailsProgressiveRevealOptions } from "./wordTrailsProgressiveReveal";
+/**
+ * Word Trails — a *quantitatively honest* word cloud.
+ *
+ * Where a classic word cloud (d3-cloud / amueller) packs words into free space
+ * with only size encoding frequency and position meaning nothing, Word Trails
+ * gives position meaning on both axes:
+ *
+ *   - **columns** (x) are a category — e.g. each speaker in a debate;
+ *   - **the vertical axis** (y) is an ordered value — e.g. the debate segment
+ *     where the word peaked, so a word's height reads as *when* it was said;
+ *   - **font size** encodes frequency/weight.
+ *
+ * Each column is laid out with greedy, largest-first placement: every word
+ * searches outward from its segment anchor for the nearest free spot, so the
+ * result is **overlap-free by construction**. A single global font scale
+ * (`scaleToFit`) shrinks every word together until it all fits — relative
+ * magnitude is preserved, nothing is clipped or dropped.
+ *
+ * The reading: scan a column top-to-bottom to follow one speaker through time;
+ * scan across a row to compare what everyone emphasised at the same moment.
+ *
+ * Inspired by Elijah Meeks's 2016 "Word Trails" debate visualization. Because
+ * placement is *box*-aware (not sprite/pixel), the layout needs no canvas text
+ * measurement — it is pure and SSR-clean.
+ *
+ * @example
+ * ```tsx
+ * import { OrdinalCustomChart } from "semiotic/ordinal"
+ * import { wordTrailsLayout } from "semiotic/recipes"
+ *
+ * <OrdinalCustomChart
+ *   data={terms}                     // [{ word, weight, speaker, segment }]
+ *   layout={wordTrailsLayout}
+ *   layoutConfig={{
+ *     textAccessor: "word",
+ *     weightAccessor: "weight",
+ *     columnAccessor: "speaker",
+ *     segmentAccessor: "segment",
+ *   }}
+ *   width={860}
+ *   height={520}
+ * />
+ * ```
+ */
+export interface WordTrailsWordInfo {
+    /** Rendered word text. */
+    word: string;
+    /** Column containing this word. */
+    column: string;
+    /** Quantitative weight used to size this word. */
+    weight: number;
+    /** Ordered segment/time value anchoring this word vertically. */
+    segment: number;
+    /** Exact source row supplied to the chart. */
+    datum: Datum;
+    /** Index of `datum` in the chart's input data. */
+    dataIndex: number;
+    /** Index of the word's column in the final rendered column order. */
+    columnIndex: number;
+    /** Column color after `columnColor` / the chart theme has been resolved. */
+    resolvedColumnColor: string;
+}
+export interface WordTrailsConfig {
+    /** Field (or fn) giving the word text. */
+    textAccessor: string | ((d: Datum) => string);
+    /** Field (or fn) giving the word weight (→ font size). */
+    weightAccessor: string | ((d: Datum) => number);
+    /** Field (or fn) giving the column category (→ x band). */
+    columnAccessor: string | ((d: Datum) => string);
+    /** Field (or fn) giving the ordered segment/time value (→ pinned y). */
+    segmentAccessor: string | ((d: Datum) => number);
+    /** `[min, max]` of the segment axis. Derived from data when omitted. */
+    segmentDomain?: [number, number];
+    /** Explicit column order. Data insertion order when omitted. */
+    columnOrder?: string[];
+    /** Smallest font size, px. @default 11 */
+    minFontSize?: number;
+    /** Largest font size, px. @default 42 */
+    maxFontSize?: number;
+    /** Gap between columns, px. @default 18 */
+    columnGutter?: number;
+    /**
+     * Gap kept between word boxes, px — the density knob. `0` packs words as
+     * tightly as their glyph boxes allow (crowded, still overlap-free); larger
+     * values open the cloud up. @default 2
+     */
+    collisionPadding?: number;
+    /**
+     * Per-word fill override. Return a color for a word (e.g. from a
+     * distinctiveness / sentiment model) or `undefined` to fall back to the
+     * column color. Same word ⇒ same color across columns if you key on the text.
+     */
+    wordColor?: (info: WordTrailsWordInfo) => string | undefined | null;
+    /**
+     * Per-word reveal opacity. Return a value in `[0, 1]`; values are clamped,
+     * and non-finite values resolve to `0`. Every row still participates in
+     * scale-to-fit and collision placement, so changing opacity cannot move the
+     * remaining words. A resolved `0` emits neither a glyph nor an interactive
+     * hit target. By default a nonzero value multiplies the built-in weight
+     * opacity; set `weightOpacity` to `false` when this callback should be the
+     * exact rendered opacity.
+     * @default () => 1
+     */
+    wordOpacity?: (info: WordTrailsWordInfo) => number;
+    /**
+     * Fade lower-weight words from `0.5` to `1` opacity in addition to encoding
+     * weight with font size. Disable this when opacity carries an independent
+     * variable such as recency; `wordOpacity` then controls rendered opacity
+     * exactly. @default true
+     */
+    weightOpacity?: boolean;
+    /** Per-column label color override. Falls back to the categorical palette. */
+    columnColor?: (column: string) => string | undefined | null;
+    /** Draw the speaker/column labels along the top. @default true */
+    showColumnLabels?: boolean;
+    /** Draw the segment/time value axis on the left. @default true */
+    showSegmentAxis?: boolean;
+    /** Approx. number of ticks on the segment axis. @default 6 */
+    segmentTickCount?: number;
+    /** Formats a segment value for the axis + tooltip. @default String */
+    segmentTickFormat?: (v: number) => string;
+    /** Title shown above the segment axis (e.g. "Debate segment"). */
+    segmentAxisLabel?: string;
+    /**
+     * Max rotation magnitude, degrees. Each word gets a deterministic angle in
+     * `[-rotate, +rotate]`. `0` keeps every word horizontal (most legible).
+     * @default 0
+     */
+    rotate?: number;
+    /**
+     * Allow the same word to appear more than once in a column. When `false`
+     * (default), duplicate `(column, word)` rows are merged to a single entry at
+     * the row with the greatest weight (its peak) — the classic word-cloud
+     * reading. When `true`, every row is kept, so a word can trail down its
+     * column once per segment it appeared in. @default false
+     */
+    repeatWords?: boolean;
+    /**
+     * Uniformly shrink every word by one global factor until nothing overlaps.
+     * Relative magnitude is preserved (a word twice as frequent stays twice the
+     * area) — only the absolute scale drops as words are added. Turn it off to
+     * keep exact `minFontSize`/`maxFontSize` sizing and accept overlap.
+     * @default true
+     */
+    scaleToFit?: boolean;
+    /**
+     * Target fraction of each column's area filled by word boxes before the
+     * global scale is reduced. Lower packs looser (more whitespace); higher
+     * starts larger and lets the greedy placer crowd words in. @default 0.6
+     */
+    packingDensity?: number;
+}
+export declare const wordTrailsLayout: OrdinalCustomLayout<WordTrailsConfig>;

package/dist/components/recipes/wordTrailsProgressiveReveal.d.ts

@@ -0,0 +1,42 @@
+import type { WordTrailsConfig } from "./wordTrails";
+/** Options for a stable, progressive Word Trails reveal. */
+export interface WordTrailsProgressiveRevealOptions {
+    /** Segment that is currently active/reached. Values are clamped to `segmentDomain`. */
+    currentSegment: number;
+    /** Ordered `[oldest, newest]` segment extent used for the fade. */
+    segmentDomain: readonly [number, number];
+    /** Opacity of the oldest reached segment. @default 0.25 */
+    oldestOpacity?: number;
+    /** Opacity of the current segment. @default 1 */
+    currentOpacity?: number;
+    /** Opacity of unreached segments. `0` hides their glyphs and hit targets. @default 0 */
+    futureOpacity?: number;
+    /** Also multiply the reveal by Word Trails' built-in weight fade. @default false */
+    combineWeightOpacity?: boolean;
+}
+/**
+ * Build the two config fields for a stable, progressive segment reveal.
+ *
+ * Reached rows fade linearly from `oldestOpacity` at the start of the domain
+ * to `currentOpacity` at `currentSegment`; future rows use `futureOpacity`.
+ * Word Trails still lays out zero-opacity rows, so playback changes visibility
+ * without reflow. The returned config disables the independent weight-opacity
+ * encoding unless `combineWeightOpacity` is explicitly enabled.
+ *
+ * This is the Word Trails composition counterpart to the runtime-neutral
+ * `opacityFromAge` helper: it keeps the same linear newest-to-oldest reading,
+ * then adds future hiding, layout reservation, and exact weight-opacity
+ * semantics without making the recipes entry point depend on a motion runtime.
+ *
+ * @example
+ * ```tsx
+ * layoutConfig={{
+ *   ...config,
+ *   ...wordTrailsProgressiveReveal({
+ *     currentSegment: iteration,
+ *     segmentDomain: [0, lastIteration]
+ *   })
+ * }}
+ * ```
+ */
+export declare function wordTrailsProgressiveReveal(options: WordTrailsProgressiveRevealOptions): Pick<WordTrailsConfig, "wordOpacity" | "weightOpacity">;

package/dist/components/semiotic-ai-core.d.ts

@@ -18,6 +18,9 @@ export { toConfig, fromConfig, toURL, fromURL, copyConfig, configToJSX } from ".
 export type { ChartConfig, ToConfigOptions, CopyFormat } from "./export/chartConfig";
 export { summarizeData } from "./data/DataSummarizer";
 export type { DataSummary, FieldSummary, FieldType, SummarizeOptions } from "./data/DataSummarizer";
+export { auditData, formatDataAudit, profileNumericFields, toDataAuditNotifications, } from "./data/auditData";
+export type { AuditDataOptions, CheckedNumericContract, DataAuditChartNotification, DataAuditDiagnosis, DataAuditNotificationOptions, DataAuditResult, NumericFieldProfile, ProfileNumericFieldsOptions, } from "./data/auditData";
+export type { NumericAggregateContract, NumericContracts, NumericFieldContract, NumericFieldRole, NumericRequirement, } from "./data/numericContracts";
 export { profileData } from "./ai/profileData";
 export type { ProfileDataOptions } from "./ai/profileData";
 export { inferIntent } from "./ai/inferIntent";

package/dist/components/semiotic-ai-data-audit.d.ts

@@ -0,0 +1,4 @@
+export { auditData, formatDataAudit, profileNumericFields, toDataAuditNotifications, } from "./data/auditData";
+export type { AuditDataOptions, CheckedNumericContract, DataAuditChartNotification, DataAuditDiagnosis, DataAuditNotificationOptions, DataAuditResult, NumericFieldProfile, ProfileNumericFieldsOptions, } from "./data/auditData";
+export type { NumericAggregateContract, NumericContracts, NumericFieldContract, NumericFieldRole, NumericRequirement, } from "./data/numericContracts";
+export type { ChartContainerDataAudit, ChartContainerDataAuditOptions, } from "./chartContainerDataAudit";

package/dist/components/semiotic-ai.d.ts

@@ -50,6 +50,7 @@ export { CollisionSwarmChart } from "./charts/physics/CollisionSwarmChart";
 export { PhysicalFlowChart } from "./charts/physics/PhysicalFlowChart";
 export { ProcessFlowChart } from "./charts/physics/ProcessFlowChart";
 export { GauntletChart } from "./charts/physics/GauntletChart";
+export { CrucibleChart } from "./charts/physics/CrucibleChart";
 export { BigNumber } from "./charts/value/BigNumber";
 export { TooltipProvider } from "./store/TooltipStore";
 export { MultiLineTooltip } from "./Tooltip/Tooltip";
@@ -59,10 +60,10 @@ export { ChartContainer } from "./ChartContainer";
 export { MobileChartContainer } from "./MobileChartContainer";
 export { SmallMultipleChart } from "./SmallMultipleChart";
 export { MobileStandardControls } from "./MobileStandardControls";
-export { clampMobileRange, useMobileRangeControls, zoomMobileRange, } from "./MobileStandardControls";
+export { clampMobileRange, useMobileRangeControls, zoomMobileRange } from "./MobileStandardControls";
 export type { ChartContainerProps, ChartContainerHandle, ChartContainerMobileOptions, ChartNotification, ChartNotificationLevel } from "./ChartContainer";
 export type { MobileChartChip, MobileChartContainerProps, MobileChartDetailMode } from "./MobileChartContainer";
-export type { MobileStandardBrushControls, MobileStandardControlKind, MobileStandardControlLegendItem, MobileStandardControlRequest, MobileStandardControlsMode, MobileStandardControlsProps, MobileStandardLegendControls, MobileStandardZoomControls, UseMobileRangeControlsOptions, UseMobileRangeControlsResult, } from "./MobileStandardControls";
+export type { MobileStandardBrushControls, MobileStandardControlKind, MobileStandardControlLegendItem, MobileStandardControlRequest, MobileStandardControlsMode, MobileStandardControlsProps, MobileStandardLegendControls, MobileStandardZoomControls, UseMobileRangeControlsOptions, UseMobileRangeControlsResult } from "./MobileStandardControls";
 export type { SmallMultipleChartProps, SmallMultipleExtent, SmallMultipleItem, SmallMultipleRenderContext, SmallMultipleSharedExtent } from "./SmallMultipleChart";
 export { ChartGrid } from "./ChartGrid";
 export type { ChartGridProps } from "./ChartGrid";
@@ -76,8 +77,8 @@ export { validateProps } from "./charts/shared/validateProps";
 export type { ValidationResult } from "./charts/shared/validateProps";
 export { diagnoseConfig } from "./charts/shared/diagnoseConfig";
 export type { Diagnosis, DiagnosisResult } from "./charts/shared/diagnoseConfig";
-export { diagnoseTokenEncoding, normalizeTokenEncoding, suggestTokenEncoding, tokenTaskIntentToCapabilityIntents, } from "./recipes/tokenEncoding";
-export type { PositionedToken, SuggestTokenEncodingInput, TokenCapabilityIntent, TokenCountStrategy, TokenDiagnostic, TokenDiagnosticCode, TokenDiagnosticsContext, TokenEncoding, TokenEncodingSuggestion, TokenGeneratorInput, TokenGridOptions, TokenLabelPolicy, TokenLayout, TokenSemantics, TokenSet, TokenTaskIntent, TokenType, VisualToken, } from "./recipes/tokenEncoding";
+export { diagnoseTokenEncoding, normalizeTokenEncoding, suggestTokenEncoding, tokenTaskIntentToCapabilityIntents } from "./recipes/tokenEncoding";
+export type { PositionedToken, SuggestTokenEncodingInput, TokenCapabilityIntent, TokenCountStrategy, TokenDiagnostic, TokenDiagnosticCode, TokenDiagnosticsContext, TokenEncoding, TokenEncodingSuggestion, TokenGeneratorInput, TokenGridOptions, TokenLabelPolicy, TokenLayout, TokenSemantics, TokenSet, TokenTaskIntent, TokenType, VisualToken } from "./recipes/tokenEncoding";
 export { auditAccessibility, formatAccessibilityAudit, accessibilityCaveats } from "./charts/shared/auditAccessibility";
 export { auditMobileVisualization, formatMobileVisualizationAudit, mobileVisualizationCaveats } from "./charts/shared/auditMobileVisualization";
 export { responsiveRuleMatches, resolveResponsiveRules } from "./charts/shared/responsiveRules";
@@ -112,6 +113,7 @@ export type { AccessibleNavTreeProps } from "./AccessibleNavTree";
 export { useNavigationSync } from "./ai/useNavigationSync";
 export type { UseNavigationSyncOptions, UseNavigationSyncResult } from "./ai/useNavigationSync";
 export type { DataSummary, FieldSummary, FieldType, NumericFieldSummary, DateFieldSummary, CategoricalFieldSummary, UnknownFieldSummary, SummarizeOptions } from "./data/DataSummarizer";
+export * from "./semiotic-ai-data-audit";
 export { profileData } from "./ai/profileData";
 export type { ProfileDataOptions } from "./ai/profileData";
 export { suggestCharts, suggestChartsGrouped, scoreChart, explainCapabilityFit } from "./ai/suggestCharts";
@@ -154,7 +156,7 @@ export type { RecipeNavigationOptions } from "./ai/recipeNavigation";
 export { auditObservedScene } from "./ai/observedSceneAudit";
 export type { AuditObservedSceneInput, DeclaredRecipeSemantics, ObservedAuditFinding, ObservedAuditStatus, ObservedSceneAuditResult } from "./ai/observedSceneAudit";
 export { auditVisualizationControls } from "./controls/controlAudit";
-export type { AuditVisualizationControlsOptions, ControlAuditFinding, ControlAuditResult, ControlAuditStatus, } from "./controls/controlAudit";
+export type { AuditVisualizationControlsOptions, ControlAuditFinding, ControlAuditResult, ControlAuditStatus } from "./controls/controlAudit";
 export type { VisualizationControlDefinition } from "./controls/controlContract";
 export { IntentMark } from "./ai/IntentMark";
 export type { IntentMarkProps } from "./ai/IntentMark";

package/dist/components/semiotic-physics.d.ts

@@ -25,6 +25,7 @@ export { BuiltInPhysicsEngineAdapter, CollisionSwarmChart, EventDropChart, Gaunt
 export default StreamPhysicsFrame;
 export type { CollisionSwarmChartProps } from "./charts/physics/CollisionSwarmChart";
 export type { EventDropChartProps } from "./charts/physics/EventDropChart";
+export * from "./charts/physics/CrucibleChart";
 export type { GauntletChartProps, GauntletEffect, GauntletEvent, GauntletEventContext, GauntletEventLogItem, GauntletGate, GauntletLayout, GauntletNegativeReplacementOptions, GauntletPopSpec, GauntletProjectPlacement, GauntletProjectState, GauntletPropertyForceContext, GauntletPropertyDefinition, GauntletPropertyWorkPlan, GauntletPropertyWorkPlanOptions } from "./charts/physics/GauntletChart";
 export type { PhysicsProcessBodyGroup, PhysicsProcessBoundaryOptions, PhysicsProcessStage } from "./charts/physics/physicsProcessPrimitives";
 export type { GaltonBoardChartProps, GaltonBoardReferenceLine } from "./charts/physics/GaltonBoardChart";

package/dist/components/semiotic-recipes-core.d.ts

@@ -25,6 +25,8 @@ export { lineageDagLayout } from "./recipes/lineageDag";
 export type { LineageDagConfig, LineageLod, LineageStoreSlot } from "./recipes/lineageDag";
 export { mermaidDagLayout } from "./recipes/mermaidDag";
 export type { MermaidDagConfig } from "./recipes/mermaidDag";
+export { netEnsembleLayout, analyzeNetEnsemble } from "./recipes/netEnsembleLayout";
+export type { NetEnsembleConfig, NetEnsembleAnalysis, NetEnsembleComponent, NetEnsembleMotif, } from "./recipes/netEnsembleLayout";
 export { packedClusterMatrix } from "./recipes/packedClusterMatrix";
 export type { PackedClusterMatrixConfig } from "./recipes/packedClusterMatrix";
 export { marimekkoLayout } from "./recipes/marimekko";
@@ -39,10 +41,14 @@ export { annotationLayout } from "./recipes/annotationLayout";
 export type { AnnotationLayoutConfig, AnnotationLayoutOptions, AutoPlaceAnnotations, AutoPlaceAnnotationsConfig, AnnotationCohesion, AnnotationAudience, AnnotationMobileConfig, } from "./recipes/annotationLayout";
 export { annotationDensity, annotationBudget, DEFAULT_AREA_PER_ANNOTATION } from "./recipes/annotationDensity";
 export type { AnnotationDensityConfig, AnnotationDensityOptions, AnnotationDensityResult, } from "./recipes/annotationDensity";
+export { GRID_FUEL_KEYS, GRID_FUEL_LABELS, stackFuelSeries, demandForecastRows, reserveMarginPct, reserveSeries, thresholdBandsForReserve, reserveAnnotationBands, summarizeOperatingPoint, gridEventAnnotations, tightestHours, formatMw, formatReservePct, } from "./recipes/gridObservatory";
+export type { GridFuelKey, GridHour, ReserveSnapshot, ReserveLevels, FuelStackRow, DemandForecastRow, OperatingPointSummary, GridEventWindow, } from "./recipes/gridObservatory";
 export { intervalLanesLayout } from "./recipes/intervalLanes";
 export type { IntervalLanesConfig } from "./recipes/intervalLanes";
 export { axisFixedForceLayout, axisFixedForcePositions, rectCollide } from "./recipes/axisFixedForce";
 export type { AxisFixedForceConfig, AxisFixedForceResult, PositionedNode, CollisionBox, RectCollideOptions, } from "./recipes/axisFixedForce";
+export { wordTrailsLayout, wordTrailsProgressiveReveal } from "./recipes/wordTrails";
+export type { WordTrailsConfig, WordTrailsProgressiveRevealOptions, WordTrailsWordInfo, } from "./recipes/wordTrails";
 export { hitTargetPoint, hitTargetRect, networkHitTarget, geoHitTarget, geoAreaHitTarget, DEFAULT_HIT_RADIUS, } from "./stream/hitTarget";
 export type { GeoAreaHitTargetProps, HitTargetPointProps, HitTargetRectProps, NetworkHitTargetCircleProps, NetworkHitTargetRectProps, } from "./stream/hitTarget";
 export { runs, runLengthEncode } from "./recipes/runs";
@@ -50,6 +56,8 @@ export type { Run, RunOptions } from "./recipes/runs";
 export { wrapValue, shortestArcDelta, cyclicRangeContains, selectCyclicRange } from "./recipes/cyclical";
 export { packIntervals, activeCountOverDomain } from "./recipes/intervals";
 export type { PackedInterval, PackIntervalsResult, PackIntervalsOptions, ActiveCount, ActiveCountOptions, } from "./recipes/intervals";
+export { layoutSequence, layoutChipStrip, estimateLabelWidth, packSpanLevels, scaleArcBand, spanArcPath, spanArcPeakY, partitionSharedEdges, } from "./recipes/sequenceLayout";
+export type { SequenceItem, SequencePosition, LayoutSequenceOptions, ChipStripItem, LayoutChipStripOptions, ChipStripPosition, SpanInterval, PackedSpanLevel, PackSpanLevelsResult, ScaleArcBandOptions, ScaleArcBandResult, SpanArcPathOptions, EdgeKeyFn, } from "./recipes/sequenceLayout";
 export { polarToXY, xyToAngle, angleScale, radiusScale, ringArcPath, TAU } from "./recipes/radialCoords";
 export type { Point, PolarOptions, AngleScaleOptions, RingArcOptions } from "./recipes/radialCoords";
 export { curvedEdgePath, orthogonalEdgePath, boxEdgeAnchors, fanOutBend, cubicPoint, cubicTangent, cubicPath, } from "./recipes/edgeRouter";
@@ -69,8 +77,8 @@ export type { NetworkSymbolName } from "./stream/symbolPath";
 export { glyphPlacement, glyphExtent, glyphFractionClipRect, DEFAULT_GLYPH_VIEWBOX, DEFAULT_GLYPH_ANCHOR, } from "./stream/glyphDef";
 export type { GlyphDef, GlyphPart, GlyphPlacement } from "./stream/glyphDef";
 export { isotypeInk, isotypePaper, isotypeGhost, isotypeServerGlyph, isotypeChipGlyph, isotypeBoltGlyph, isotypeBusGlyph, isotypePersonPath, isotypePersonGlyph, isotypeNetworkGlyphs, } from "./recipes/isotypeGlyphs";
-export { roundedEnclosure, boundsOf, bandLabel, markCallout, linearAxis, hatchFill } from "./recipes/recipeChrome";
-export type { RoundedEnclosureProps, BandLabelProps, MarkCalloutProps, CalloutConnector, LinearAxisProps, AxisOrient, HatchFillOptions, } from "./recipes/recipeChrome";
+export { roundedEnclosure, boundsOf, hullFromBoxes, bandLabel, markCallout, linearAxis, hatchFill, } from "./recipes/recipeChrome";
+export type { RoundedEnclosureProps, HullBox, HullPadding, BandLabelProps, MarkCalloutProps, CalloutConnector, LinearAxisProps, AxisOrient, HatchFillOptions, } from "./recipes/recipeChrome";
 export { legendGroupsFrom, legendSwatches } from "./recipes/recipeLegend";
 export type { LegendGroupsInput, LegendSwatch, LegendSwatchesProps } from "./recipes/recipeLegend";
 export { buildTooltipEntries, extractTooltipDatum, formatTooltipValue, } from "./recipes/customTooltip";

package/dist/components/semiotic-utils-core.d.ts

@@ -20,6 +20,9 @@ export { resolveStyleRules, matchesThreshold, ruleMatches, makeRuleValueResolver
 export type { StyleRule, StyleRuleStyle, StyleRuleThreshold, StyleRuleContext, StyleRulePredicate, } from "./charts/shared/styleRules";
 export { validateProps } from "./charts/shared/validateProps";
 export { diagnoseConfig } from "./charts/shared/diagnoseConfig";
+export { auditData, formatDataAudit, profileNumericFields, toDataAuditNotifications, } from "./data/auditData";
+export type { AuditDataOptions, CheckedNumericContract, DataAuditChartNotification, DataAuditDiagnosis, DataAuditNotificationOptions, DataAuditResult, NumericFieldProfile, ProfileNumericFieldsOptions, } from "./data/auditData";
+export type { NumericAggregateContract, NumericContracts, NumericFieldContract, NumericFieldRole, NumericRequirement, } from "./data/numericContracts";
 export { auditAccessibility, formatAccessibilityAudit, accessibilityCaveats } from "./charts/shared/auditAccessibility";
 export { auditMobileVisualization, formatMobileVisualizationAudit, mobileVisualizationCaveats } from "./charts/shared/auditMobileVisualization";
 export { responsiveRuleMatches, resolveResponsiveRules } from "./charts/shared/responsiveRules";

package/dist/components/semiotic.d.ts

@@ -72,7 +72,7 @@ export { intentManifestFromRecipe, summarizeIntentManifest } from "./ai/intentMa
 export type { IntentManifest, IntentManifestFromRecipeOptions } from "./ai/intentManifest";
 export { useNavigationSync } from "./ai/useNavigationSync";
 export type { UseNavigationSyncOptions, UseNavigationSyncResult } from "./ai/useNavigationSync";
-export type { ChartContainerProps, ChartContainerHandle, ChartContainerMobileOptions, ChartNotification, ChartNotificationLevel, } from "./ChartContainer";
+export type { ChartContainerProps, ChartContainerHandle, ChartContainerDataAudit, ChartContainerDataAuditOptions, ChartContainerMobileOptions, ChartNotification, ChartNotificationLevel, } from "./ChartContainer";
 export type { MobileChartChip, MobileChartContainerProps, MobileChartDetailMode, } from "./MobileChartContainer";
 export type { MobileStandardBrushControls, MobileStandardControlKind, MobileStandardControlLegendItem, MobileStandardControlRequest, MobileStandardControlsMode, MobileStandardControlsProps, MobileStandardLegendControls, MobileStandardZoomControls, UseMobileRangeControlsOptions, UseMobileRangeControlsResult, } from "./MobileStandardControls";
 export type { MobileVisualizationContract } from "./charts/shared/auditMobileVisualization";

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

@@ -47,6 +47,26 @@ export interface RenderEvidence {
     ariaLabel: string;
     /** Stable warning codes (EMPTY_SCENE, NO_SCALES). */
     warnings: string[];
+    /**
+     * The resolved margin Semiotic actually used — after auto-reservation for a
+     * legend, a title, or any other chrome that grows a side beyond the caller's
+     * input. This is ground truth for reconstructing the plot rectangle by
+     * hand (e.g. a caller hand-drawing an SSR overlay); it is exactly what the
+     * emitted SVG's `data-area` group is translated by.
+     */
+    margin?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /** The plot rectangle after resolving `margin` against the outer `width`/`height`. */
+    plot?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
 }
 /**
  * Internal mutable slot threaded through the frame renderers. Only
@@ -85,6 +105,13 @@ interface BuildEvidenceInput {
     edgeCount?: number;
     legendItems?: number;
     extraWarnings?: string[];
+    /** The resolved margin (after auto-reservation) the caller's frame used. */
+    margin?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
 }
 /** Assemble evidence from a computed scene. Component name is stamped later
  *  by `renderChartWithEvidence`, which knows the HOC-level name. */

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

@@ -52,6 +52,7 @@ export declare const CHART_CONFIGS: {
     CollisionSwarmChart: ChartConfig;
     ProcessFlowChart: ChartConfig;
     GauntletChart: ChartConfig;
+    CrucibleChart: ChartConfig;
     PhysicalFlowChart: ChartConfig;
     PhysicsCustomChart: ChartConfig;
 };

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

@@ -5,5 +5,14 @@ export declare const physicsPileChart: ChartConfig;
 export declare const collisionSwarmChart: ChartConfig;
 export declare const processFlowChart: ChartConfig;
 export declare const gauntletChart: ChartConfig;
+/**
+ * Static CrucibleChart renders the same deterministic ledger used by the
+ * client HOC. A replay request settles at the terminal state for SSR (the
+ * client also hydrates from that reduced-motion snapshot); snapshot mode is
+ * the one deliberate way to request an authored intermediate instant.
+ * `paused`, `playbackRate`, and `rerunMS` govern wall-clock replay only and
+ * therefore cannot alter this static semantic state.
+ */
+export declare const crucibleChart: ChartConfig;
 export declare const physicalFlowChart: ChartConfig;
 export declare const physicsCustomChart: ChartConfig;

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

@@ -7,6 +7,7 @@ import type { Datum, DatumValue } from "../charts/shared/datumTypes";
  */
 import * as React from "react";
 import type { SemioticTheme } from "../store/ThemeStore";
+import type { AnnotationContext } from "../realtime/types";
 import { type AutoPlaceAnnotations } from "../recipes/annotationLayout";
 interface AnnotationScales {
     x?: AnnotationScale;
@@ -27,7 +28,9 @@ interface AnnotationScales {
 }
 type AnnotationScale = {
     bivarianceHack(value: DatumValue): number;
-}["bivarianceHack"];
+}["bivarianceHack"] & {
+    domain?: () => DatumValue[];
+};
 interface AnnotationLayout {
     width: number;
     height: number;
@@ -44,6 +47,17 @@ export interface StaticAnnotationConfig {
     yAccessor?: string;
     /** Ordinal projection — determines whether r maps to x or y */
     projection?: "vertical" | "horizontal" | "radial";
+    /**
+     * Custom SVG annotation renderer — same contract as the client
+     * `svgAnnotationRules` frame prop. When present, each annotation is
+     * offered to this rule first; returning `null`/`undefined` falls through
+     * to the built-in static type handlers. Without this, custom middle-
+     * marker / bulb overlays (and any other non-built-in annotation type)
+     * silently vanished from `renderChart` SVG.
+     */
+    svgAnnotationRules?: (annotation: Datum, index: number, context: AnnotationContext) => React.ReactNode;
+    /** Chart data forwarded into the AnnotationContext for custom rules. */
+    annotationData?: Datum[];
 }
 /**
  * Render annotations as static SVG elements.