@jax-data-science/sci-image-visualizer 0.3.3 → 0.5.0

package/esm2022/lib/implementations/plotly/omics-trace-builders.mjs

@@ -0,0 +1,555 @@
+import { NO_CATEGORY } from '../../contracts/spatial-dataset.contract';
+const DEFAULT_COLOR = '#0072B2';
+/** Plotly renders every point of a violin/box; past this we thin the input.
+ *  84k cells x a violin per category is otherwise seconds of layout. */
+const MAX_POINTS_PER_TRACE = 20_000;
+/** Finite values only, optionally log-scaled and restricted to a selection. */
+function prepare(input, restrict) {
+    const { values, log } = input;
+    const out = [];
+    for (let i = 0; i < values.length; i++) {
+        if (restrict && !restrict[i])
+            continue;
+        const v = values[i];
+        if (!Number.isFinite(v))
+            continue;
+        out.push(log ? Math.log1p(Math.max(0, v)) : v);
+    }
+    return out;
+}
+/** Evenly thin a sample to `max` points, preserving its distribution. */
+function thin(values, max = MAX_POINTS_PER_TRACE) {
+    if (values.length <= max)
+        return values;
+    const step = values.length / max;
+    const out = [];
+    for (let i = 0; i < max; i++)
+        out.push(values[Math.floor(i * step)]);
+    return out;
+}
+/** Values per category, finite and optionally selection-restricted. */
+function byCategory(input, group, restrict) {
+    const buckets = group.categories.map(() => []);
+    const { values, log } = input;
+    for (let i = 0; i < values.length; i++) {
+        if (restrict && !restrict[i])
+            continue;
+        const code = group.codes[i];
+        // NO_CATEGORY has no bucket by definition; an out-of-range code would
+        // otherwise silently land in the wrong one.
+        if (code === NO_CATEGORY || code >= buckets.length)
+            continue;
+        const v = values[i];
+        if (!Number.isFinite(v))
+            continue;
+        buckets[code].push(log ? Math.log1p(Math.max(0, v)) : v);
+    }
+    return buckets;
+}
+/** True when the selection actually restricts anything. */
+function activeSelection(selection) {
+    if (!selection)
+        return null;
+    for (let i = 0; i < selection.length; i++)
+        if (selection[i])
+            return selection;
+    return null;
+}
+/**
+ * Traces for one chart kind.
+ *
+ * - **histogram** — the full distribution, plus an overlaid *Selected* trace
+ *   when a selection exists, so the two are directly comparable. That
+ *   comparison is the whole point of linking the chart to the map.
+ * - **violin / box** — one per category when grouped, otherwise a single trace.
+ *   These narrow TO the selection rather than overlaying it: a violin per
+ *   category per selection state is unreadable.
+ */
+export function buildOmicsTraces(kind, input) {
+    const selection = activeSelection(input.selection);
+    const color = input.color ?? DEFAULT_COLOR;
+    if (kind === 'histogram') {
+        const traces = [{
+                type: 'histogram',
+                x: prepare(input, null),
+                name: 'All',
+                marker: { color, line: { width: 0 } },
+                opacity: selection ? 0.55 : 1,
+                hovertemplate: '%{y} obs<br>%{x}<extra>All</extra>',
+            }];
+        if (selection) {
+            traces.push({
+                type: 'histogram',
+                x: prepare(input, selection),
+                name: 'Selected',
+                marker: { color: '#D55E00', line: { width: 0 } },
+                opacity: 0.85,
+                hovertemplate: '%{y} obs<br>%{x}<extra>Selected</extra>',
+            });
+        }
+        return traces;
+    }
+    const type = kind; // 'violin' | 'box'
+    const shared = {
+        type,
+        ...(type === 'violin'
+            ? { box: { visible: true }, meanline: { visible: true }, points: false }
+            : { boxpoints: false }),
+    };
+    if (input.group) {
+        const buckets = byCategory(input, input.group, selection);
+        return buckets
+            // Drop empty categories: an empty violin renders as a stray tick with a
+            // label, which reads as data.
+            .map((values, i) => ({ values, i }))
+            .filter((b) => b.values.length > 0)
+            .map((b) => ({
+            ...shared,
+            y: thin(b.values),
+            name: input.group.categories[b.i],
+            marker: { color: input.group.colors[b.i] ?? color },
+            line: { color: input.group.colors[b.i] ?? color },
+        }));
+    }
+    const values = thin(prepare(input, selection));
+    if (values.length === 0)
+        return [];
+    return [{
+            ...shared,
+            y: values,
+            name: selection ? 'Selected' : 'All',
+            marker: { color },
+            line: { color },
+        }];
+}
+/** Layout for a chart kind — axis titles reflect the log toggle. */
+export function omicsLayout(kind, input) {
+    const label = input.log ? `log1p(${input.name})` : input.name;
+    const base = {
+        margin: { t: 10, r: 10, b: 40, l: 52 },
+        autosize: true,
+        showlegend: kind === 'histogram' && !!activeSelection(input.selection),
+        legend: { orientation: 'h', y: 1.12, x: 0 },
+        bargap: 0.02,
+        hovermode: 'closest',
+    };
+    if (kind === 'histogram') {
+        return {
+            ...base,
+            barmode: 'overlay',
+            xaxis: { title: { text: label } },
+            yaxis: { title: { text: 'observations' } },
+        };
+    }
+    return {
+        ...base,
+        xaxis: { automargin: true },
+        yaxis: { title: { text: label }, zeroline: false },
+    };
+}
+/** Whether a chart kind needs a categorical grouping to be worth showing. */
+export function benefitsFromGrouping(kind) {
+    return kind === 'violin' || kind === 'box';
+}
+/** Categories shown as bars before the tail is folded into one "other". */
+const MAX_COUNT_BARS = 25;
+/** Per-category counts, biggest first, with the tail folded into one bar. */
+export function countByCategory(input) {
+    const { codes, categories, colors } = input.group;
+    const selection = activeSelection(input.selection);
+    const totals = new Float64Array(categories.length);
+    const selected = new Float64Array(categories.length);
+    for (let i = 0; i < codes.length; i++) {
+        const c = codes[i];
+        if (c === NO_CATEGORY || c >= categories.length)
+            continue;
+        totals[c]++;
+        if (selection && selection[i])
+            selected[c]++;
+    }
+    const ranked = Array.from(totals, (n, c) => ({ c, n }))
+        .filter((r) => r.n > 0)
+        .sort((a, b) => b.n - a.n);
+    const max = input.max ?? MAX_COUNT_BARS;
+    const head = ranked.slice(0, max);
+    const tail = ranked.slice(max);
+    const out = {
+        labels: head.map((r) => categories[r.c]),
+        colors: head.map((r) => colors[r.c] ?? DEFAULT_COLOR),
+        totals: head.map((r) => r.n),
+        selected: head.map((r) => selected[r.c]),
+    };
+    // The tail is aggregated rather than dropped: 338 subclasses do not fit a
+    // readable axis, but silently showing 25 of them would misstate the whole.
+    if (tail.length) {
+        out.labels.push(`other (${tail.length} categories)`);
+        out.colors.push('#9e9e9e');
+        out.totals.push(tail.reduce((a, r) => a + r.n, 0));
+        out.selected.push(tail.reduce((a, r) => a + selected[r.c], 0));
+    }
+    return out;
+}
+/**
+ * Bars of per-category cell counts — the distribution a CATEGORICAL colour
+ * source has.
+ *
+ * A histogram of a category code would be meaningless (the codes are labels, not
+ * magnitudes), but "how many cells per class" is a real question, and the same one
+ * the legend implies without answering. Horizontal, because taxonomy labels are
+ * long, and sorted, because rank is what the chart is read for.
+ */
+export function buildCountTraces(input) {
+    const { labels, colors, totals, selected } = countByCategory(input);
+    const selection = activeSelection(input.selection);
+    // Plotly draws the first category at the BOTTOM of a horizontal axis, so
+    // reverse to put the biggest bar at the top where the eye starts.
+    const flip = (a) => a.slice().reverse();
+    const traces = [{
+            type: 'bar',
+            orientation: 'h',
+            x: flip(totals),
+            y: flip(labels),
+            name: selection ? 'All' : 'Cells',
+            marker: { color: flip(colors) },
+            opacity: selection ? 0.45 : 1,
+            hovertemplate: '%{x} obs<extra>%{y}</extra>',
+        }];
+    if (selection) {
+        traces.push({
+            type: 'bar',
+            orientation: 'h',
+            x: flip(selected),
+            y: flip(labels),
+            name: 'Selected',
+            marker: { color: flip(colors) },
+            hovertemplate: '%{x} obs<extra>%{y} · selected</extra>',
+        });
+    }
+    return traces;
+}
+export function countsLayout(input) {
+    const { labels } = countByCategory(input);
+    return {
+        // Room for the labels, and a height that grows with the bar count so 25
+        // categories are not crushed into the same box as 3.
+        margin: { t: 10, r: 10, b: 40, l: 8 },
+        autosize: true,
+        // Overlaid, not stacked: the selected bar reads against the total it came
+        // from, which is the comparison being made.
+        barmode: 'overlay',
+        showlegend: !!activeSelection(input.selection),
+        legend: { orientation: 'h', y: 1.12, x: 0 },
+        hovermode: 'closest',
+        xaxis: { title: { text: 'observations' } },
+        yaxis: { automargin: true, ticklabelposition: 'inside', tickfont: { size: 10 } },
+        height: Math.max(180, 22 * labels.length + 60),
+    };
+}
+/**
+ * Past this many categories, one trace each stops being worth it.
+ *
+ * A trace per category buys a legend whose entries toggle — click one to isolate a population,
+ * which is how these plots are actually read. But Plotly holds per-trace state, and a legend of
+ * hundreds of entries is unreadable anyway (the ABC atlas has 338 subclasses), so beyond the cap
+ * everything goes into ONE trace with a per-point colour: no legend, but it still draws.
+ */
+export const EMBEDDING_MAX_LEGEND_CATEGORIES = 40;
+/**
+ * Categories past which the legend is not DRAWN, though the traces stay split.
+ *
+ * A legend is only worth its space if it fits. seqFISH's 22 cell types stack into one tall
+ * column in a docked panel, overlapping the axis title and running off the bottom — and
+ * the colours already match the map, whose own panel lists them, while hover names the
+ * category under the cursor. So past this the plot takes the whole panel and the legend
+ * is dropped rather than shown badly.
+ */
+export const EMBEDDING_MAX_LEGEND_SHOWN = 10;
+/** Dimming applied to unselected points, matching the map's muted opacity. */
+const EMBEDDING_MUTED_OPACITY = 0.15;
+/**
+ * Mix a hex colour toward white by `amount`.
+ *
+ * How unselected points are dimmed in 3D. `scatter3d` accepts `marker.opacity` only as a
+ * SCALAR — a per-point array is silently collapsed to the first value, verified against
+ * the bundled Plotly — so the per-point opacity that dims the 2D plot does nothing there,
+ * and a selection appeared to highlight nothing in 3D. Colour arrays ARE honoured, so
+ * the same effect is produced by mixing toward the paper instead.
+ */
+function towardPaper(hex, amount) {
+    const clean = hex.replace('#', '');
+    const full = clean.length === 3
+        ? clean.split('').map((c) => c + c).join('')
+        : clean;
+    const n = Number.parseInt(full, 16);
+    if (!Number.isFinite(n) || full.length !== 6)
+        return hex;
+    const mix = (c) => Math.round(c + (255 - c) * amount);
+    const r = mix((n >> 16) & 0xff);
+    const g = mix((n >> 8) & 0xff);
+    const b = mix(n & 0xff);
+    return `#${((r << 16) | (g << 8) | b).toString(16).padStart(6, '0')}`;
+}
+const DEFAULT_EMBEDDING_POINT_SIZE = 4;
+export function buildEmbeddingTraces(input) {
+    const { x, y, categories, selection } = input;
+    const n = Math.min(x.length, y.length);
+    if (n === 0)
+        return [];
+    const z = input.z;
+    // `scattergl` for the plane — 10^4-10^6 points, which the SVG renderer would not
+    // survive. `scatter3d` for the cloud: WebGL too, but a different trace type with its
+    // own scene, which is why a third dimension cannot just be added to the former. It
+    // costs more per point, so it suits this scale and not millions.
+    const type = z ? 'scatter3d' : 'scattergl';
+    const markerSize = z ? Math.max(1, (input.size ?? DEFAULT_EMBEDDING_POINT_SIZE) - 2)
+        : (input.size ?? DEFAULT_EMBEDDING_POINT_SIZE);
+    const opacityFor = (i) => !selection || selection[i] ? 1 : EMBEDDING_MUTED_OPACITY;
+    const isSelected = (i) => !selection || selection[i] === 1;
+    // In 3D the dimming has to be in the COLOUR, since a per-point opacity array is
+    // ignored there. Cached per input colour: 19k lookups of the same few categories.
+    const dimCache = new Map();
+    const shade = (hex, i) => {
+        if (!z || isSelected(i))
+            return hex;
+        const hit = dimCache.get(hex);
+        if (hit)
+            return hit;
+        const dimmed = towardPaper(hex, 1 - EMBEDDING_MUTED_OPACITY);
+        dimCache.set(hex, dimmed);
+        return dimmed;
+    };
+    /** Per-point opacity, which only the 2D trace types honour. */
+    const opacityArray = (indices) => selection && !z ? indices.map(opacityFor) : undefined;
+    if (!categories || categories.names.length === 0) {
+        return [{
+                type,
+                mode: 'markers',
+                x: Array.from(x.subarray(0, n)),
+                y: Array.from(y.subarray(0, n)),
+                ...(z ? { z: Array.from(z.subarray(0, n)) } : {}),
+                // The OBSERVATION index per point, carried through so a lasso can be turned back
+                // into a selection. Plotly reports a selected point by its position within its
+                // trace, which is not the observation index once the points are split by category.
+                customdata: Array.from({ length: n }, (_, i) => i),
+                marker: {
+                    size: markerSize,
+                    // A flat colour normally; per point once a selection has to dim some of them in
+                    // 3D, where opacity arrays are ignored.
+                    color: selection && z
+                        ? Array.from({ length: n }, (_, i) => shade('#4c72b0', i))
+                        : '#4c72b0',
+                    ...(opacityArray(Array.from({ length: n }, (_, i) => i))
+                        ? { opacity: Array.from({ length: n }, (_, i) => opacityFor(i)) }
+                        : {}),
+                },
+                hoverinfo: 'none',
+                showlegend: false,
+            }];
+    }
+    const { codes, names, colors } = categories;
+    if (names.length > EMBEDDING_MAX_LEGEND_CATEGORIES) {
+        // One trace, per-point colour. Hover still names the category, which is the part that
+        // matters; the legend is what is lost.
+        return [{
+                type,
+                mode: 'markers',
+                x: Array.from(x.subarray(0, n)),
+                y: Array.from(y.subarray(0, n)),
+                ...(z ? { z: Array.from(z.subarray(0, n)) } : {}),
+                marker: {
+                    size: markerSize,
+                    color: Array.from({ length: n }, (_, i) => shade(colors[codes[i]] ?? '#999999', i)),
+                    ...(opacityArray(Array.from({ length: n }, (_, i) => i))
+                        ? { opacity: Array.from({ length: n }, (_, i) => opacityFor(i)) }
+                        : {}),
+                },
+                customdata: Array.from({ length: n }, (_, i) => i),
+                text: Array.from({ length: n }, (_, i) => names[codes[i]] ?? 'unassigned'),
+                hovertemplate: '%{text}<extra></extra>',
+                showlegend: false,
+            }];
+    }
+    // One trace per category: the legend entries toggle, so a population can be isolated by
+    // clicking rather than by re-colouring the whole plot.
+    const buckets = names.map(() => []);
+    for (let i = 0; i < n; i++) {
+        const c = codes[i];
+        // NO_CATEGORY, or a code past the list, is unassigned — dropped rather than drawn in a
+        // colour that would read as a population of its own.
+        if (c < buckets.length)
+            buckets[c].push(i);
+    }
+    return buckets
+        .map((idx, c) => ({ idx, c }))
+        .filter(({ idx }) => idx.length > 0)
+        .map(({ idx, c }) => ({
+        type,
+        mode: 'markers',
+        name: names[c],
+        x: idx.map((i) => x[i]),
+        y: idx.map((i) => y[i]),
+        ...(z ? { z: idx.map((i) => z[i]) } : {}),
+        // This trace's points ARE a subset, so the observation index has to travel with
+        // them; `pointIndex` alone would address the wrong cell.
+        customdata: idx,
+        marker: {
+            size: markerSize,
+            color: selection && z
+                ? idx.map((i) => shade(colors[c] ?? '#999999', i))
+                : (colors[c] ?? '#999999'),
+            ...(opacityArray(idx) ? { opacity: idx.map(opacityFor) } : {}),
+        },
+        // Split per category regardless, so hover names it and a future isolate control
+        // has something to toggle; only the legend's VISIBILITY depends on the count.
+        showlegend: names.length <= EMBEDDING_MAX_LEGEND_SHOWN,
+        hovertemplate: `${names[c]}<extra></extra>`,
+    }));
+}
+/**
+ * Axis title: the embedding's name, the axis number, and its variance share when there is
+ * one to report.
+ */
+function axisTitle(stem, axis, varianceRatio) {
+    const share = varianceRatio?.[axis - 1];
+    if (share === undefined || !Number.isFinite(share))
+        return `${stem} ${axis}`;
+    // One decimal: the difference between 23.4% and 23% is worth seeing when comparing
+    // components, and more digits than that is noise from the estimate.
+    return `${stem} ${axis} (${(share * 100).toFixed(1)}%)`;
+}
+export function embeddingLayout(input) {
+    const stem = input.label || 'Embedding';
+    const vr = input.varianceRatio;
+    // No annotation for a derived embedding. That a recomputed UMAP is not the published
+    // picture does need saying — but the panel's caption already says it, and repeating it
+    // over the plot cost a strip of the panel's height and, in the 3D scene, sat on top of
+    // the cloud. One statement, in the caption.
+    if (input.z) {
+        return {
+            autosize: true,
+            // A 3D scene has no margins to speak of; the axes live inside it.
+            margin: { l: 0, r: 0, t: 0, b: 0 },
+            scene: {
+                xaxis: { title: { text: axisTitle(stem, 1, vr) } },
+                yaxis: { title: { text: axisTitle(stem, 2, vr) } },
+                zaxis: { title: { text: axisTitle(stem, 3, vr) } },
+                // Carried across the redraw, or every recolour snaps the cloud back to its
+                // default orientation.
+                ...(input.view?.camera ? { camera: input.view.camera } : {}),
+                // Equal aspect for the same reason as the plane: the axes carry no units, so
+                // distances only compare if all three are scaled alike. `data` keeps the cloud's
+                // own proportions instead of stretching it into the cube.
+                aspectmode: 'data',
+            },
+            showlegend: false,
+            hovermode: 'closest',
+        };
+    }
+    return {
+        autosize: true,
+        // Bottom margin carries the legend: laid out BELOW the plot rather than beside it.
+        // A vertical legend of 22 cell types took half a docked panel's width and squeezed
+        // the embedding into a corner — and the shapes of the clusters are the thing being
+        // read here, while the labels are a lookup.
+        margin: {
+            l: 44,
+            r: 8,
+            t: 8,
+            // Room for the legend only when one is drawn; otherwise the axis title alone.
+            b: (input.categories?.names.length ?? 0) > 0
+                && (input.categories?.names.length ?? 0) <= EMBEDDING_MAX_LEGEND_SHOWN ? 64 : 40,
+        },
+        // Equal aspect: an embedding's axes carry no units, so distances are only comparable if the
+        // two are scaled alike. Stretching one axis to fill the panel invents structure.
+        xaxis: {
+            title: { text: axisTitle(stem, 1, vr) }, zeroline: false, ticks: 'outside',
+            ...(input.view?.ranges ? { range: input.view.ranges.x, autorange: false } : {}),
+        },
+        yaxis: {
+            title: { text: axisTitle(stem, 2, vr) }, zeroline: false, ticks: 'outside',
+            scaleanchor: 'x', scaleratio: 1,
+            ...(input.view?.ranges ? { range: input.view.ranges.y, autorange: false } : {}),
+        },
+        legend: {
+            orientation: 'h',
+            itemsizing: 'constant',
+            font: { size: 9 },
+            yanchor: 'top', y: -0.16, xanchor: 'left', x: 0,
+        },
+        hovermode: 'closest',
+    };
+}
+/** Diverging, centred: after z-scoring, the sign carries the meaning. */
+const HEATMAP_DIVERGING = [
+    [0, '#2166AC'],
+    [0.5, '#F7F7F7'],
+    [1, '#B2182B'],
+];
+/** Sequential, for raw means where zero is the bottom rather than the middle. */
+const HEATMAP_SEQUENTIAL = [
+    [0, '#F7FBFF'],
+    [0.5, '#6BAED6'],
+    [1, '#08306B'],
+];
+export function buildHeatmapTraces(input) {
+    const { rows, cols, values, counts } = input;
+    if (rows.length === 0 || cols.length === 0)
+        return [];
+    // Plotly wants z as an array of rows, bottom-up; NaN renders as a gap.
+    const z = [];
+    for (let r = rows.length - 1; r >= 0; r--) {
+        const line = [];
+        for (let c = 0; c < cols.length; c++) {
+            const v = values[r * cols.length + c];
+            line.push(Number.isFinite(v) ? v : null);
+        }
+        z.push(line);
+    }
+    const y = rows.slice().reverse();
+    const unit = input.zScored ? 'z' : 'mean';
+    // Symmetric about zero when z-scored, so the same magnitude reads the same
+    // whichever side of the gene's average it falls on.
+    let zmin;
+    let zmax;
+    if (input.zScored) {
+        let peak = 0;
+        for (let i = 0; i < values.length; i++) {
+            const v = Math.abs(values[i]);
+            if (Number.isFinite(v) && v > peak)
+                peak = v;
+        }
+        zmax = peak > 0 ? peak : 1;
+        zmin = -zmax;
+    }
+    const hover = counts
+        ? cols.map((label, c) => `${label} · ${counts[c]} cells`)
+        : cols;
+    return [{
+            type: 'heatmap',
+            z,
+            x: cols,
+            y,
+            customdata: z.map(() => hover),
+            colorscale: input.zScored ? HEATMAP_DIVERGING : HEATMAP_SEQUENTIAL,
+            ...(zmin !== undefined ? { zmin, zmax } : {}),
+            // A gap has no colour rather than the scale's bottom: nothing was measured
+            // there, which is not the same as a low mean.
+            hoverongaps: false,
+            colorbar: { title: { text: unit, side: 'right' }, thickness: 10, len: 0.9 },
+            hovertemplate: `%{y}<br>%{customdata}<br>${unit} %{z:.2f}<extra></extra>`,
+        }];
+}
+export function heatmapLayout(input) {
+    return {
+        // Left margin grows with the longest gene name; the labels are the point.
+        margin: { t: 10, r: 10, b: 90, l: 8 },
+        autosize: true,
+        hovermode: 'closest',
+        xaxis: { automargin: true, tickangle: -45, tickfont: { size: 10 },
+            title: { text: input.groupLabel ?? '' } },
+        yaxis: { automargin: true, tickfont: { size: 10 } },
+        // Grows with the gene count so 3 rows are not stretched to 20 rows' height.
+        height: Math.max(180, 24 * input.rows.length + 110),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"omics-trace-builders.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/omics-trace-builders.ts"],"names":[],"mappings":"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","sourcesContent":["import { NO_CATEGORY } from '../../contracts/spatial-dataset.contract';\n\n/**\n * Plotly traces for the 1-D distribution charts over spatial-omics values:\n * histogram, violin and box.\n *\n * Pure, like `plotly-trace-builders.ts` — and deliberately SEPARATE from it,\n * because that module's `TraceBuildInput` is image-matrix shaped (`frames`,\n * `width`, `ratios`, `trueImageSize`) and cannot express \"one value per\n * observation\". Forcing the two together would make both worse.\n *\n * Violin and box need no bundling work: `plotly.js-dist-min` is the full\n * distribution and already carries both trace types.\n */\n\nexport type OmicsChartKind =\n  | 'histogram' | 'violin' | 'box' | 'counts' | 'heatmap' | 'embedding';\n\n/** Per-observation grouping for a violin/box, or an overlaid histogram. */\nexport interface OmicsGrouping {\n  codes: Uint16Array;\n  categories: string[];\n  /** `#rrggbb` per category, index-aligned — the same colours the map uses. */\n  colors: string[];\n}\n\nexport interface OmicsTraceInput {\n  /** The values being charted (an annotation column or a gene vector). */\n  values: Float32Array;\n  /** Axis label for the value — the column or gene name. */\n  name: string;\n  group?: OmicsGrouping | null;\n  /** `1` marks a selected observation. When present, the charts narrow to it. */\n  selection?: Uint8Array | null;\n  /** Plot `log1p(value)` instead of the raw value. */\n  log?: boolean;\n  /** Colour for the ungrouped trace. */\n  color?: string;\n}\n\nconst DEFAULT_COLOR = '#0072B2';\n/** Plotly renders every point of a violin/box; past this we thin the input.\n *  84k cells x a violin per category is otherwise seconds of layout. */\nconst MAX_POINTS_PER_TRACE = 20_000;\n\n/** Finite values only, optionally log-scaled and restricted to a selection. */\nfunction prepare(input: OmicsTraceInput, restrict: Uint8Array | null): number[] {\n  const { values, log } = input;\n  const out: number[] = [];\n  for (let i = 0; i < values.length; i++) {\n    if (restrict && !restrict[i]) continue;\n    const v = values[i];\n    if (!Number.isFinite(v)) continue;\n    out.push(log ? Math.log1p(Math.max(0, v)) : v);\n  }\n  return out;\n}\n\n/** Evenly thin a sample to `max` points, preserving its distribution. */\nfunction thin(values: number[], max = MAX_POINTS_PER_TRACE): number[] {\n  if (values.length <= max) return values;\n  const step = values.length / max;\n  const out: number[] = [];\n  for (let i = 0; i < max; i++) out.push(values[Math.floor(i * step)]);\n  return out;\n}\n\n/** Values per category, finite and optionally selection-restricted. */\nfunction byCategory(\n  input: OmicsTraceInput, group: OmicsGrouping, restrict: Uint8Array | null,\n): number[][] {\n  const buckets: number[][] = group.categories.map(() => []);\n  const { values, log } = input;\n  for (let i = 0; i < values.length; i++) {\n    if (restrict && !restrict[i]) continue;\n    const code = group.codes[i];\n    // NO_CATEGORY has no bucket by definition; an out-of-range code would\n    // otherwise silently land in the wrong one.\n    if (code === NO_CATEGORY || code >= buckets.length) continue;\n    const v = values[i];\n    if (!Number.isFinite(v)) continue;\n    buckets[code].push(log ? Math.log1p(Math.max(0, v)) : v);\n  }\n  return buckets;\n}\n\n/** True when the selection actually restricts anything. */\nfunction activeSelection(selection: Uint8Array | null | undefined): Uint8Array | null {\n  if (!selection) return null;\n  for (let i = 0; i < selection.length; i++) if (selection[i]) return selection;\n  return null;\n}\n\n/**\n * Traces for one chart kind.\n *\n * - **histogram** — the full distribution, plus an overlaid *Selected* trace\n *   when a selection exists, so the two are directly comparable. That\n *   comparison is the whole point of linking the chart to the map.\n * - **violin / box** — one per category when grouped, otherwise a single trace.\n *   These narrow TO the selection rather than overlaying it: a violin per\n *   category per selection state is unreadable.\n */\nexport function buildOmicsTraces(kind: OmicsChartKind, input: OmicsTraceInput): unknown[] {\n  const selection = activeSelection(input.selection);\n  const color = input.color ?? DEFAULT_COLOR;\n\n  if (kind === 'histogram') {\n    const traces: unknown[] = [{\n      type: 'histogram',\n      x: prepare(input, null),\n      name: 'All',\n      marker: { color, line: { width: 0 } },\n      opacity: selection ? 0.55 : 1,\n      hovertemplate: '%{y} obs<br>%{x}<extra>All</extra>',\n    }];\n    if (selection) {\n      traces.push({\n        type: 'histogram',\n        x: prepare(input, selection),\n        name: 'Selected',\n        marker: { color: '#D55E00', line: { width: 0 } },\n        opacity: 0.85,\n        hovertemplate: '%{y} obs<br>%{x}<extra>Selected</extra>',\n      });\n    }\n    return traces;\n  }\n\n  const type = kind; // 'violin' | 'box'\n  const shared = {\n    type,\n    ...(type === 'violin'\n      ? { box: { visible: true }, meanline: { visible: true }, points: false as const }\n      : { boxpoints: false as const }),\n  };\n\n  if (input.group) {\n    const buckets = byCategory(input, input.group, selection);\n    return buckets\n      // Drop empty categories: an empty violin renders as a stray tick with a\n      // label, which reads as data.\n      .map((values, i) => ({ values, i }))\n      .filter((b) => b.values.length > 0)\n      .map((b) => ({\n        ...shared,\n        y: thin(b.values),\n        name: input.group!.categories[b.i],\n        marker: { color: input.group!.colors[b.i] ?? color },\n        line: { color: input.group!.colors[b.i] ?? color },\n      }));\n  }\n\n  const values = thin(prepare(input, selection));\n  if (values.length === 0) return [];\n  return [{\n    ...shared,\n    y: values,\n    name: selection ? 'Selected' : 'All',\n    marker: { color },\n    line: { color },\n  }];\n}\n\n/** Layout for a chart kind — axis titles reflect the log toggle. */\nexport function omicsLayout(kind: OmicsChartKind, input: OmicsTraceInput): unknown {\n  const label = input.log ? `log1p(${input.name})` : input.name;\n  const base = {\n    margin: { t: 10, r: 10, b: 40, l: 52 },\n    autosize: true,\n    showlegend: kind === 'histogram' && !!activeSelection(input.selection),\n    legend: { orientation: 'h', y: 1.12, x: 0 },\n    bargap: 0.02,\n    hovermode: 'closest',\n  };\n  if (kind === 'histogram') {\n    return {\n      ...base,\n      barmode: 'overlay',\n      xaxis: { title: { text: label } },\n      yaxis: { title: { text: 'observations' } },\n    };\n  }\n  return {\n    ...base,\n    xaxis: { automargin: true },\n    yaxis: { title: { text: label }, zeroline: false },\n  };\n}\n\n/** Whether a chart kind needs a categorical grouping to be worth showing. */\nexport function benefitsFromGrouping(kind: OmicsChartKind): boolean {\n  return kind === 'violin' || kind === 'box';\n}\n\n/** Categories shown as bars before the tail is folded into one \"other\". */\nconst MAX_COUNT_BARS = 25;\n\nexport interface OmicsCountInput {\n  /** The categorical being counted, with the map's own colours. */\n  group: OmicsGrouping;\n  /** `1` marks a selected observation; when present the bars show the selection\n   *  against the total. */\n  selection?: Uint8Array | null;\n  /** Bars before the tail is aggregated. */\n  max?: number;\n}\n\n/** Per-category counts, biggest first, with the tail folded into one bar. */\nexport function countByCategory(\n  input: OmicsCountInput,\n): { labels: string[]; colors: string[]; totals: number[]; selected: number[] } {\n  const { codes, categories, colors } = input.group;\n  const selection = activeSelection(input.selection);\n  const totals = new Float64Array(categories.length);\n  const selected = new Float64Array(categories.length);\n  for (let i = 0; i < codes.length; i++) {\n    const c = codes[i];\n    if (c === NO_CATEGORY || c >= categories.length) continue;\n    totals[c]++;\n    if (selection && selection[i]) selected[c]++;\n  }\n\n  const ranked = Array.from(totals, (n, c) => ({ c, n }))\n    .filter((r) => r.n > 0)\n    .sort((a, b) => b.n - a.n);\n  const max = input.max ?? MAX_COUNT_BARS;\n  const head = ranked.slice(0, max);\n  const tail = ranked.slice(max);\n\n  const out = {\n    labels: head.map((r) => categories[r.c]),\n    colors: head.map((r) => colors[r.c] ?? DEFAULT_COLOR),\n    totals: head.map((r) => r.n),\n    selected: head.map((r) => selected[r.c]),\n  };\n  // The tail is aggregated rather than dropped: 338 subclasses do not fit a\n  // readable axis, but silently showing 25 of them would misstate the whole.\n  if (tail.length) {\n    out.labels.push(`other (${tail.length} categories)`);\n    out.colors.push('#9e9e9e');\n    out.totals.push(tail.reduce((a, r) => a + r.n, 0));\n    out.selected.push(tail.reduce((a, r) => a + selected[r.c], 0));\n  }\n  return out;\n}\n\n/**\n * Bars of per-category cell counts — the distribution a CATEGORICAL colour\n * source has.\n *\n * A histogram of a category code would be meaningless (the codes are labels, not\n * magnitudes), but \"how many cells per class\" is a real question, and the same one\n * the legend implies without answering. Horizontal, because taxonomy labels are\n * long, and sorted, because rank is what the chart is read for.\n */\nexport function buildCountTraces(input: OmicsCountInput): unknown[] {\n  const { labels, colors, totals, selected } = countByCategory(input);\n  const selection = activeSelection(input.selection);\n  // Plotly draws the first category at the BOTTOM of a horizontal axis, so\n  // reverse to put the biggest bar at the top where the eye starts.\n  const flip = <T>(a: T[]): T[] => a.slice().reverse();\n  const traces: unknown[] = [{\n    type: 'bar',\n    orientation: 'h',\n    x: flip(totals),\n    y: flip(labels),\n    name: selection ? 'All' : 'Cells',\n    marker: { color: flip(colors) },\n    opacity: selection ? 0.45 : 1,\n    hovertemplate: '%{x} obs<extra>%{y}</extra>',\n  }];\n  if (selection) {\n    traces.push({\n      type: 'bar',\n      orientation: 'h',\n      x: flip(selected),\n      y: flip(labels),\n      name: 'Selected',\n      marker: { color: flip(colors) },\n      hovertemplate: '%{x} obs<extra>%{y} · selected</extra>',\n    });\n  }\n  return traces;\n}\n\nexport function countsLayout(input: OmicsCountInput & { name: string }): unknown {\n  const { labels } = countByCategory(input);\n  return {\n    // Room for the labels, and a height that grows with the bar count so 25\n    // categories are not crushed into the same box as 3.\n    margin: { t: 10, r: 10, b: 40, l: 8 },\n    autosize: true,\n    // Overlaid, not stacked: the selected bar reads against the total it came\n    // from, which is the comparison being made.\n    barmode: 'overlay',\n    showlegend: !!activeSelection(input.selection),\n    legend: { orientation: 'h', y: 1.12, x: 0 },\n    hovermode: 'closest',\n    xaxis: { title: { text: 'observations' } },\n    yaxis: { automargin: true, ticklabelposition: 'inside', tickfont: { size: 10 } },\n    height: Math.max(180, 22 * labels.length + 60),\n  };\n}\n\n// ── heatmap ─────────────────────────────────────────────────────────────────\n\n/**\n * Genes × groups mean expression, as a Plotly heatmap.\n *\n * The matrix itself is computed by the pure `heatmapMatrix` in\n * `spatial/spatial-heatmap.ts`; this only shapes it for Plotly. Kept in the\n * matrix's own row-major order and flipped once here, because Plotly draws\n * `z[0]` at the BOTTOM of the y axis while the caller lists genes top-down.\n *\n * The colour scale is its own, NOT the map's `continuousColormap`. This is a\n * different quantity — a z-scored mean per group, not a per-cell value — so\n * sharing one scale would invite reading a heatmap cell as if it were a marker\n * colour. Diverging and centred on zero, because after z-scoring the sign is\n * the reading: above or below this gene's average across the groups.\n */\n/**\n * An embedding scatter — a UMAP, t-SNE or PCA plane over the same observations.\n *\n * Answers a different question from the map: the map says WHERE a population sits in the tissue,\n * the embedding says which populations there are and how close they are in expression. Read side\n * by side, and selecting in one highlighting the other, is the whole point of having both.\n */\nexport interface OmicsEmbeddingInput {\n  /** Embedding coordinates, index-aligned with the observations. */\n  x: Float32Array;\n  y: Float32Array;\n  /**\n   * Third dimension, when the embedding has one.\n   *\n   * Its presence is what switches the plot to a rotatable 3D scatter. A 3D embedding is\n   * always COMPUTED — every embedding published with a spatial dataset is 2D, because a\n   * UMAP exists to be looked at — so `derived` is expected alongside it.\n   */\n  z?: Float32Array;\n  /** Axis label stem, e.g. \"UMAP\" — the axes become \"UMAP 1\" / \"UMAP 2\". */\n  label: string;\n  /** Colour by a categorical column: per-observation codes plus the category names/colours. */\n  categories?: {\n    codes: Uint16Array;\n    names: readonly string[];\n    colors: readonly string[];\n  };\n  /** Marker diameter in px. */\n  size?: number;\n  /**\n   * Selection mask over the observations. When present, unselected points are dimmed rather than\n   * dropped: the shape of the whole embedding is the context that makes a selection legible, and\n   * removing it would leave a handful of dots floating in an empty plane.\n   */\n  selection?: Uint8Array;\n  /** True when the coordinates were computed here rather than published with the dataset. */\n  derived?: boolean;\n  /**\n   * Fraction of variance per axis, for a LINEAR embedding.\n   *\n   * Present for a PCA and absent for a UMAP, and that difference is the point of showing\n   * a PCA at all: its axes are ordered and each explains a measurable share of the\n   * variance, so \"PC1 (23%)\" says something a reader can act on. A UMAP's coordinates are\n   * an arbitrary output of an optimisation — unordered, unitless, and reproducible only\n   * up to a rotation — so there is nothing to label them with.\n   */\n  varianceRatio?: number[];\n  /**\n   * The view to keep across a redraw.\n   *\n   * `Plotly.react` resets the 3D scene camera and any zoomed 2D axis range unless the\n   * layout carries them, so recolouring or selecting would throw away an orientation the\n   * user had set up. Rotating a cloud to see a structure and losing it on the next click\n   * makes the plot unusable for the thing it is for.\n   *\n   * `camera` is a 3D scene camera; `ranges` are 2D axis ranges, and are only passed when\n   * the user has actually zoomed — freezing an autoranged axis would stop the plot\n   * re-fitting when the data changes.\n   */\n  view?: { camera?: unknown; ranges?: { x: unknown; y: unknown } };\n}\n\n/**\n * Past this many categories, one trace each stops being worth it.\n *\n * A trace per category buys a legend whose entries toggle — click one to isolate a population,\n * which is how these plots are actually read. But Plotly holds per-trace state, and a legend of\n * hundreds of entries is unreadable anyway (the ABC atlas has 338 subclasses), so beyond the cap\n * everything goes into ONE trace with a per-point colour: no legend, but it still draws.\n */\nexport const EMBEDDING_MAX_LEGEND_CATEGORIES = 40;\n\n/**\n * Categories past which the legend is not DRAWN, though the traces stay split.\n *\n * A legend is only worth its space if it fits. seqFISH's 22 cell types stack into one tall\n * column in a docked panel, overlapping the axis title and running off the bottom — and\n * the colours already match the map, whose own panel lists them, while hover names the\n * category under the cursor. So past this the plot takes the whole panel and the legend\n * is dropped rather than shown badly.\n */\nexport const EMBEDDING_MAX_LEGEND_SHOWN = 10;\n\n/** Dimming applied to unselected points, matching the map's muted opacity. */\nconst EMBEDDING_MUTED_OPACITY = 0.15;\n\n/**\n * Mix a hex colour toward white by `amount`.\n *\n * How unselected points are dimmed in 3D. `scatter3d` accepts `marker.opacity` only as a\n * SCALAR — a per-point array is silently collapsed to the first value, verified against\n * the bundled Plotly — so the per-point opacity that dims the 2D plot does nothing there,\n * and a selection appeared to highlight nothing in 3D. Colour arrays ARE honoured, so\n * the same effect is produced by mixing toward the paper instead.\n */\nfunction towardPaper(hex: string, amount: number): string {\n  const clean = hex.replace('#', '');\n  const full = clean.length === 3\n    ? clean.split('').map((c) => c + c).join('')\n    : clean;\n  const n = Number.parseInt(full, 16);\n  if (!Number.isFinite(n) || full.length !== 6) return hex;\n  const mix = (c: number): number => Math.round(c + (255 - c) * amount);\n  const r = mix((n >> 16) & 0xff);\n  const g = mix((n >> 8) & 0xff);\n  const b = mix(n & 0xff);\n  return `#${((r << 16) | (g << 8) | b).toString(16).padStart(6, '0')}`;\n}\n\nconst DEFAULT_EMBEDDING_POINT_SIZE = 4;\n\nexport function buildEmbeddingTraces(input: OmicsEmbeddingInput): unknown[] {\n  const { x, y, categories, selection } = input;\n  const n = Math.min(x.length, y.length);\n  if (n === 0) return [];\n  const z = input.z;\n  // `scattergl` for the plane — 10^4-10^6 points, which the SVG renderer would not\n  // survive. `scatter3d` for the cloud: WebGL too, but a different trace type with its\n  // own scene, which is why a third dimension cannot just be added to the former. It\n  // costs more per point, so it suits this scale and not millions.\n  const type = z ? 'scatter3d' : 'scattergl';\n  const markerSize = z ? Math.max(1, (input.size ?? DEFAULT_EMBEDDING_POINT_SIZE) - 2)\n    : (input.size ?? DEFAULT_EMBEDDING_POINT_SIZE);\n  const opacityFor = (i: number): number =>\n    !selection || selection[i] ? 1 : EMBEDDING_MUTED_OPACITY;\n  const isSelected = (i: number): boolean => !selection || selection[i] === 1;\n  // In 3D the dimming has to be in the COLOUR, since a per-point opacity array is\n  // ignored there. Cached per input colour: 19k lookups of the same few categories.\n  const dimCache = new Map<string, string>();\n  const shade = (hex: string, i: number): string => {\n    if (!z || isSelected(i)) return hex;\n    const hit = dimCache.get(hex);\n    if (hit) return hit;\n    const dimmed = towardPaper(hex, 1 - EMBEDDING_MUTED_OPACITY);\n    dimCache.set(hex, dimmed);\n    return dimmed;\n  };\n  /** Per-point opacity, which only the 2D trace types honour. */\n  const opacityArray = (indices: readonly number[]): number[] | undefined =>\n    selection && !z ? indices.map(opacityFor) : undefined;\n\n  if (!categories || categories.names.length === 0) {\n    return [{\n      type,\n      mode: 'markers',\n      x: Array.from(x.subarray(0, n)),\n      y: Array.from(y.subarray(0, n)),\n      ...(z ? { z: Array.from(z.subarray(0, n)) } : {}),\n      // The OBSERVATION index per point, carried through so a lasso can be turned back\n      // into a selection. Plotly reports a selected point by its position within its\n      // trace, which is not the observation index once the points are split by category.\n      customdata: Array.from({ length: n }, (_, i) => i),\n      marker: {\n        size: markerSize,\n        // A flat colour normally; per point once a selection has to dim some of them in\n        // 3D, where opacity arrays are ignored.\n        color: selection && z\n          ? Array.from({ length: n }, (_, i) => shade('#4c72b0', i))\n          : '#4c72b0',\n        ...(opacityArray(Array.from({ length: n }, (_, i) => i))\n          ? { opacity: Array.from({ length: n }, (_, i) => opacityFor(i)) }\n          : {}),\n      },\n      hoverinfo: 'none',\n      showlegend: false,\n    }];\n  }\n\n  const { codes, names, colors } = categories;\n  if (names.length > EMBEDDING_MAX_LEGEND_CATEGORIES) {\n    // One trace, per-point colour. Hover still names the category, which is the part that\n    // matters; the legend is what is lost.\n    return [{\n      type,\n      mode: 'markers',\n      x: Array.from(x.subarray(0, n)),\n      y: Array.from(y.subarray(0, n)),\n      ...(z ? { z: Array.from(z.subarray(0, n)) } : {}),\n      marker: {\n        size: markerSize,\n        color: Array.from({ length: n }, (_, i) => shade(colors[codes[i]] ?? '#999999', i)),\n        ...(opacityArray(Array.from({ length: n }, (_, i) => i))\n          ? { opacity: Array.from({ length: n }, (_, i) => opacityFor(i)) }\n          : {}),\n      },\n      customdata: Array.from({ length: n }, (_, i) => i),\n      text: Array.from({ length: n }, (_, i) => names[codes[i]] ?? 'unassigned'),\n      hovertemplate: '%{text}<extra></extra>',\n      showlegend: false,\n    }];\n  }\n\n  // One trace per category: the legend entries toggle, so a population can be isolated by\n  // clicking rather than by re-colouring the whole plot.\n  const buckets: number[][] = names.map(() => []);\n  for (let i = 0; i < n; i++) {\n    const c = codes[i];\n    // NO_CATEGORY, or a code past the list, is unassigned — dropped rather than drawn in a\n    // colour that would read as a population of its own.\n    if (c < buckets.length) buckets[c].push(i);\n  }\n  return buckets\n    .map((idx, c) => ({ idx, c }))\n    .filter(({ idx }) => idx.length > 0)\n    .map(({ idx, c }) => ({\n      type,\n      mode: 'markers',\n      name: names[c],\n      x: idx.map((i) => x[i]),\n      y: idx.map((i) => y[i]),\n      ...(z ? { z: idx.map((i) => z[i]) } : {}),\n      // This trace's points ARE a subset, so the observation index has to travel with\n      // them; `pointIndex` alone would address the wrong cell.\n      customdata: idx,\n      marker: {\n        size: markerSize,\n        color: selection && z\n          ? idx.map((i) => shade(colors[c] ?? '#999999', i))\n          : (colors[c] ?? '#999999'),\n        ...(opacityArray(idx) ? { opacity: idx.map(opacityFor) } : {}),\n      },\n      // Split per category regardless, so hover names it and a future isolate control\n      // has something to toggle; only the legend's VISIBILITY depends on the count.\n      showlegend: names.length <= EMBEDDING_MAX_LEGEND_SHOWN,\n      hovertemplate: `${names[c]}<extra></extra>`,\n    }));\n}\n\n/**\n * Axis title: the embedding's name, the axis number, and its variance share when there is\n * one to report.\n */\nfunction axisTitle(stem: string, axis: number, varianceRatio?: number[]): string {\n  const share = varianceRatio?.[axis - 1];\n  if (share === undefined || !Number.isFinite(share)) return `${stem} ${axis}`;\n  // One decimal: the difference between 23.4% and 23% is worth seeing when comparing\n  // components, and more digits than that is noise from the estimate.\n  return `${stem} ${axis} (${(share * 100).toFixed(1)}%)`;\n}\n\nexport function embeddingLayout(input: OmicsEmbeddingInput): unknown {\n  const stem = input.label || 'Embedding';\n  const vr = input.varianceRatio;\n  // No annotation for a derived embedding. That a recomputed UMAP is not the published\n  // picture does need saying — but the panel's caption already says it, and repeating it\n  // over the plot cost a strip of the panel's height and, in the 3D scene, sat on top of\n  // the cloud. One statement, in the caption.\n\n  if (input.z) {\n    return {\n      autosize: true,\n      // A 3D scene has no margins to speak of; the axes live inside it.\n      margin: { l: 0, r: 0, t: 0, b: 0 },\n      scene: {\n        xaxis: { title: { text: axisTitle(stem, 1, vr) } },\n        yaxis: { title: { text: axisTitle(stem, 2, vr) } },\n        zaxis: { title: { text: axisTitle(stem, 3, vr) } },\n        // Carried across the redraw, or every recolour snaps the cloud back to its\n        // default orientation.\n        ...(input.view?.camera ? { camera: input.view.camera } : {}),\n        // Equal aspect for the same reason as the plane: the axes carry no units, so\n        // distances only compare if all three are scaled alike. `data` keeps the cloud's\n        // own proportions instead of stretching it into the cube.\n        aspectmode: 'data',\n      },\n      showlegend: false,\n      hovermode: 'closest',\n    };\n  }\n\n  return {\n    autosize: true,\n    // Bottom margin carries the legend: laid out BELOW the plot rather than beside it.\n    // A vertical legend of 22 cell types took half a docked panel's width and squeezed\n    // the embedding into a corner — and the shapes of the clusters are the thing being\n    // read here, while the labels are a lookup.\n    margin: {\n      l: 44,\n      r: 8,\n      t: 8,\n      // Room for the legend only when one is drawn; otherwise the axis title alone.\n      b: (input.categories?.names.length ?? 0) > 0\n        && (input.categories?.names.length ?? 0) <= EMBEDDING_MAX_LEGEND_SHOWN ? 64 : 40,\n    },\n    // Equal aspect: an embedding's axes carry no units, so distances are only comparable if the\n    // two are scaled alike. Stretching one axis to fill the panel invents structure.\n    xaxis: {\n      title: { text: axisTitle(stem, 1, vr) }, zeroline: false, ticks: 'outside',\n      ...(input.view?.ranges ? { range: input.view.ranges.x, autorange: false } : {}),\n    },\n    yaxis: {\n      title: { text: axisTitle(stem, 2, vr) }, zeroline: false, ticks: 'outside',\n      scaleanchor: 'x', scaleratio: 1,\n      ...(input.view?.ranges ? { range: input.view.ranges.y, autorange: false } : {}),\n    },\n    legend: {\n      orientation: 'h',\n      itemsizing: 'constant',\n      font: { size: 9 },\n      yanchor: 'top', y: -0.16, xanchor: 'left', x: 0,\n    },\n    hovermode: 'closest',\n  };\n}\n\nexport interface OmicsHeatmapInput {\n  rows: string[];\n  cols: string[];\n  /** `rows.length × cols.length`, row-major; `NaN` where nothing was measured. */\n  values: Float32Array;\n  /** Cells behind each column, for the hover. */\n  counts?: Uint32Array;\n  /** True when `values` are z-scores, which sets the scale and the labels. */\n  zScored?: boolean;\n  /** Column axis title — the grouping column's name, or \"cell\". */\n  groupLabel?: string;\n}\n\n/** Diverging, centred: after z-scoring, the sign carries the meaning. */\nconst HEATMAP_DIVERGING: [number, string][] = [\n  [0, '#2166AC'],\n  [0.5, '#F7F7F7'],\n  [1, '#B2182B'],\n];\n/** Sequential, for raw means where zero is the bottom rather than the middle. */\nconst HEATMAP_SEQUENTIAL: [number, string][] = [\n  [0, '#F7FBFF'],\n  [0.5, '#6BAED6'],\n  [1, '#08306B'],\n];\n\nexport function buildHeatmapTraces(input: OmicsHeatmapInput): unknown[] {\n  const { rows, cols, values, counts } = input;\n  if (rows.length === 0 || cols.length === 0) return [];\n  // Plotly wants z as an array of rows, bottom-up; NaN renders as a gap.\n  const z: (number | null)[][] = [];\n  for (let r = rows.length - 1; r >= 0; r--) {\n    const line: (number | null)[] = [];\n    for (let c = 0; c < cols.length; c++) {\n      const v = values[r * cols.length + c];\n      line.push(Number.isFinite(v) ? v : null);\n    }\n    z.push(line);\n  }\n  const y = rows.slice().reverse();\n  const unit = input.zScored ? 'z' : 'mean';\n  // Symmetric about zero when z-scored, so the same magnitude reads the same\n  // whichever side of the gene's average it falls on.\n  let zmin: number | undefined;\n  let zmax: number | undefined;\n  if (input.zScored) {\n    let peak = 0;\n    for (let i = 0; i < values.length; i++) {\n      const v = Math.abs(values[i]);\n      if (Number.isFinite(v) && v > peak) peak = v;\n    }\n    zmax = peak > 0 ? peak : 1;\n    zmin = -zmax;\n  }\n  const hover = counts\n    ? cols.map((label, c) => `${label} · ${counts[c]} cells`)\n    : cols;\n  return [{\n    type: 'heatmap',\n    z,\n    x: cols,\n    y,\n    customdata: z.map(() => hover),\n    colorscale: input.zScored ? HEATMAP_DIVERGING : HEATMAP_SEQUENTIAL,\n    ...(zmin !== undefined ? { zmin, zmax } : {}),\n    // A gap has no colour rather than the scale's bottom: nothing was measured\n    // there, which is not the same as a low mean.\n    hoverongaps: false,\n    colorbar: { title: { text: unit, side: 'right' }, thickness: 10, len: 0.9 },\n    hovertemplate: `%{y}<br>%{customdata}<br>${unit} %{z:.2f}<extra></extra>`,\n  }];\n}\n\nexport function heatmapLayout(input: OmicsHeatmapInput): unknown {\n  return {\n    // Left margin grows with the longest gene name; the labels are the point.\n    margin: { t: 10, r: 10, b: 90, l: 8 },\n    autosize: true,\n    hovermode: 'closest',\n    xaxis: { automargin: true, tickangle: -45, tickfont: { size: 10 },\n      title: { text: input.groupLabel ?? '' } },\n    yaxis: { automargin: true, tickfont: { size: 10 } },\n    // Grows with the gene count so 3 rows are not stretched to 20 rows' height.\n    height: Math.max(180, 24 * input.rows.length + 110),\n  };\n}\n"]}