nirs4all-ui 0.1.12 → 0.1.13

package/dist/chains/types.d.ts

@@ -0,0 +1,240 @@
+/**
+ * Package-level view-model contract for the chain-effect explorer.
+ *
+ * A "chain" is one executed *linear* pipeline — an ordered sequence of steps
+ * (e.g. `SNV → SavGol → PLS`) that produced a comparable score (nRMSE, RMSE,
+ * R², …) on some dataset/source. This domain turns a corpus of *hundreds* of
+ * scored chains into the influence of each node: how much a step helps or
+ * hurts globally, whether it is better early / mid / late in the chain, and
+ * whether its effect depends on what precedes it (e.g. "MSC after SNV").
+ *
+ * This is a small, framework-free contract — deliberately NOT a dependency on
+ * `dag-ml`. The *authoritative* analysis (per-dataset score normalization with
+ * lineage) is a coordination concern that lives native in `dag-ml`; this
+ * package renders its serialized artifact (see {@link file://./contract.ts})
+ * and also ships a descriptive {@link file://./analysis.ts fromScoredChains}
+ * adapter — the same view-model tier as `viz/geometry` — so hosts can render
+ * from a raw scored-chain list before the native producer exists.
+ */
+/** Coarse role of a step; drives color, legend, and position/sequence scoping. */
+export type ChainStepRole = "split" | "preprocess" | "feature" | "model" | "augmentation" | "target" | "other";
+/** One node occurrence inside a chain. */
+export interface ChainStep {
+    /** Canonical id, e.g. `"snv"`, `"msc"`, `"savgol"`, `"pls"`. */
+    token: string;
+    /** Display label; defaults to `token`. */
+    label?: string;
+    role: ChainStepRole;
+}
+/** A single executed chain with a comparable score (host-provided raw input). */
+export interface ScoredChain {
+    id: string;
+    /** Ordered steps, first → last. */
+    steps: readonly ChainStep[];
+    /** Metric value (e.g. nRMSE). Direction is carried by {@link ChainMetric}. */
+    score: number;
+    /** Dataset the chain ran on — the unit of per-dataset normalization. */
+    dataset?: string;
+    /** Source / modality (multisource, multimodal). */
+    source?: string;
+}
+/** The metric the scores are expressed in, plus its optimization direction. */
+export interface ChainMetric {
+    key: string;
+    label: string;
+    /** `true` for error metrics (nRMSE, RMSE); `false` for R²/accuracy. */
+    lowerIsBetter: boolean;
+}
+/**
+ * Normalization lens that makes heterogeneous datasets comparable.
+ * - `raw`: oriented score as-is (best for a single dataset).
+ * - `rankByDataset`: percentile rank within each dataset (0..1, 1 = best) —
+ *   robust, non-parametric; the recommended default for cross-dataset corpora.
+ * - `zByDataset`: z-score within each dataset (higher = better).
+ */
+export type ScoreLens = "raw" | "rankByDataset" | "zByDataset";
+/** A deduplicated token reference (first-occurrence order within a chain). */
+export interface ChainTokenRef {
+    token: string;
+    label: string;
+    role: ChainStepRole;
+}
+/** One chain projected to a comparable "goodness" (higher = better). */
+export interface ChainPoint {
+    id: string;
+    /** Raw metric value (for tooltips). */
+    score: number;
+    /** Oriented, lens-normalized score; higher is always better. */
+    goodness: number;
+    /** Dataset key (`"∗"` when unknown). */
+    dataset: string;
+    /** Source key (`"∗"` when unknown). */
+    source: string;
+    /** Unique tokens present (membership test). */
+    tokens: readonly string[];
+    /** First-occurrence-ordered, deduped step references. */
+    orderedTokens: readonly ChainTokenRef[];
+}
+/** Five-number summary + sample size of a goodness distribution. */
+export interface Stat {
+    n: number;
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+    mean: number;
+}
+/** Global effect of one token: distribution with vs without, and the delta. */
+export interface TokenEffect {
+    token: string;
+    label: string;
+    role: ChainStepRole;
+    /** Chains containing the token. */
+    n: number;
+    /** `n / total`. */
+    coverage: number;
+    /** Goodness of chains that contain the token. */
+    with: Stat;
+    /** Goodness of chains that do not. */
+    without: Stat;
+    /** `with.median − without.median` (NaN when either side is empty). */
+    delta: number;
+}
+/** The full analysis view-model consumed by every chart in this domain. */
+export interface ChainEffectAnalysis {
+    lens: ScoreLens;
+    metric: ChainMetric;
+    total: number;
+    datasets: readonly string[];
+    sources: readonly string[];
+    roles: readonly ChainStepRole[];
+    /** Reference goodness (global median); the diverging color pivot. */
+    baseline: number;
+    goodnessExtent: {
+        min: number;
+        max: number;
+    };
+    points: readonly ChainPoint[];
+    /** Per-token effects, sorted by `delta` desc (NaN last). */
+    tokens: readonly TokenEffect[];
+}
+/** Position bucketization: absolute ordinal or relative early/mid/late phase. */
+export type PositionMode = "absolute" | "phase";
+export interface PositionBucket {
+    key: string;
+    label: string;
+}
+export interface PositionRow {
+    token: string;
+    label: string;
+    role: ChainStepRole;
+    /** Index-aligned to the matrix buckets; `null` below the min-count gate. */
+    cells: readonly (Stat | null)[];
+}
+export interface PositionMatrix {
+    mode: PositionMode;
+    buckets: readonly PositionBucket[];
+    rows: readonly PositionRow[];
+    baseline: number;
+}
+/** Predecessor (rows) × successor (cols) goodness matrix. */
+export interface SequenceMatrix {
+    tokens: readonly ChainTokenRef[];
+    /** `cells[pred][succ]`; `null` on the diagonal or below the min-count gate. */
+    cells: readonly (readonly (Stat | null)[])[];
+    baseline: number;
+    adjacentOnly: boolean;
+}
+export interface ContextRow {
+    token: string;
+    label: string;
+    role: ChainStepRole;
+    stat: Stat;
+    /** `stat.median − baseline`. */
+    delta: number;
+}
+/** Best/worst neighbours for a focus token (drives the explorer detail panel). */
+export interface TokenContexts {
+    token: string;
+    /** Tokens occurring before the focus, sorted by median goodness desc. */
+    predecessors: readonly ContextRow[];
+    /** Tokens occurring after the focus, sorted by median goodness desc. */
+    successors: readonly ContextRow[];
+}
+/** One co-occurring node linked to a focus node (an orbit wedge). */
+export interface NeighborLink {
+    token: string;
+    label: string;
+    role: ChainStepRole;
+    /** Chains containing both the focus and this token — the link weight. */
+    count: number;
+    /** Goodness distribution of those shared chains. */
+    stat: Stat;
+    /** `stat.median − baseline` (the combined effect). */
+    delta: number;
+}
+/** One node in the directional flow tree (a sunburst wedge with children). */
+export interface FlowNode {
+    token: string;
+    label: string;
+    role: ChainStepRole;
+    /** Chains matching the ordered path focus → … → this node. */
+    count: number;
+    stat: Stat;
+    /** `stat.median − baseline`. */
+    delta: number;
+    /** The next step(s) after this node, nested one ring further out. */
+    children: readonly FlowNode[];
+}
+/**
+ * Directional flow around a focus node — the multi-ring sunburst model:
+ * predecessors (what leads in, one inner ring) and a successor tree (what
+ * follows, expanded outward `depth` rings).
+ */
+export interface NodeFlow {
+    token: string;
+    label: string;
+    role: ChainStepRole;
+    /** Goodness of every chain containing the focus. */
+    self: Stat;
+    /** Nodes occurring before the focus — the inner ring. */
+    predecessors: readonly NeighborLink[];
+    /** Ordered continuation after the focus — the outer sunburst. */
+    successors: readonly FlowNode[];
+    baseline: number;
+    goodnessExtent: {
+        min: number;
+        max: number;
+    };
+}
+/** A focus node and its co-occurring neighbours — the single-ring model. */
+export interface NodeNeighborhood {
+    token: string;
+    label: string;
+    role: ChainStepRole;
+    /** Goodness of every chain containing the focus. */
+    self: Stat;
+    /** Neighbours sorted by link weight desc (capped by `maxNeighbors`). */
+    neighbors: readonly NeighborLink[];
+    /** Neighbour tokens folded out beyond the cap. */
+    otherCount: number;
+    /** Summed link weight of the folded neighbours (the "others" wedge span). */
+    otherWeight: number;
+    baseline: number;
+    goodnessExtent: {
+        min: number;
+        max: number;
+    };
+}
+/** Human-facing role labels for legends and chips. */
+export declare const CHAIN_ROLE_LABELS: Readonly<Record<ChainStepRole, string>>;
+/** Stable display order for roles (used when listing/grouping). */
+export declare const CHAIN_ROLE_ORDER: readonly ChainStepRole[];
+/** Roles whose *order* is meaningful — the "transform stack" of a chain. */
+export declare const CHAIN_TRANSFORM_ROLES: readonly ChainStepRole[];
+/** Short labels for each normalization lens. */
+export declare const CHAIN_LENS_LABELS: Readonly<Record<ScoreLens, string>>;
+/** Coerce an arbitrary role string to a known {@link ChainStepRole}. */
+export declare function coerceChainRole(role: string | undefined): ChainStepRole;
+//# sourceMappingURL=types.d.ts.map

package/dist/chains/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/chains/types.ts"],"names":[],"mappings":"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"}

package/dist/chains/types.js

@@ -0,0 +1,52 @@
+/**
+ * Package-level view-model contract for the chain-effect explorer.
+ *
+ * A "chain" is one executed *linear* pipeline — an ordered sequence of steps
+ * (e.g. `SNV → SavGol → PLS`) that produced a comparable score (nRMSE, RMSE,
+ * R², …) on some dataset/source. This domain turns a corpus of *hundreds* of
+ * scored chains into the influence of each node: how much a step helps or
+ * hurts globally, whether it is better early / mid / late in the chain, and
+ * whether its effect depends on what precedes it (e.g. "MSC after SNV").
+ *
+ * This is a small, framework-free contract — deliberately NOT a dependency on
+ * `dag-ml`. The *authoritative* analysis (per-dataset score normalization with
+ * lineage) is a coordination concern that lives native in `dag-ml`; this
+ * package renders its serialized artifact (see {@link file://./contract.ts})
+ * and also ships a descriptive {@link file://./analysis.ts fromScoredChains}
+ * adapter — the same view-model tier as `viz/geometry` — so hosts can render
+ * from a raw scored-chain list before the native producer exists.
+ */
+/** Human-facing role labels for legends and chips. */
+export const CHAIN_ROLE_LABELS = {
+    split: "Split / CV",
+    preprocess: "Preprocess",
+    feature: "Feature",
+    model: "Model",
+    augmentation: "Augmentation",
+    target: "Target",
+    other: "Other",
+};
+/** Stable display order for roles (used when listing/grouping). */
+export const CHAIN_ROLE_ORDER = [
+    "split",
+    "preprocess",
+    "feature",
+    "augmentation",
+    "model",
+    "target",
+    "other",
+];
+/** Roles whose *order* is meaningful — the "transform stack" of a chain. */
+export const CHAIN_TRANSFORM_ROLES = ["preprocess", "feature", "augmentation"];
+/** Short labels for each normalization lens. */
+export const CHAIN_LENS_LABELS = {
+    raw: "Raw score",
+    rankByDataset: "Rank in dataset",
+    zByDataset: "Z in dataset",
+};
+const VALID_ROLES = new Set(CHAIN_ROLE_ORDER);
+/** Coerce an arbitrary role string to a known {@link ChainStepRole}. */
+export function coerceChainRole(role) {
+    return role && VALID_ROLES.has(role) ? role : "other";
+}
+//# sourceMappingURL=types.js.map

package/dist/chains/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/chains/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAwOH,sDAAsD;AACtD,MAAM,CAAC,MAAM,iBAAiB,GAA4C;IACxE,KAAK,EAAE,YAAY;IACnB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,YAAY,EAAE,cAAc;IAC5B,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;CACf,CAAC;AAEF,mEAAmE;AACnE,MAAM,CAAC,MAAM,gBAAgB,GAA6B;IACxD,OAAO;IACP,YAAY;IACZ,SAAS;IACT,cAAc;IACd,OAAO;IACP,QAAQ;IACR,OAAO;CACR,CAAC;AAEF,4EAA4E;AAC5E,MAAM,CAAC,MAAM,qBAAqB,GAA6B,CAAC,YAAY,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;AAEzG,gDAAgD;AAChD,MAAM,CAAC,MAAM,iBAAiB,GAAwC;IACpE,GAAG,EAAE,WAAW;IAChB,aAAa,EAAE,iBAAiB;IAChC,UAAU,EAAE,cAAc;CAC3B,CAAC;AAEF,MAAM,WAAW,GAAG,IAAI,GAAG,CAAgB,gBAAgB,CAAC,CAAC;AAE7D,wEAAwE;AACxE,MAAM,UAAU,eAAe,CAAC,IAAwB;IACtD,OAAO,IAAI,IAAI,WAAW,CAAC,GAAG,CAAC,IAAqB,CAAC,CAAC,CAAC,CAAE,IAAsB,CAAC,CAAC,CAAC,OAAO,CAAC;AAC5F,CAAC"}

package/dist/components/ConformalPredictionTree.d.ts

@@ -0,0 +1,79 @@
+import type { ReactNode } from "react";
+import { type Extent } from "../viz/geometry.js";
+import type { ConformalGuaranteeView, ConformalIntervalSummaryRow, ConformalPredictionIntervalCell, ConformalPredictionRow } from "../conformal/result.js";
+export type ConformalTreeGroupMode = "conformance" | "uncertainty" | "none";
+export type ConformalTierTone = "success" | "warning" | "danger" | "neutral";
+/** One prediction, projected onto its conformance / uncertainty coordinates. */
+export interface ConformalTreeSample {
+    index: number;
+    sampleId: string | null;
+    prediction: number;
+    predictionLabel: string;
+    actual: number | null;
+    /** Width of the target-coverage interval (falls back to the widest band). */
+    targetWidth: number | null;
+    widestWidth: number;
+    coveredAtTarget: boolean | null;
+    /** Smallest coverage level whose interval still contains the truth. */
+    tightestCovering: number | null;
+    intervals: readonly ConformalPredictionIntervalCell[];
+}
+export interface ConformalTreeTier {
+    id: string;
+    label: string;
+    description: string;
+    tone: ConformalTierTone;
+    samples: ConformalTreeSample[];
+    count: number;
+    share: number;
+    meanWidth: number | null;
+}
+export interface ConformalTreeModel {
+    tiers: ConformalTreeTier[];
+    coverages: number[];
+    domain: Extent;
+    target: number;
+    total: number;
+    hasActuals: boolean;
+    groupBy: ConformalTreeGroupMode;
+}
+export interface BuildConformalTreeOptions {
+    actuals?: readonly (number | null | undefined)[] | undefined;
+    targetCoverage?: number | null | undefined;
+    groupBy?: "auto" | ConformalTreeGroupMode | undefined;
+}
+/**
+ * Project calibrated prediction rows into a grouped, nesting-aware tree model —
+ * the pure view-model behind {@link ConformalPredictionTree}. Grouping is by
+ * where the truth falls within the nested intervals (conformance) when ground
+ * truth is present, otherwise by interval width (uncertainty).
+ */
+export declare function buildConformalTreeModel(rows: readonly ConformalPredictionRow[], options?: BuildConformalTreeOptions): ConformalTreeModel;
+export interface ConformalPredictionTreeProps {
+    rows: readonly ConformalPredictionRow[];
+    /** Ground-truth values aligned to `rows` — enables conformance grouping + scoring. */
+    actuals?: readonly (number | null | undefined)[];
+    /** Materialized interval summaries (qhat per coverage) for the leaf rows. */
+    summaries?: readonly ConformalIntervalSummaryRow[];
+    guarantee?: ConformalGuaranteeView | null;
+    targetCoverage?: number | null;
+    groupBy?: "auto" | ConformalTreeGroupMode;
+    unit?: string;
+    defaultOpenTiers?: boolean;
+    maxSamplesPerTier?: number;
+    glyphWidth?: number;
+    className?: string;
+    empty?: ReactNode;
+}
+/**
+ * Calibrated **predictions as a nested conformance tree** — the drill-down
+ * companion to {@link file://../viz/ConformalIntervalStrip.tsx ConformalIntervalStrip}.
+ * Predictions are grouped into conformance tiers (where the truth lands inside
+ * the nested intervals) or uncertainty tiers (interval width), each tier opening
+ * into per-sample nodes that carry a nesting glyph, and each sample opening into
+ * its per-coverage interval rows. Presentational + local `<details>` state only;
+ * hosts pass `conformal` view-model rows. Default styles ship at
+ * `nirs4all-ui/assets/conformal.css`.
+ */
+export declare function ConformalPredictionTree({ rows, actuals, summaries, guarantee, targetCoverage, groupBy, unit, defaultOpenTiers, maxSamplesPerTier, glyphWidth, className, empty, }: ConformalPredictionTreeProps): import("react").JSX.Element;
+//# sourceMappingURL=ConformalPredictionTree.d.ts.map

package/dist/components/ConformalPredictionTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConformalPredictionTree.d.ts","sourceRoot":"","sources":["../../src/components/ConformalPredictionTree.tsx"],"names":[],"mappings":"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"}

package/dist/components/ConformalPredictionTree.js

@@ -0,0 +1,223 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { clamp, makeScale, niceExtent, quantileSorted, round, } from "../viz/geometry.js";
+import { N4_VIZ_COLORS } from "../viz/theme.js";
+import { conformalBandShade } from "../viz/ConformalIntervalStrip.js";
+const COVERED_COLOR = "#059669";
+const MISSED_COLOR = N4_VIZ_COLORS.rose;
+const PREDICTION_COLOR = N4_VIZ_COLORS.indigo;
+function cellWidth(cell) {
+    return cell.upper - cell.lower;
+}
+function coversActual(cell, actual) {
+    return actual >= cell.lower && actual <= cell.upper;
+}
+/**
+ * Project calibrated prediction rows into a grouped, nesting-aware tree model —
+ * the pure view-model behind {@link ConformalPredictionTree}. Grouping is by
+ * where the truth falls within the nested intervals (conformance) when ground
+ * truth is present, otherwise by interval width (uncertainty).
+ */
+export function buildConformalTreeModel(rows, options = {}) {
+    const { actuals, targetCoverage = null, groupBy = "auto" } = options;
+    const coverages = [...new Set(rows.flatMap((row) => row.intervals.map((cell) => cell.coverage)))]
+        .filter((coverage) => Number.isFinite(coverage))
+        .sort((a, b) => b - a);
+    const minCoverage = coverages.length > 0 ? coverages[coverages.length - 1] : Number.NaN;
+    const target = targetCoverage != null && coverages.includes(targetCoverage)
+        ? targetCoverage
+        : (coverages[0] ?? Number.NaN);
+    const valuePool = [];
+    const samples = rows.map((row, index) => {
+        const rawActual = actuals?.[index];
+        const actual = rawActual != null && Number.isFinite(rawActual) ? rawActual : null;
+        valuePool.push(row.yPred);
+        if (actual != null)
+            valuePool.push(actual);
+        let widest = 0;
+        let tightestCovering = null;
+        for (const cell of row.intervals) {
+            valuePool.push(cell.lower, cell.upper);
+            widest = Math.max(widest, cellWidth(cell));
+            if (actual != null && coversActual(cell, actual)) {
+                tightestCovering = tightestCovering == null ? cell.coverage : Math.min(tightestCovering, cell.coverage);
+            }
+        }
+        const targetCell = row.intervals.find((cell) => cell.coverage === target) ?? null;
+        return {
+            index: row.index,
+            sampleId: row.sampleId,
+            prediction: row.yPred,
+            predictionLabel: row.yPredLabel,
+            actual,
+            targetWidth: targetCell ? cellWidth(targetCell) : null,
+            widestWidth: widest,
+            coveredAtTarget: actual == null ? null : tightestCovering != null && tightestCovering <= target,
+            tightestCovering,
+            intervals: row.intervals,
+        };
+    });
+    const hasActuals = samples.some((sample) => sample.actual != null);
+    const mode = groupBy === "auto"
+        ? (hasActuals ? "conformance" : "uncertainty")
+        : groupBy;
+    const domain = niceExtent(valuePool, 0.04);
+    const tiers = mode === "conformance"
+        ? conformanceTiers(samples, target, minCoverage)
+        : mode === "uncertainty"
+            ? uncertaintyTiers(samples)
+            : flatTier(samples);
+    return {
+        tiers: tiers.filter((tier) => tier.count > 0),
+        coverages,
+        domain,
+        target,
+        total: samples.length,
+        hasActuals,
+        groupBy: mode,
+    };
+}
+function tierWidth(sample) {
+    return sample.targetWidth ?? sample.widestWidth;
+}
+function finalizeTier(id, label, description, tone, samples, total) {
+    const widths = samples.map(tierWidth).filter((width) => Number.isFinite(width));
+    const meanWidth = widths.length > 0 ? widths.reduce((sum, width) => sum + width, 0) / widths.length : null;
+    return {
+        id,
+        label,
+        description,
+        tone,
+        samples,
+        count: samples.length,
+        share: total > 0 ? samples.length / total : 0,
+        meanWidth,
+    };
+}
+function conformanceTiers(samples, target, minCoverage) {
+    const core = [];
+    const within = [];
+    const wide = [];
+    const violation = [];
+    const unknown = [];
+    for (const sample of samples) {
+        if (sample.actual == null) {
+            unknown.push(sample);
+        }
+        else if (sample.tightestCovering == null) {
+            violation.push(sample);
+        }
+        else if (sample.tightestCovering <= minCoverage) {
+            core.push(sample);
+        }
+        else if (sample.tightestCovering <= target) {
+            within.push(sample);
+        }
+        else {
+            wide.push(sample);
+        }
+    }
+    return [
+        finalizeTier("core", "Truth in the tightest band", "Covered even by the narrowest calibrated interval.", "success", core, samples.length),
+        finalizeTier("within", "Covered at target", "Covered at the guarantee level but not the tightest band.", "success", within, samples.length),
+        finalizeTier("wide", "Covered only when widened", "Truth falls outside the target band but inside a wider one.", "warning", wide, samples.length),
+        finalizeTier("violation", "Interval violations", "Truth escapes every calibrated interval.", "danger", violation, samples.length),
+        finalizeTier("unknown", "No ground truth", "Prediction intervals only — no observed value to score.", "neutral", unknown, samples.length),
+    ];
+}
+function uncertaintyTiers(samples) {
+    const sortedWidths = samples.map(tierWidth).filter((width) => Number.isFinite(width)).sort((a, b) => a - b);
+    const q33 = quantileSorted(sortedWidths, 1 / 3);
+    const q66 = quantileSorted(sortedWidths, 2 / 3);
+    const tight = [];
+    const moderate = [];
+    const broad = [];
+    for (const sample of samples) {
+        const width = tierWidth(sample);
+        if (width <= q33)
+            tight.push(sample);
+        else if (width <= q66)
+            moderate.push(sample);
+        else
+            broad.push(sample);
+    }
+    return [
+        finalizeTier("tight", "Tight intervals", "The most confident predictions — narrowest calibrated intervals.", "success", tight, samples.length),
+        finalizeTier("moderate", "Typical intervals", "Interval widths around the median of the set.", "neutral", moderate, samples.length),
+        finalizeTier("broad", "Wide intervals", "The least certain predictions — widest calibrated intervals.", "warning", broad, samples.length),
+    ];
+}
+function flatTier(samples) {
+    return [finalizeTier("all", "All predictions", "Every calibrated prediction.", "neutral", samples, samples.length)];
+}
+function fmtCoverage(coverage) {
+    if (!Number.isFinite(coverage))
+        return "—";
+    const percent = coverage * 100;
+    return `${Number.isInteger(percent) ? percent.toFixed(0) : percent.toFixed(1)}%`;
+}
+function fmtShare(share) {
+    const percent = share * 100;
+    return `${percent < 10 && percent > 0 ? percent.toFixed(1) : percent.toFixed(0)}%`;
+}
+function fmtWidth(width) {
+    if (width == null || !Number.isFinite(width))
+        return "—";
+    if (Math.abs(width) >= 1000)
+        return width.toFixed(0);
+    if (Math.abs(width) >= 1)
+        return width.toFixed(2);
+    return width.toFixed(3);
+}
+function shadeForCoverage(coverage, coverages) {
+    if (coverages.length <= 1)
+        return conformalBandShade(0.62);
+    const rank = coverages.indexOf(coverage);
+    return conformalBandShade(rank / (coverages.length - 1));
+}
+/** Per-sample horizontal nesting of the calibrated intervals + truth marker. */
+function NestedBandGlyph({ sample, coverages, domain, width, height = 22 }) {
+    const padX = 3;
+    const scale = makeScale(domain, padX, width - padX);
+    const barTop = 3;
+    const barHeight = height - barTop * 2;
+    const bands = [...sample.intervals].sort((a, b) => b.coverage - a.coverage);
+    return (_jsxs("svg", { className: "n4conf-glyph", viewBox: `0 0 ${width} ${height}`, width: width, height: height, role: "img", "aria-label": `Nested intervals for ${sample.sampleId ?? `sample ${sample.index}`}`, preserveAspectRatio: "none", children: [bands.map((cell) => {
+                const x1 = scale(cell.lower);
+                const x2 = scale(cell.upper);
+                return (_jsx("rect", { className: "n4conf-glyph-band", x: round(Math.min(x1, x2)), y: barTop, width: round(Math.abs(x2 - x1)), height: barHeight, rx: 2, fill: shadeForCoverage(cell.coverage, coverages) }, `b-${cell.coverage}`));
+            }), _jsx("line", { className: "n4conf-glyph-point", x1: round(scale(sample.prediction)), x2: round(scale(sample.prediction)), y1: barTop - 1, y2: height - barTop + 1, stroke: PREDICTION_COLOR, strokeWidth: 2 }), sample.actual != null ? (sample.coveredAtTarget !== false ? (_jsx("circle", { cx: round(scale(sample.actual)), cy: height / 2, r: 3.2, fill: COVERED_COLOR, stroke: "var(--n4-color-surface, #fff)", strokeWidth: 1.5 })) : (_jsx("path", { d: diamond(scale(sample.actual), height / 2, 3.8), fill: MISSED_COLOR, stroke: "var(--n4-color-surface, #fff)", strokeWidth: 1.5 }))) : null] }));
+}
+/**
+ * Calibrated **predictions as a nested conformance tree** — the drill-down
+ * companion to {@link file://../viz/ConformalIntervalStrip.tsx ConformalIntervalStrip}.
+ * Predictions are grouped into conformance tiers (where the truth lands inside
+ * the nested intervals) or uncertainty tiers (interval width), each tier opening
+ * into per-sample nodes that carry a nesting glyph, and each sample opening into
+ * its per-coverage interval rows. Presentational + local `<details>` state only;
+ * hosts pass `conformal` view-model rows. Default styles ship at
+ * `nirs4all-ui/assets/conformal.css`.
+ */
+export function ConformalPredictionTree({ rows, actuals, summaries, guarantee = null, targetCoverage = null, groupBy = "auto", unit, defaultOpenTiers = true, maxSamplesPerTier = 50, glyphWidth = 150, className, empty, }) {
+    if (rows.length === 0)
+        return empty == null ? _jsx("div", { className: cx("n4conf-tree", className) }) : _jsx(_Fragment, { children: empty });
+    const model = buildConformalTreeModel(rows, { actuals, targetCoverage, groupBy });
+    const qhatByCoverage = new Map((summaries ?? []).map((row) => [row.coverage, row.qhatLabel]));
+    const maxWidth = Math.max(1e-9, ...rows.flatMap((row) => row.intervals.map((cell) => cell.width)));
+    const unitSuffix = unit ? ` ${unit}` : "";
+    return (_jsxs("div", { className: cx("n4conf-tree", className), children: [guarantee ? (_jsxs("header", { className: "n4conf-guarantee", "data-tone": guarantee.tone, children: [_jsx("span", { className: "n4conf-guarantee-status", "data-status": guarantee.status }), _jsx("span", { className: "n4conf-guarantee-label", children: guarantee.label }), _jsxs("span", { className: "n4conf-guarantee-meta", children: [guarantee.method, " \u00B7 ", guarantee.effectiveEngine, " \u00B7 target ", guarantee.coverageLabel] })] })) : null, _jsxs("div", { className: "n4conf-legend", role: "note", children: [_jsxs("span", { className: "n4conf-legend-item", children: [_jsx("i", { className: "n4conf-swatch", style: { background: PREDICTION_COLOR } }), " prediction"] }), model.hasActuals ? (_jsxs(_Fragment, { children: [_jsxs("span", { className: "n4conf-legend-item", children: [_jsx("i", { className: "n4conf-dot", style: { background: COVERED_COLOR } }), " covered"] }), _jsxs("span", { className: "n4conf-legend-item", children: [_jsx("i", { className: "n4conf-diamond", style: { background: MISSED_COLOR } }), " missed"] })] })) : null, _jsxs("span", { className: "n4conf-legend-item n4conf-legend-ramp", "aria-hidden": "true", children: [model.coverages.map((coverage) => (_jsx("i", { className: "n4conf-swatch", title: fmtCoverage(coverage), style: { background: shadeForCoverage(coverage, model.coverages) } }, coverage))), _jsx("span", { className: "n4conf-legend-ramp-label", children: "wide \u2192 tight" })] })] }), model.tiers.map((tier) => (_jsxs("details", { className: "n4conf-tier", "data-tone": tier.tone, open: defaultOpenTiers, children: [_jsxs("summary", { className: "n4conf-tier-summary", children: [_jsx("span", { className: "n4conf-chevron", "aria-hidden": "true" }), _jsx("span", { className: "n4conf-tier-label", children: tier.label }), _jsx("span", { className: "n4conf-tier-desc", children: tier.description }), _jsxs("span", { className: "n4conf-tier-stats", children: [_jsx("span", { className: "n4conf-badge", children: tier.count }), _jsx("span", { className: "n4conf-share", children: fmtShare(tier.share) }), _jsxs("span", { className: "n4conf-meanwidth", children: ["x\u0304 width ", fmtWidth(tier.meanWidth), unitSuffix] })] })] }), _jsxs("div", { className: "n4conf-samples", children: [tier.samples.slice(0, maxSamplesPerTier).map((sample) => (_jsxs("details", { className: "n4conf-sample", children: [_jsxs("summary", { className: "n4conf-sample-summary", children: [_jsx("span", { className: "n4conf-chevron", "aria-hidden": "true" }), _jsx("span", { className: "n4conf-sample-id", children: sample.sampleId ?? `#${sample.index}` }), _jsxs("span", { className: "n4conf-sample-pred", children: ["\u0177 ", sample.predictionLabel, unitSuffix] }), _jsx(NestedBandGlyph, { sample: sample, coverages: model.coverages, domain: model.domain, width: glyphWidth }), sample.coveredAtTarget == null ? (_jsxs("span", { className: "n4conf-chip", "data-tone": "neutral", children: ["\u00B1", fmtWidth(sample.targetWidth ?? sample.widestWidth)] })) : sample.coveredAtTarget ? (_jsxs("span", { className: "n4conf-chip", "data-tone": "success", children: ["covered ", sample.tightestCovering != null ? fmtCoverage(sample.tightestCovering) : ""] })) : (_jsx("span", { className: "n4conf-chip", "data-tone": "danger", children: "missed" }))] }), _jsx("div", { className: "n4conf-levels", children: [...sample.intervals].sort((a, b) => a.coverage - b.coverage).map((cell) => {
+                                            const covered = sample.actual == null ? null : coversActual(cell, sample.actual);
+                                            const qhat = qhatByCoverage.get(cell.coverage);
+                                            return (_jsxs("div", { className: "n4conf-level", "data-covered": covered == null ? "na" : covered ? "yes" : "no", children: [_jsx("span", { className: "n4conf-level-cov", children: cell.coverageLabel }), qhat ? _jsxs("span", { className: "n4conf-level-qhat", children: ["q\u0302 ", qhat] }) : null, _jsxs("span", { className: "n4conf-level-range", children: ["[", cell.lowerLabel, ", ", cell.upperLabel, "]"] }), _jsx("span", { className: "n4conf-level-bar", "aria-hidden": "true", children: _jsx("i", { className: "n4conf-level-bar-fill", style: { width: `${clamp((cell.width / maxWidth) * 100, 2, 100)}%`, background: shadeForCoverage(cell.coverage, model.coverages) } }) }), _jsxs("span", { className: "n4conf-level-width", children: [cell.widthLabel, unitSuffix] }), covered != null ? (_jsx("span", { className: "n4conf-level-mark", "data-covered": covered ? "yes" : "no", children: covered ? "✓" : "✗" })) : null] }, cell.coverage));
+                                        }) })] }, sample.index))), tier.samples.length > maxSamplesPerTier ? (_jsxs("p", { className: "n4conf-more", children: ["+", tier.samples.length - maxSamplesPerTier, " more predictions"] })) : null] })] }, tier.id)))] }));
+}
+function diamond(cx, cy, radius) {
+    const x = round(cx);
+    const y = round(cy);
+    const r = round(radius);
+    return `M${x} ${y - r} L${x + r} ${y} L${x} ${y + r} L${x - r} ${y} Z`;
+}
+function cx(...parts) {
+    const resolved = parts.filter((part) => typeof part === "string" && part.length > 0);
+    return resolved.length > 0 ? resolved.join(" ") : undefined;
+}
+//# sourceMappingURL=ConformalPredictionTree.js.map