semiotic 3.8.3 → 3.8.5

package/dist/components/charts/physics/crucibleTypes.d.ts

@@ -0,0 +1,415 @@
+/**
+ * Pure domain contracts for CrucibleChart.
+ *
+ * A Crucible run is a bounded, controlled event tape. Source components are
+ * assigned to at most one product, while products may remain `forming` across
+ * several events before being completed and poured to an outlet.
+ */
+import type { Datum } from "../shared/datumTypes";
+import type { ChartAccessor } from "../shared/types";
+import type { PhysicsPipelineConfig, PhysicsQueuedSpawn } from "../../stream/physics/PhysicsPipelineStore";
+import type { PhysicsColliderSpec } from "../../stream/physics/PhysicsKernel";
+export type CrucibleComponentStatus = "queued" | "active" | "transformed" | "consumed" | "retained" | "ejected" | "failed" | "recovered";
+export type CrucibleProductStatus = "forming" | "complete";
+export type CrucibleMotion = "charge" | "mix" | "hold" | "press" | "bind" | "separate" | "pour" | "quench";
+export type CrucibleMetricMap = Record<string, number>;
+export interface CruciblePhase {
+    id: string;
+    duration: number;
+    label?: string;
+    description?: string;
+    intensity?: number;
+    motion?: CrucibleMotion;
+    color?: string;
+    metrics?: Record<string, string | number>;
+}
+export interface CrucibleOutlet {
+    id: string;
+    label?: string;
+    description?: string;
+    side?: "left" | "right" | "bottom";
+    color?: string;
+    order?: number;
+}
+/**
+ * Source-component selector. Supplied fields intersect; ids are resolved in
+ * lexical order before `count` is applied so fresh arrays replay identically.
+ */
+export interface CrucibleSelector {
+    ids?: readonly string[];
+    categories?: readonly string[];
+    statuses?: readonly CrucibleComponentStatus[];
+    outletIds?: readonly string[];
+    count?: number;
+}
+/** A declared mold. State is created only when an effect forms the product. */
+export interface CrucibleProductDefinition {
+    id: string;
+    label?: string;
+    description?: string;
+    category?: string;
+    /** Optional declared final amount, applied when the product completes. */
+    amount?: number;
+    color?: string;
+    metrics?: CrucibleMetricMap;
+    outletId?: string;
+    order?: number;
+}
+export interface CrucibleLoss {
+    amount?: number;
+    metrics?: CrucibleMetricMap;
+    label?: string;
+}
+export interface CrucibleRelationDefinition {
+    id: string;
+    sourceIds: readonly string[];
+    label?: string;
+    category?: string;
+    strength?: number;
+    metrics?: CrucibleMetricMap;
+}
+export type CrucibleRelationResolution = "combined" | "rejected" | "expired";
+export interface CrucibleRelationState extends CrucibleRelationDefinition {
+    status: "active" | "resolved";
+    createdByEventId: string;
+    createdAt: number;
+    resolution?: CrucibleRelationResolution;
+    resolvedByEventId?: string;
+    resolvedAt?: number;
+    reason?: string;
+}
+export interface CrucibleSetStateEffect {
+    type: "set-state";
+    select: CrucibleSelector;
+    state: Exclude<CrucibleComponentStatus, "consumed">;
+    outletId?: string;
+    reason?: string;
+    metricsDelta?: CrucibleMetricMap;
+}
+export interface CrucibleSetRelationEffect {
+    type: "set-relation";
+    relation: CrucibleRelationDefinition;
+}
+export interface CrucibleResolveRelationEffect {
+    type: "resolve-relation";
+    relationIds: readonly string[];
+    resolution: CrucibleRelationResolution;
+    reason?: string;
+}
+export interface CrucibleCombineEffect {
+    type: "combine";
+    sourceIds: readonly string[];
+    productId: string;
+    basisRelationIds?: readonly string[];
+    loss?: CrucibleLoss;
+    /** Defaults to true. Set false to admit later `contribute` effects. */
+    complete?: boolean;
+}
+export interface CrucibleContributeEffect {
+    type: "contribute";
+    sourceIds: readonly string[];
+    productId: string;
+    basisRelationIds?: readonly string[];
+    loss?: CrucibleLoss;
+}
+export interface CrucibleCompleteProductEffect {
+    type: "complete-product";
+    productId: string;
+    outletId?: string;
+    reason?: string;
+}
+export interface CrucibleProductAllocation {
+    productId: string;
+    amount?: number;
+    metrics?: CrucibleMetricMap;
+}
+export interface CrucibleSplitEffect {
+    type: "split";
+    sourceId: string;
+    products: readonly CrucibleProductAllocation[];
+    loss?: CrucibleLoss;
+}
+export interface CrucibleEjectEffect {
+    type: "eject";
+    select: CrucibleSelector;
+    outletId: string;
+    state?: "ejected" | "failed" | "retained" | "recovered";
+    reason?: string;
+}
+export type CrucibleMetricTarget = "run" | {
+    components: CrucibleSelector;
+} | {
+    productIds: readonly string[];
+};
+export interface CrucibleSetMetricEffect {
+    type: "set-metric";
+    target: CrucibleMetricTarget;
+    metricsDelta: CrucibleMetricMap;
+}
+export interface CrucibleSetOutcomeEffect {
+    type: "set-outcome";
+    outcome: string;
+    summary?: string;
+}
+export type CrucibleEffect = CrucibleSetStateEffect | CrucibleSetRelationEffect | CrucibleResolveRelationEffect | CrucibleCombineEffect | CrucibleContributeEffect | CrucibleCompleteProductEffect | CrucibleSplitEffect | CrucibleEjectEffect | CrucibleSetMetricEffect | CrucibleSetOutcomeEffect;
+export type CrucibleEventAt = {
+    time: number;
+    phaseId?: never;
+    progress?: never;
+} | {
+    time?: never;
+    phaseId: string;
+    progress?: number;
+};
+export interface CrucibleEvent {
+    id: string;
+    at: CrucibleEventAt;
+    effects: readonly CrucibleEffect[];
+    label?: string;
+    description?: string;
+    summary?: string;
+}
+export interface CrucibleHistoryItem {
+    eventId: string;
+    effectType: CrucibleEffect["type"];
+    phaseId: string;
+    authoredAt: number;
+    appliedAt: number;
+    label?: string;
+    summary?: string;
+    sourceIds?: string[];
+    productIds?: string[];
+    relationIds?: string[];
+    outletIds?: string[];
+}
+export interface CrucibleComponentState<TDatum extends Datum = Datum> {
+    id: string;
+    label: string;
+    category: string;
+    datum: TDatum;
+    status: CrucibleComponentStatus;
+    initialAmount: number;
+    amount: number;
+    initialMetrics: CrucibleMetricMap;
+    metrics: CrucibleMetricMap;
+    productIds: string[];
+    outletId?: string;
+    reason?: string;
+    history: CrucibleHistoryItem[];
+}
+export interface CrucibleProductState {
+    id: string;
+    label: string;
+    description?: string;
+    category: string;
+    color?: string;
+    order?: number;
+    declaredAmount?: number;
+    amount: number;
+    metrics: CrucibleMetricMap;
+    status: CrucibleProductStatus;
+    sourceIds: string[];
+    outletId?: string;
+    createdByEventId: string;
+    createdAt: number;
+    completedByEventId?: string;
+    completedAt?: number;
+    reason?: string;
+    history: CrucibleHistoryItem[];
+}
+export interface CrucibleRunState<TDatum extends Datum = Datum> {
+    elapsed: number;
+    phaseElapsed: number;
+    phaseId: string;
+    phaseIndex: number;
+    playing: boolean;
+    complete: boolean;
+    outcome?: string;
+    summary?: string;
+    eventsApplied: string[];
+    components: Record<string, CrucibleComponentState<TDatum>>;
+    products: Record<string, CrucibleProductState>;
+    relations: Record<string, CrucibleRelationState>;
+    input: {
+        amount: number;
+        metrics: CrucibleMetricMap;
+    };
+    metrics: CrucibleMetricMap;
+    loss: {
+        amount: number;
+        metrics: CrucibleMetricMap;
+    };
+    history: CrucibleHistoryItem[];
+}
+export type CrucibleMaterializationType = "activate-relation" | "resolve-relation" | "form-product" | "update-product" | "complete-product" | "split-source" | "retarget-component" | "retarget-product";
+export interface CrucibleMaterialization {
+    type: CrucibleMaterializationType;
+    eventId: string;
+    sourceIds?: string[];
+    productIds?: string[];
+    relationIds?: string[];
+    outletIds?: string[];
+}
+export interface CrucibleObservation {
+    type: "crucible-event" | CrucibleMaterializationType | "crucible-outcome";
+    eventId: string;
+    phaseId: string;
+    authoredAt: number;
+    appliedAt: number;
+    sourceIds?: string[];
+    productIds?: string[];
+    relationIds?: string[];
+    outletIds?: string[];
+    outcome?: string;
+}
+export interface CrucibleDiagnostic {
+    severity: "warning" | "error";
+    code: string;
+    message: string;
+    path?: string;
+    ids?: string[];
+}
+export interface CrucibleApplyResult<TDatum extends Datum = Datum> {
+    applied: boolean;
+    state: CrucibleRunState<TDatum>;
+    materializations: CrucibleMaterialization[];
+    observations: CrucibleObservation[];
+    diagnostics: CrucibleDiagnostic[];
+}
+export interface CrucibleApplyContext {
+    phaseId: string;
+    authoredAt: number;
+    appliedAt: number;
+    products: readonly CrucibleProductDefinition[];
+    outlets: readonly CrucibleOutlet[];
+}
+export interface CrucibleCompiledPhase extends CruciblePhase {
+    index: number;
+    start: number;
+    end: number;
+}
+/** `boundaryRank` encodes phase-end (0), then next phase-start (1). */
+export interface CrucibleCompiledEvent extends CrucibleEvent {
+    index: number;
+    authoredAt: number;
+    phaseId: string;
+    phaseIndex: number;
+    boundaryRank: 0 | 1;
+}
+export interface CrucibleAccessors<TDatum extends Datum = Datum> {
+    idAccessor?: ChartAccessor<TDatum, string>;
+    labelAccessor?: ChartAccessor<TDatum, string>;
+    categoryAccessor?: ChartAccessor<TDatum, string>;
+    amountAccessor?: ChartAccessor<TDatum, number>;
+    metricsAccessor?: ChartAccessor<TDatum, CrucibleMetricMap>;
+    initialStateAccessor?: ChartAccessor<TDatum, CrucibleComponentStatus>;
+}
+export interface CrucibleCompileOptions<TDatum extends Datum = Datum> extends CrucibleAccessors<TDatum> {
+    data: readonly TDatum[];
+    phases: readonly CruciblePhase[];
+    products?: readonly CrucibleProductDefinition[];
+    outlets?: readonly CrucibleOutlet[];
+    events?: readonly CrucibleEvent[];
+    size?: [number, number];
+    seed?: number | string;
+    bodyRadius?: number;
+    radiusRange?: [number, number];
+    metrics?: CrucibleMetricMap;
+}
+export interface CrucibleLayoutOutlet extends CrucibleOutlet {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface CrucibleLayout {
+    width: number;
+    height: number;
+    phaseRail: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    chamber: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    mouth: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    projection: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    outlets: CrucibleLayoutOutlet[];
+}
+export interface CrucibleBodyDatum<TDatum extends Datum = Datum> {
+    __crucible: true;
+    kind: "component" | "product";
+    semanticId: string;
+    sourceDatum?: TDatum;
+    product?: CrucibleProductState;
+}
+export interface CrucibleCompiledPlan<TDatum extends Datum = Datum> {
+    phases: CrucibleCompiledPhase[];
+    events: CrucibleCompiledEvent[];
+    products: CrucibleProductDefinition[];
+    outlets: CrucibleOutlet[];
+    duration: number;
+    initialState: CrucibleRunState<TDatum>;
+    terminalState: CrucibleRunState<TDatum>;
+    layout: CrucibleLayout;
+    colliders: PhysicsColliderSpec[];
+    config: PhysicsPipelineConfig;
+    initialSpawns: PhysicsQueuedSpawn[];
+    terminalSpawns: PhysicsQueuedSpawn[];
+    semanticKey: string;
+    diagnostics: CrucibleDiagnostic[];
+}
+export interface CrucibleReplayResult<TDatum extends Datum = Datum> {
+    state: CrucibleRunState<TDatum>;
+    materializations: CrucibleMaterialization[];
+    observations: CrucibleObservation[];
+    diagnostics: CrucibleDiagnostic[];
+}
+export type CrucibleProjectionGroupBy = "status" | "outlet" | "category" | "product";
+export interface CrucibleProjectionSpec {
+    groupBy?: CrucibleProjectionGroupBy;
+    measure?: "count" | "amount" | string;
+    order?: readonly string[];
+    showInputBaseline?: boolean;
+    showDelta?: boolean;
+}
+export interface CrucibleProjectionRow {
+    key: string;
+    label: string;
+    count: number;
+    amount: number;
+    metrics: CrucibleMetricMap;
+    status?: CrucibleComponentStatus | CrucibleProductStatus;
+    outletId?: string;
+    category?: string;
+    productId?: string;
+}
+export interface CrucibleConservationSpec {
+    field?: "amount" | string;
+    tolerance?: number;
+}
+export interface CrucibleConservationResult {
+    field: string;
+    input: number;
+    products: number;
+    unassigned: number;
+    loss: number;
+    output: number;
+    delta: number;
+    conserved: boolean;
+}

package/dist/components/charts/physics/gauntletChartProps.d.ts

@@ -7,7 +7,7 @@ import type { PhysicsQueuedSpawn } from "../../stream/physics/PhysicsPipelineSto
 import type { Datum } from "../shared/datumTypes";
 import type { BaseChartProps, ChartAccessor } from "../shared/types";
 import type { PhysicsProcessBodyGroup } from "./physicsProcessPrimitives";
-import type { PhysicsHocFrameProps, PhysicsSharedChartProps, TooltipProp } from "./physicsHocUtils";
+import type { PhysicsHocFrameProps, PhysicsRerunMS, PhysicsSharedChartProps, TooltipProp } from "./physicsHocUtils";
 import type { GauntletEvent, GauntletGate, GauntletLayout, GauntletProjectPlacement, GauntletProjectState, GauntletPropertyDefinition } from "./gauntletTypes";
 export interface GauntletChartProps<TDatum extends Datum = Datum> extends Omit<BaseChartProps, "margin">, PhysicsSharedChartProps {
     data?: TDatum[];
@@ -43,6 +43,12 @@ export interface GauntletChartProps<TDatum extends Datum = Datum> extends Omit<B
         positiveProperties: Map<string, GauntletPropertyDefinition>;
     }) => string;
     paused?: boolean;
+    /**
+     * Replay the full compound simulation this many milliseconds after it
+     * settles. Omit or pass `null` for a single run; `0` replays on the next
+     * timer turn.
+     */
+    rerunMS?: PhysicsRerunMS;
     projectPlacement?: (project: GauntletProjectState<TDatum>, index: number, layout: GauntletLayout) => Partial<GauntletProjectPlacement>;
     showChrome?: boolean;
     /**

package/dist/components/charts/physics/gauntletChrome.d.ts

@@ -12,9 +12,10 @@ export declare function defaultGauntletTooltipContent(hover: PhysicsHoverData):
 export declare function drawGauntletBody(ctx: CanvasRenderingContext2D, body: PhysicsBodyState, style: Style): void;
 export declare function resolveCanvasColor(ctx: CanvasRenderingContext2D, value: Style[keyof Style] | undefined, fallback: string): string;
 export declare function drawTethers(ctx: CanvasRenderingContext2D, bodies: PhysicsBodyState[]): void;
-export declare function GauntletChrome({ layout, states }: {
+export declare function GauntletChrome({ layout, states, compact }: {
     layout: GauntletLayout;
     states: readonly GauntletProjectState[];
+    compact?: boolean;
 }): React.JSX.Element;
 export declare function gauntletSemanticItem(body: PhysicsBodyState): false | {
     label: string;

package/dist/components/charts/physics/gauntletPhysics.d.ts

@@ -10,7 +10,7 @@ export { CORE_KIND, POSITIVE_KIND, NEGATIVE_KIND } from "./gauntletTypes";
 export type { GauntletAccessors, GauntletBodyDatum, GauntletCoreBodyFn, GauntletEffect, GauntletEvent, GauntletEventContext, GauntletEventLogItem, GauntletGate, GauntletLayout, GauntletNegativeReplacementOptions, GauntletPopSpec, GauntletProjectPlacement, GauntletProjectPlacementFn, GauntletProjectState, GauntletPropertyDefinition, GauntletPropertyForceContext, GauntletPropertyWorkPlan, GauntletPropertyWorkPlanOptions, GauntletViabilityFn } from "./gauntletTypes";
 export declare const DEFAULT_WIDTH = 900;
 export declare const DEFAULT_HEIGHT = 520;
-export declare function gauntletWallColliders(layout: Pick<GauntletLayout, "width" | "floorY">): NonNullable<PhysicsPipelineConfig["colliders"]>;
+export declare function gauntletWallColliders(layout: Pick<GauntletLayout, "width" | "floorY"> & Partial<Pick<GauntletLayout, "height">>): NonNullable<PhysicsPipelineConfig["colliders"]>;
 export declare function readAccessor<TDatum extends Datum, TValue>(datum: TDatum, index: number, accessor: ChartAccessor<TDatum, TValue> | undefined, fallback: TValue): TValue;
 export declare function propertyLabel(property: GauntletPropertyDefinition | undefined): string;
 export declare function projectCoreId(projectId: string): string;
@@ -23,19 +23,34 @@ export declare const GAUNTLET_WALL: {
     readonly rightInset: 30;
     readonly thickness: 8;
 };
+type GauntletWallLayout = Pick<GauntletLayout, "width" | "floorY"> & Partial<Pick<GauntletLayout, "height">>;
+/** Scale the authored gauntlet corridor into context and sparkline boxes. */
+export declare function resolveGauntletWall(layout: GauntletWallLayout): {
+    readonly left: 28;
+    readonly top: 76;
+    readonly rightInset: 30;
+    readonly thickness: 8;
+} | {
+    left: number;
+    top: number;
+    rightInset: number;
+    thickness: number;
+};
+/** Scale default body/orbit geometry while preserving authored full-size values. */
+export declare function gauntletSpatialScale(layout: GauntletWallLayout): number;
 /**
  * Keep body centers inside the playable gauntlet corridor so satellite
  * property particles never spawn or settle outside the left/right walls
  * (the "stuck on the left" regression for Homes on Main Street).
  */
-export declare function clampGauntletPoint(x: number, y: number, radius: number, layout: Pick<GauntletLayout, "width" | "floorY">): {
+export declare function clampGauntletPoint(x: number, y: number, radius: number, layout: GauntletWallLayout): {
     x: number;
     y: number;
 };
 export declare function buildLayout(size: [number, number], gates: readonly GauntletGate[] | undefined, crashOffset: number): GauntletLayout;
 export declare function defaultPlacement(layout: GauntletLayout): Required<GauntletProjectPlacement>;
 export declare function resolvePlacement<TDatum extends Datum>(project: GauntletProjectState<TDatum>, index: number, layout: GauntletLayout, projectPlacement: GauntletProjectPlacementFn<TDatum> | undefined): Required<GauntletProjectPlacement>;
-export declare function featureSlot(ids: readonly string[], id: string): {
+export declare function featureSlot(ids: readonly string[], id: string, spatialScale?: number): {
     angle: number;
     index: number;
     radius: number;
@@ -68,4 +83,4 @@ export declare function buildGauntletPhysics<TDatum extends Datum = Datum>(optio
     initialSpawns: PhysicsQueuedSpawn[];
     layout: GauntletLayout;
 };
-export declare function buildNegativeSpawn<TDatum extends Datum>(project: GauntletProjectState<TDatum>, property: GauntletPropertyDefinition, index: number, x: number, y: number, layout: Pick<GauntletLayout, "width" | "floorY">, spawnAt?: number): PhysicsQueuedSpawn;
+export declare function buildNegativeSpawn<TDatum extends Datum>(project: GauntletProjectState<TDatum>, property: GauntletPropertyDefinition, index: number, x: number, y: number, layout: GauntletWallLayout, spawnAt?: number): PhysicsQueuedSpawn;

package/dist/components/charts/physics/gauntletRuntime.d.ts

@@ -34,7 +34,10 @@ export declare function spawnBodiesForGauntletEffect<TDatum extends Datum>(optio
         color?: string;
         durationMs?: number;
         radius?: number;
+        scale?: number;
     }) => unknown;
+    /** Uniform pop-burst scale (see StreamPhysicsPopOptions.scale). */
+    popScale?: number;
 }): void;
 export declare function projectRouteTarget<TDatum extends Datum>(elapsed: number, project: GauntletProjectState<TDatum>, layout: GauntletLayout, placement: Required<GauntletProjectPlacement>, events: readonly GauntletEvent[], gateById: Map<string, GauntletLayout["gates"][number]>, terminalBehavior: "outcome" | "hold-last"): {
     x: number;

package/dist/components/charts/physics/physicsHocUtils.d.ts

@@ -21,6 +21,18 @@ export type PhysicsSharedChartProps = {
 };
 /** Galton / pile sampling mode (orthogonal to ChartMode display modes). */
 export type PhysicsSimulationMode = "sample" | "mechanical";
+/** Delay between a settled physics run and a fresh seeded replay. */
+export type PhysicsRerunMS = number | null;
+/**
+ * Add an optional settle -> delay -> remount loop to a physics HOC.
+ *
+ * Remounting is intentional: it replays the chart's deterministic seed,
+ * initial bodies, and spawn pacing instead of trying to reverse a live store.
+ */
+export declare function usePhysicsRerun(config: StreamPhysicsFrameProps["config"], rerunMS: PhysicsRerunMS | undefined, paused: boolean | undefined, onRerun?: () => void): {
+    config: StreamPhysicsFrameProps["config"];
+    rerunKey: number;
+};
 /**
  * Split ChartMode (`primary`/`context`/`sparkline`/`mobile`) from the
  * Galton/pile `sample`/`mechanical` simulation mode. Accepts legacy

package/dist/components/charts/shared/chartMode.d.ts

@@ -36,6 +36,8 @@ export interface ChartModeInput {
     responsiveRules?: ResponsiveRule[];
 }
 export interface ChartModeResult {
+    /** Effective mode after responsive rules have been applied. */
+    mode: ChartMode;
     width: number;
     height: number;
     showAxes: boolean;
@@ -65,3 +67,9 @@ export declare function resolveChartMode(mode: ChartMode | undefined, userProps:
     width?: number;
     height?: number;
 }): ChartModeResult;
+/**
+ * Axis-free charts keep their established 10px regular-mode inset while
+ * adopting the shared context/sparkline margins. Reading `resolved` here is
+ * important: responsive rules may have changed the effective chart mode.
+ */
+export declare function resolveAxisFreeMarginDefaults(resolved: Pick<ChartModeResult, "compactMode" | "marginDefaults">): ChartModeResult["marginDefaults"];

package/dist/components/charts/shared/chartSpecCore.d.ts

@@ -32,7 +32,7 @@
  *     schema.json (and MCP responses) but are dropped from validationMap
  *     (which only reads `type` and `enum`).
  */
-export type PropType = "string" | "number" | "boolean" | "array" | "object" | "function";
+export type PropType = "string" | "number" | "boolean" | "array" | "object" | "function" | "null";
 export type DataShape = "array" | "object" | "network" | "realtime" | "none";
 export type ChartCategory = "xy" | "ordinal" | "network" | "geo" | "realtime" | "physics" | "value";
 /**
@@ -110,6 +110,14 @@ export interface ChartPropSpec {
     default?: unknown;
     /** Schema-side description; surfaces in LLM tool definitions. */
     description?: string;
+    /**
+     * Additional JSON Schema keywords for this prop. Use this for nested wire
+     * contracts (`items`, `properties`, `oneOf`, numeric bounds, and similar)
+     * that cannot be expressed by the shallow runtime validation map. These
+     * keywords are copied only to the AI/MCP schema; runtime validation still
+     * consumes the top-level `type` and `enum` above.
+     */
+    schema?: Readonly<Record<string, unknown>>;
     /**
      * When true, the prop is included in validationMap but omitted from
      * schema.json. Use for handler/callback props (`onClick`, `tooltip`)
@@ -157,7 +165,7 @@ export declare const ORIENTATION_ENUM: readonly ["vertical", "horizontal"];
 export declare const HORIZONTAL_VERTICAL_ENUM: readonly ["horizontal", "vertical"];
 export declare const LEGEND_POSITION_ENUM: readonly ["right", "left", "top", "bottom"];
 export declare const CURVE_ENUM: readonly ["linear", "monotoneX", "monotoneY", "step", "stepAfter", "stepBefore", "basis", "cardinal", "catmullRom"];
-export declare const CHART_MODE_ENUM: readonly ["primary", "context", "sparkline"];
+export declare const CHART_MODE_ENUM: readonly ["primary", "context", "sparkline", "mobile"];
 /**
  * Compose a chart's full prop set (bags + ownProps) in deterministic order.
  * ownProps wins on key collision so a chart can override a shared default.

package/dist/components/charts/shared/crucibleWireSchema.d.ts

@@ -0,0 +1,5 @@
+/** Nested JSON Schema fragments for CrucibleChart's serializable program. */
+export declare const CRUCIBLE_PHASES_SCHEMA: Readonly<Record<string, unknown>>;
+export declare const CRUCIBLE_PRODUCTS_SCHEMA: Readonly<Record<string, unknown>>;
+export declare const CRUCIBLE_OUTLETS_SCHEMA: Readonly<Record<string, unknown>>;
+export declare const CRUCIBLE_EVENTS_SCHEMA: Readonly<Record<string, unknown>>;

package/dist/components/charts/shared/diagnoseTypes.d.ts

@@ -3,6 +3,16 @@ export interface Diagnosis {
     code: string;
     message: string;
     fix: string;
+    /** Optional evaluator domain; omitted by legacy configuration checks. */
+    domain?: "data" | "configuration" | "accessibility" | "render";
+    /** Numeric/data checks attach the resolved accessor label. */
+    field?: string;
+    /** Numeric/data checks attach the semantic encoding role. */
+    role?: string;
+    /** Bounded zero-based row indices for actionable data findings. */
+    rows?: ReadonlyArray<number>;
+    /** Full affected-row/group count when `rows` is truncated. */
+    count?: number;
 }
 export interface DiagnosisResult {
     ok: boolean;

package/dist/components/charts/shared/hatchPattern.d.ts

@@ -12,6 +12,7 @@
  * />
  * ```
  */
+import type { HatchFill } from "./hatchFill";
 export interface HatchPatternOptions {
     /** Background color of the pattern tile */
     background?: string;
@@ -27,9 +28,13 @@ export interface HatchPatternOptions {
 /**
  * Create a repeating diagonal-line hatch pattern for canvas fills.
  *
- * Must be called in a browser environment (needs canvas). Returns null
- * in server/test environments where canvas is unavailable.
+ * In a browser (canvas available) returns a `CanvasPattern`. In server/test
+ * environments — where canvas is unavailable — returns the equivalent
+ * serializable {@link HatchFill} descriptor instead of `null`, so the same
+ * `pieceStyle`/`nodeStyle` renders a hatch through the SVG path rather than
+ * collapsing to the solid fallback. Use {@link isHatchFill} to distinguish the
+ * two forms; both are valid as a `style.fill`.
  */
 export declare function createHatchPattern(options?: HatchPatternOptions, 
 /** Optional target canvas to create the pattern on (for correct DPR scaling) */
-targetCtx?: CanvasRenderingContext2D): CanvasPattern | null;
+targetCtx?: CanvasRenderingContext2D): CanvasPattern | HatchFill | null;

package/dist/components/charts/shared/knownChartComponents.d.ts

@@ -5,5 +5,5 @@
  * This compact registry is intentionally separate from validation metadata:
  * config serialization only needs chart-name membership.
  */
-export declare const KNOWN_CHART_COMPONENTS: readonly ["BarChart", "StackedBarChart", "GroupedBarChart", "SwarmPlot", "BoxPlot", "Histogram", "ViolinPlot", "RidgelinePlot", "DotPlot", "PieChart", "DonutChart", "GaugeChart", "FunnelChart", "SwimlaneChart", "LikertChart", "LineChart", "AreaChart", "DifferenceChart", "StackedAreaChart", "Scatterplot", "BubbleChart", "Heatmap", "QuadrantChart", "MultiAxisLineChart", "CandlestickChart", "ConnectedScatterplot", "ScatterplotMatrix", "MinimapChart", "ForceDirectedGraph", "SankeyDiagram", "ProcessSankey", "ChordDiagram", "TreeDiagram", "Treemap", "CirclePack", "OrbitDiagram", "ChoroplethMap", "ProportionalSymbolMap", "FlowMap", "DistanceCartogram", "RealtimeLineChart", "RealtimeHistogram", "TemporalHistogram", "RealtimeSwarmChart", "RealtimeWaterfallChart", "RealtimeHeatmap", "GaltonBoardChart", "EventDropChart", "PhysicsPileChart", "CollisionSwarmChart", "GauntletChart", "ProcessFlowChart", "PhysicalFlowChart", "BigNumber"];
+export declare const KNOWN_CHART_COMPONENTS: readonly ["BarChart", "StackedBarChart", "GroupedBarChart", "SwarmPlot", "BoxPlot", "Histogram", "ViolinPlot", "RidgelinePlot", "DotPlot", "PieChart", "DonutChart", "GaugeChart", "FunnelChart", "SwimlaneChart", "LikertChart", "LineChart", "AreaChart", "DifferenceChart", "StackedAreaChart", "Scatterplot", "BubbleChart", "Heatmap", "QuadrantChart", "MultiAxisLineChart", "CandlestickChart", "ConnectedScatterplot", "ScatterplotMatrix", "MinimapChart", "ForceDirectedGraph", "SankeyDiagram", "ProcessSankey", "ChordDiagram", "TreeDiagram", "Treemap", "CirclePack", "OrbitDiagram", "ChoroplethMap", "ProportionalSymbolMap", "FlowMap", "DistanceCartogram", "RealtimeLineChart", "RealtimeHistogram", "TemporalHistogram", "RealtimeSwarmChart", "RealtimeWaterfallChart", "RealtimeHeatmap", "GaltonBoardChart", "EventDropChart", "PhysicsPileChart", "CollisionSwarmChart", "GauntletChart", "CrucibleChart", "ProcessFlowChart", "PhysicalFlowChart", "BigNumber"];
 export declare function isKnownChartComponent(componentName: string): boolean;