@jax-data-science/sci-image-visualizer 0.3.2 → 0.4.0

package/esm2022/lib/spatial-controls/spatial-charts/spatial-charts.component.mjs

@@ -0,0 +1,1278 @@
+import { Component, Inject, Input, } from '@angular/core';
+import { Subscription, combineLatest } from 'rxjs';
+import * as Plotly from 'plotly.js-dist-min';
+import { VISUALIZER } from '../../contracts/visualizer.contract';
+import { DEFAULT_SPATIAL_VIEW } from '../../contracts/display-types';
+import { emptySelection, maskToIndices, } from '../../spatial/spatial-selection';
+import { cellsAsGroups, heatmapMatrix } from '../../spatial/spatial-heatmap';
+import { geneOptionsFor } from '../../spatial/gene-search';
+import { EmbeddingComputeRun } from '../../spatial/embedding-compute';
+import { benefitsFromGrouping, buildCountTraces, buildHeatmapTraces, buildOmicsTraces, buildEmbeddingTraces, countsLayout, heatmapLayout, omicsLayout, embeddingLayout, } from '../../implementations/plotly/omics-trace-builders';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "primeng/button";
+import * as i4 from "primeng/tooltip";
+import * as i5 from "primeng/dropdown";
+import * as i6 from "primeng/dialog";
+import * as i7 from "primeng/progressbar";
+import * as i8 from "primeng/checkbox";
+import * as i9 from "primeng/multiselect";
+import * as i10 from "primeng/selectbutton";
+/**
+ * Widen the help tooltip, once per document.
+ *
+ * PrimeNG caps `.p-tooltip` at 12.5rem and appends it to `<body>`, so a component
+ * stylesheet cannot reach it — the same reason the detached dialog is sized inline. At
+ * 200 px the chart explanations render as a tall thread of two-word lines, which is worse
+ * than not showing them. The library ships no global stylesheet to put this in, so one
+ * rule is injected instead: scoped to this component's own tooltip class, idempotent, and
+ * skipped where there is no document.
+ */
+const HELP_TIP_STYLE_ID = 'sx-help-tip-style';
+function ensureHelpTipStyle() {
+    if (typeof document === 'undefined')
+        return;
+    if (document.getElementById(HELP_TIP_STYLE_ID))
+        return;
+    const style = document.createElement('style');
+    style.id = HELP_TIP_STYLE_ID;
+    style.textContent = '.sx-help-tip .p-tooltip-text { max-width: none; width: 24rem; '
+        + 'line-height: 1.45; }\n.sx-help-tip { max-width: none; }';
+    document.head.appendChild(style);
+}
+/** Per-instance chart-div id source — see {@link SpatialChartsComponent.chartDiv}. */
+let chartInstanceSeq = 0;
+/** Plotly config: a static-ish analysis chart, not an editable figure. */
+const CHART_CONFIG = {
+    displaylogo: false,
+    responsive: true,
+    modeBarButtonsToRemove: ['lasso2d', 'select2d', 'autoScale2d'],
+};
+/**
+ * Config for the embedding, which unlike the distributions is a plot you SELECT in.
+ *
+ * The lasso and box-select are kept — drawing round a cluster is how a population gets
+ * picked out of a UMAP — and the wheel zooms, because exploring an embedding means
+ * zooming into a cluster and reaching for a toolbar button to do it breaks that.
+ */
+const EMBEDDING_CONFIG = {
+    displaylogo: false,
+    responsive: true,
+    scrollZoom: true,
+    modeBarButtonsToRemove: ['autoScale2d'],
+};
+/**
+ * Distribution charts over the spatial-omics values — histogram, violin, box —
+ * **linked to the map**: they chart whatever the map is coloured by, and narrow
+ * to the current selection.
+ *
+ * Embedded INSIDE `<spatial-controls>` rather than owning a dialog of its own:
+ * the two are one workflow (change the colour source, watch the distribution
+ * move), and splitting them across two floating windows made the link harder to
+ * see, not easier. It stays a separate component so the pure trace builders and
+ * its own tests keep their boundary.
+ *
+ * Charting the active colour source rather than offering its own value picker is
+ * deliberate: it keeps one source of truth, so what you see on the map and what
+ * you see in the chart cannot disagree, and it makes the link legible without
+ * explaining it.
+ *
+ * Depends only on {@link ISpatialControls} through the `VISUALIZER` contract
+ * token, like `SpatialControlsComponent`. Trace building lives in the pure
+ * `omics-trace-builders`; this component only moves data and owns the div.
+ */
+export class SpatialChartsComponent {
+    /**
+     * Whether the host panel is on screen. The chart only draws when it is: the
+     * enclosing dialog creates and destroys its content, so without this the
+     * component would mount with a div present but no state change to trigger a
+     * first draw.
+     */
+    set active(on) {
+        const was = this.isActive;
+        this.isActive = on;
+        // Deferred by a task: when a collapsed section expands, the host is still
+        // `hidden` at the moment this setter runs, so plotting now would size the
+        // chart to a zero-height div.
+        if (on && !was)
+            setTimeout(() => void this.reload(), 0);
+        else if (on)
+            void this.reload();
+    }
+    get active() {
+        return this.isActive;
+    }
+    static { this.CONTINUOUS_KINDS = [
+        { label: 'Histogram', value: 'histogram' },
+        { label: 'Violin', value: 'violin' },
+        { label: 'Box', value: 'box' },
+    ]; }
+    static { this.CATEGORICAL_KINDS = [
+        { label: 'Counts', value: 'counts' },
+    ]; }
+    /** Available whatever the map is coloured by: the heatmap's subject is a GENE
+     *  LIST crossed with a grouping, not the active colour source. */
+    static { this.ALWAYS_KINDS = [
+        { label: 'Heatmap', value: 'heatmap' },
+    ]; }
+    /**
+     * A t-SNE the dataset does not publish, offered so it can be computed here.
+     *
+     * A dropped-in `.h5ad` typically carries one UMAP and a PCA, and no t-SNE — the two
+     * views answer different questions, so having only one is a real gap. Computing it
+     * needs no expression data: t-SNE runs on the PCA scores, which is why this can happen
+     * in the browser at all while PCA cannot.
+     */
+    static { this.COMPUTABLE = [
+        { name: 'local:tsne', label: 't-SNE (compute)', dims: 2, derived: true },
+        { name: 'local:tsne3d', label: 't-SNE 3D (compute)', dims: 3, derived: true },
+    ]; }
+    /** The menu suffix that says a click will start work; not part of the name. */
+    static { this.COMPUTE_SUFFIX = ' (compute)'; }
+    /**
+     * Largest dataset this will offer to embed in the browser.
+     *
+     * t-SNE is O(N²) per iteration — vectorised on the GPU, but not approximated — so the
+     * cost is quadratic in observations. Measured end to end in Firefox on WebGPU: 2,688
+     * points took 95 s. That scales to roughly five and a half minutes at this threshold,
+     * and to about 76 minutes at seqFISH's 19,416, which was also measured offline.
+     *
+     * Past this the option is WITHDRAWN rather than offered with a warning. An hour-long
+     * job started from a button is not a choice a reader can meaningfully consent to in a
+     * dialog, and a t-SNE that large belongs in the offline pipeline, where it can run
+     * once and be served to everyone.
+     */
+    static { this.BROWSER_TSNE_MAX_OBSERVATIONS = 5000; }
+    /** Measured anchor for the estimate: seconds for 2,688 points on WebGPU. */
+    static { this.TSNE_SECONDS_AT = { seconds: 95, observations: 2688 }; }
+    /** Offered only when the dataset publishes an embedding to draw. */
+    // Labelled for what it is rather than for one instance of it: this view draws whatever
+    // embedding the dataset publishes — a UMAP, a PCA, a t-SNE — and calling the tab "UMAP"
+    // while it showed a PCA would be a lie the picker beneath it immediately contradicts.
+    static { this.EMBEDDING_KINDS = [
+        { label: 'Embedding', value: 'embedding' },
+    ]; }
+    /** The kinds the ACTIVE subject can be drawn as. A category code is a label,
+     *  not a magnitude, so a histogram of it would be meaningless — what a
+     *  categorical column has is a frequency distribution. */
+    get kindOptions() {
+        return [
+            ...(this.categorical
+                ? SpatialChartsComponent.CATEGORICAL_KINDS
+                : SpatialChartsComponent.CONTINUOUS_KINDS),
+            ...SpatialChartsComponent.ALWAYS_KINDS,
+            // An embedding is a property of the DATASET, not of the active colour source, so
+            // it is offered whenever one is published and never otherwise — a tab that draws
+            // nothing is worse than an absent one.
+            ...(this.embeddings.length > 0 ? SpatialChartsComponent.EMBEDDING_KINDS : []),
+        ];
+    }
+    /** Past this many selected cells the per-cell view is a texture, not a
+     *  readable panel, so the columns go back to being classes. */
+    static { this.HEATMAP_CELL_COLUMNS = 200; }
+    /**
+     * Column cap for the grouped heatmap.
+     *
+     * Any categorical column can be the x axis, and they are not the same size:
+     * `neurotransmitter` has 9 categories, `class` 34, `subclass` 338. At 338 the
+     * panel is a texture — columns a couple of pixels wide, no readable label —
+     * so past this many the strongest columns are kept and the note says how many
+     * were dropped. See `maxCols` in `spatial-heatmap.ts`.
+     */
+    static { this.HEATMAP_MAX_COLUMNS = 40; }
+    constructor(viz) {
+        this.viz = viz;
+        this.isActive = true;
+        /** Per-instance, for the same reason the visualizer's plot div is
+         *  (`visualizer.component.ts`): two mounted charts sharing one DOM id means
+         *  `getElementById` hands both of them the first element, so one instance draws
+         *  into — or purges — the other's canvas. */
+        /** One increment per INSTANCE — a static initializer would run once per class and
+         *  hand every instance the same id, which is the bug this id exists to avoid. Declared
+         *  before the ids because field initializers run in order. */
+        this.seq = ++chartInstanceSeq;
+        this.chartDiv = `spatial-charts-plot-${this.seq}`;
+        /**
+         * The div inside the detached window.
+         *
+         * A separate id rather than moving the existing div: Angular destroys and recreates a
+         * div across an `*ngIf`, so Plotly would be left holding a detached node. Two divs and
+         * a redraw is both simpler and correct.
+         *
+         * ONE is enough for every kind, because only the active kind is ever plotted. Detaching
+         * is remembered per kind, but at most one window is open at a time.
+         */
+        this.detachedDiv = `spatial-charts-detached-${this.seq}`;
+        /**
+         * Whether the chart is shown in its own window rather than inline.
+         *
+         * Detached, it sits ALONGSIDE the spatial-omics dialog instead of inside it — which is
+         * the point: these are read against the map, not instead of it. The dialog is only so
+         * wide.
+         *
+         * One flag for the PANEL, not one per kind. Where the window is, is a property of the
+         * workspace someone has arranged, not of the tab they happen to be on: having put the
+         * charts beside the map, switching from the heatmap to the counts should swap what the
+         * window shows, not yank it back into the dialog and make them detach it again.
+         */
+        this.detached = false;
+        /** Coordinates computed in this browser, by name. Not persisted: a reload recomputes. */
+        this.computed = new Map();
+        /** The live run, when one is going. */
+        this.computeRun = null;
+        /**
+         * Bumped by every dataset change and by teardown, so a computation in progress can tell
+         * that what it is computing is no longer what is on screen.
+         *
+         * A run is several awaits long — the PCA scores arrive over HTTP, then the worker takes
+         * a minute or more — and the dataset can change at any of them, including BEFORE
+         * `computeRun` exists to be terminated. Without a token, the scores fetched for one
+         * dataset get embedded and drawn over another's observations: a plot of two datasets at
+         * once, which reads as a strange-looking t-SNE rather than as a bug.
+         */
+        this.computeToken = 0;
+        /** 0..1 while running, or null before the first report. Drives the progress bar. */
+        this.computeFraction = null;
+        /** Which backend the worker got — 'webgpu', 'wasm' or 'cpu'. Shown while running. */
+        this.computeBackend = null;
+        this.computeMessage = null;
+        this.computeError = null;
+        /** True when a t-SNE is missing but the dataset is too big to embed here. */
+        this.tsneTooLarge = false;
+        /** Observations in the live dataset, kept for the cost estimate. */
+        this.observationCount = 0;
+        this.controls = null;
+        this.kind = 'histogram';
+        /** Embeddings the dataset publishes, and which of them is drawn. */
+        this.embeddings = [];
+        this.embedding = null;
+        this.embeddingCoords = null;
+        /** The categorical colouring behind the embedding's colours, kept so a redraw for a
+         *  selection change does not refetch the column. */
+        this.embeddingCodes = null;
+        /**
+         * Genes the heatmap's rows are, and the vectors behind them.
+         *
+         * Local rather than in `SpatialViewState`, matching how the chart KIND is
+         * held: this is what the panel is charting, not what the map is drawing, and
+         * the renderer has no use for it.
+         */
+        this.heatmapGenes = [];
+        /** Z-score each gene across the groups. On by default: without it one loud
+         *  gene saturates the scale and the rest of the panel reads as blank. */
+        this.heatmapZScore = true;
+        /** Columns the cap dropped from the last render, for the note. */
+        this.heatmapHidden = 0;
+        this.geneOptions = [];
+        /** Every gene the dataset inlined. `geneOptions` is only ever the best few hundred of
+         *  these — see `gene-search.ts` for why a whole-transcriptome list cannot be handed to
+         *  the control whole. */
+        this.geneNames = [];
+        /** What is typed in the picker's filter box, so the options can be rebuilt when the
+         *  selection changes without losing the query. */
+        this.geneQuery = '';
+        /** Fetched vectors by gene name, so adding a fourth gene does not refetch the
+         *  first three — each is a full per-observation Float32Array. */
+        this.geneCache = new Map();
+        /** Categorical column the violin/box splits by; null = one trace for all. */
+        this.groupBy = null;
+        this.groupOptions = [];
+        /** What the map is coloured by — the chart's subject. */
+        this.colorBy = null;
+        this.selectionCount = 0;
+        /** Set when the active colour source cannot be charted, for an inline hint. */
+        this.notice = null;
+        this.busy = false;
+        this.view = { ...DEFAULT_SPATIAL_VIEW };
+        this.selection = emptySelection();
+        this.values = null;
+        /** Set instead of `values` when the colour source is a categorical column: its
+         *  distribution is counts per category, not a histogram of its codes. */
+        this.categorical = null;
+        this.grouping = null;
+        /** Guards the async value fetch: a fast colour-source change can resolve out
+         *  of order, and a stale vector would be charted against the new label. */
+        this.token = 0;
+        /** The same guard for the grouping fetch, which the user can change as fast. */
+        this.groupToken = 0;
+        /** Whether the first view emission has been handled. */
+        this.primed = false;
+        this.subs = new Subscription();
+        /**
+         * The height the drawn layout asked for, or null where it autosizes.
+         *
+         * {@link resize} needs this: the counts and heatmap layouts size their height
+         * to their content — one band per bar, per gene row — while the distribution
+         * kinds want to fill whatever height they are given.
+         */
+        this.drawnHeight = null;
+    }
+    ngOnInit() {
+        // Before the port check: the help icon is in the template either way, and a panel
+        // with no data source is exactly where someone reads it.
+        ensureHelpTipStyle();
+        this.controls = this.viz.getSpatialControls?.() ?? null;
+        if (!this.controls)
+            return;
+        this.subs.add(combineLatest([
+            this.controls.getViewState$(), this.controls.getSelection$(),
+        ]).subscribe(([view, selection]) => {
+            const sourceChanged = view.colorBy?.kind !== this.view.colorBy?.kind
+                || view.colorBy?.name !== this.view.colorBy?.name;
+            this.view = view;
+            this.colorBy = view.colorBy;
+            this.selection = selection;
+            this.selectionCount = selection.count;
+            // A selection or log change only needs a re-render; a new colour source
+            // needs its vector fetched first. The FIRST emission always reloads:
+            // otherwise `null -> null` reads as "unchanged" and the component sits
+            // with no data and no explanation until something else moves.
+            if (!this.primed || sourceChanged) {
+                this.primed = true;
+                void this.reload();
+            }
+            else {
+                // A selection or log-scale change needs only a redraw of the same vector.
+                void this.render();
+            }
+        }));
+        this.subs.add(this.controls.getDataset$().subscribe((dataset) => {
+            this.groupOptions = [
+                { label: 'No grouping', value: null },
+                ...(this.controls?.categoricalColumns() ?? []).map((n) => ({ label: n, value: n })),
+            ];
+            // A new dataset's columns are different; a carried-over group is meaningless.
+            if (this.groupBy && !this.groupOptions.some((o) => o.value === this.groupBy)) {
+                this.groupBy = null;
+                this.grouping = null;
+            }
+            // The heatmap's rows come from the dataset's gene list. A dataset too wide
+            // to inline its names offers none here — the panel's typeahead is the way
+            // in for those, and the heatmap needs names it can list.
+            this.geneNames = [...(dataset?.features?.names ?? [])];
+            this.geneQuery = '';
+            // Validated against the WHOLE list, not the visible options: those are capped, and
+            // filtering the selection by them would drop genes the dataset still has.
+            const known = new Set(this.geneNames);
+            this.heatmapGenes = this.heatmapGenes.filter((n) => known.has(n));
+            this.refreshGeneOptions();
+            this.geneCache.clear();
+            // Embeddings belong to the dataset, so they are re-read with it and the loaded
+            // coordinates dropped: a UMAP from the previous dataset over these observations
+            // would be a plot of two different things at once.
+            this.computed.clear();
+            this.abandonCompute();
+            const published = dataset?.embeddings ? [...dataset.embeddings] : [];
+            // Offer to compute a t-SNE only where the dataset has PCA to embed and no t-SNE of
+            // its own — otherwise the menu advertises work that cannot start, or duplicates
+            // what is already served.
+            const hasPca = published.some((e) => /pca/i.test(e.label ?? e.name));
+            const hasTsne = published.some((e) => /tsne|t-sne/i.test(e.label ?? e.name));
+            this.observationCount = dataset?.observations.count ?? 0;
+            this.tsneTooLarge = hasPca && !hasTsne
+                && this.observationCount > SpatialChartsComponent.BROWSER_TSNE_MAX_OBSERVATIONS;
+            this.embeddings = hasPca && !hasTsne && !this.tsneTooLarge
+                ? [...published, ...SpatialChartsComponent.COMPUTABLE]
+                : published;
+            this.embedding = this.embeddings[0] ?? null;
+            this.embeddingCoords = null;
+            this.embeddingCodes = null;
+            // Nothing to draw for the kind that was selected; fall back rather than sit blank.
+            if (this.kind === 'embedding' && this.embeddings.length === 0)
+                this.kind = 'histogram';
+        }));
+    }
+    /**
+     * Re-fit the plot to the panel's current width.
+     *
+     * Called by the host when the dialog finishes resizing. Plotly does not notice
+     * a container resize on its own — its `responsive` option listens for WINDOW
+     * resizes only, so dragging a dialog edge reaches it through nothing at all.
+     */
+    resize() {
+        this.refit(this.chartDiv);
+    }
+    /**
+     * Re-fit whatever is plotted in `div` to its container.
+     *
+     * Shared by the panel and the detached window because the rule is the same and getting
+     * it wrong is invisible until it is not: `autosize` takes BOTH dimensions from the
+     * container, which is right only where the layout did not fix its own height. Measured:
+     * autosizing a layout with an explicit height of 500 replaced it with the container's
+     * 400. The counts and heatmap layouts size themselves to their row count, so the
+     * window resize has to set the width ALONE for them and let the height stand.
+     */
+    refit(div) {
+        const el = document.getElementById(div);
+        if (!el)
+            return;
+        const width = Math.round(el.clientWidth);
+        // Zero while the section is collapsed or the dialog is closed; relaying out
+        // to a zero box makes Plotly compute a layout it does not recover from.
+        if (width <= 0)
+            return;
+        try {
+            Plotly.relayout(el, this.drawnHeight === null ? { autosize: true } : { width });
+        }
+        catch {
+            // Nothing plotted yet.
+        }
+    }
+    ngOnDestroy() {
+        this.subs.unsubscribe();
+        // A worker outlives the component that started it: closing the panel mid-run would
+        // otherwise leave a t-SNE saturating a GPU for minutes with nothing left to receive
+        // the answer.
+        this.abandonCompute();
+        // BOTH divs: a chart left detached at teardown holds its WebGL context in the
+        // window's div, which the inline id would never reach.
+        for (const div of [this.chartDiv, this.detachedDiv]) {
+            try {
+                Plotly.purge(div);
+            }
+            catch {
+                // The div may already be gone with the dialog; nothing to clean up.
+            }
+        }
+    }
+    ngAfterViewInit() {
+        // The div exists only now, so this is the earliest a first draw can land.
+        void this.reload();
+    }
+    onKind(kind) {
+        this.kind = kind;
+        if (kind === 'heatmap') {
+            // Seed with the gene already on screen, so the chart says something the
+            // moment it opens rather than showing an empty grid and a prompt.
+            if (this.heatmapGenes.length === 0 && this.colorBy?.kind === 'feature') {
+                this.heatmapGenes = [this.colorBy.name];
+            }
+            void (async () => {
+                await this.ensureHeatmapGrouping();
+                await this.loadHeatmapGenes();
+                void this.render();
+            })();
+            return;
+        }
+        void this.render();
+    }
+    /**
+     * The grouping the heatmap's columns come from, defaulting rather than
+     * demanding one: a heatmap with no columns is not a chart, and "No grouping"
+     * is a sensible answer for a violin but not for this.
+     */
+    async ensureHeatmapGrouping() {
+        if (this.grouping || !this.controls)
+            return;
+        const first = this.groupOptions.find((o) => o.value)?.value;
+        if (!first)
+            return;
+        await this.onGroupBy(first);
+    }
+    onHeatmapZScore(on) {
+        this.heatmapZScore = on;
+        void this.render();
+    }
+    /** What the heatmap is currently showing, said plainly. */
+    get heatmapNote() {
+        if (this.heatmapGenes.length === 0)
+            return 'Pick one or more genes for the rows.';
+        const perCell = this.selectionCount > 0
+            && this.selectionCount <= SpatialChartsComponent.HEATMAP_CELL_COLUMNS;
+        if (perCell) {
+            return `One column per selected cell (${this.selectionCount}). `
+                + 'Mean expression per cell, so the columns are cells rather than classes.';
+        }
+        const scope = this.selectionCount > 0 ? 'the selected cells' : 'all cells';
+        const scaled = this.heatmapZScore
+            ? ' Each gene is z-scored across the columns, so the colour is above or below that gene\'s own average.'
+            : ' Raw means, so a highly-expressed gene dominates the scale.';
+        // Saying so matters: without it the panel looks like the whole column.
+        const capped = this.heatmapHidden > 0
+            ? ` Showing the ${SpatialChartsComponent.HEATMAP_MAX_COLUMNS} strongest of `
+                + `${SpatialChartsComponent.HEATMAP_MAX_COLUMNS + this.heatmapHidden}, `
+                + 'ranked by the largest value any picked gene reaches.'
+            : '';
+        return `Mean expression of each gene within each ${this.groupBy ?? 'group'}, over ${scope}.`
+            + `${scaled}${capped}`;
+    }
+    /** Gene rows for the heatmap. */
+    async onHeatmapGenes(names) {
+        this.heatmapGenes = names ?? [];
+        // Chosen genes must stay in the options or the control cannot label its chips.
+        this.refreshGeneOptions();
+        await this.loadHeatmapGenes();
+        void this.render();
+    }
+    /**
+     * Fetch any gene the heatmap needs and does not already hold.
+     *
+     * Sequenced on the same token the colour-source load uses: each vector is a
+     * separate request, and a slower one must not paint rows for a gene list the
+     * user has already moved on from.
+     */
+    async loadHeatmapGenes() {
+        const controls = this.controls;
+        if (!controls)
+            return;
+        const missing = this.heatmapGenes.filter((n) => !this.geneCache.has(n));
+        if (missing.length === 0)
+            return;
+        const mine = ++this.token;
+        this.busy = true;
+        try {
+            for (const name of missing) {
+                const values = await controls.continuousValues({ kind: 'feature', name });
+                if (mine !== this.token)
+                    return;
+                this.geneCache.set(name, values);
+            }
+            this.notice = null;
+        }
+        catch (err) {
+            if (mine !== this.token)
+                return;
+            this.notice = `A gene could not be charted: ${err?.message ?? err}`;
+        }
+        finally {
+            if (mine === this.token)
+                this.busy = false;
+        }
+    }
+    async onGroupBy(name) {
+        this.groupBy = name;
+        if (!name || !this.controls) {
+            this.grouping = null;
+            void this.render();
+            return;
+        }
+        // Sequenced: pick A then B and a slower A would otherwise land last, charting
+        // A's categories under a dropdown that says B.
+        const mine = ++this.groupToken;
+        try {
+            const view = await this.controls.categoricalView(name);
+            if (mine !== this.groupToken)
+                return;
+            this.grouping = { codes: view.codes, categories: view.categories, colors: view.colors };
+        }
+        catch {
+            if (mine !== this.groupToken)
+                return;
+            this.grouping = null;
+            this.groupBy = null;
+        }
+        void this.render();
+    }
+    /** True when the current kind would read better with a grouping chosen. */
+    get suggestsGrouping() {
+        return benefitsFromGrouping(this.kind) && !this.groupBy && this.groupOptions.length > 1;
+    }
+    get subject() {
+        if (!this.colorBy)
+            return '';
+        return this.colorBy.kind === 'feature' ? `gene ${this.colorBy.name}` : this.colorBy.name;
+    }
+    // ── internals ───────────────────────────────────────────────────────────
+    /** Fetch the active colour source's vector, then draw. */
+    async reload() {
+        const controls = this.controls;
+        const source = this.view.colorBy;
+        const mine = ++this.token;
+        if (!controls || !source) {
+            this.values = null;
+            this.categorical = null;
+            this.notice = controls
+                ? 'Colour the map by a column or a gene to chart its distribution.'
+                : null;
+            void this.render();
+            return;
+        }
+        this.busy = true;
+        // A categorical column charts as COUNTS per category — asked for by name
+        // rather than discovered by catching the continuous fetch's error, so a
+        // genuine failure still reads as a failure.
+        const isCategorical = source.kind === 'column'
+            && (controls.categoricalColumns() ?? []).includes(source.name);
+        try {
+            if (isCategorical) {
+                const view = await controls.categoricalView(source.name);
+                if (mine !== this.token)
+                    return; // superseded
+                this.categorical = { codes: view.codes, categories: view.categories, colors: view.colors };
+                this.values = null;
+                this.kind = 'counts';
+                this.notice = null;
+            }
+            else {
+                const values = await controls.continuousValues(source);
+                if (mine !== this.token)
+                    return;
+                this.values = values;
+                this.categorical = null;
+                if (this.kind === 'counts')
+                    this.kind = 'histogram';
+                this.notice = null;
+            }
+        }
+        catch (err) {
+            if (mine !== this.token)
+                return;
+            this.values = null;
+            this.categorical = null;
+            this.notice = `"${source.name}" could not be charted: ${err?.message ?? err}`;
+        }
+        finally {
+            if (mine === this.token)
+                this.busy = false;
+        }
+        void this.render();
+    }
+    /**
+     * The embedding scatter — a UMAP over the same observations.
+     *
+     * Answers what the map cannot: the map says WHERE a population sits, this says which
+     * populations there are and how close they are in expression.
+     *
+     * Linked to the map without asking for anything: it reuses `this.categorical`, the same
+     * loaded colouring the counts chart draws from, so the two cannot disagree about what a
+     * colour means and no second fetch happens. A selection dims the rest rather than
+     * dropping it — the embedding's shape is the context that makes a selection legible.
+     */
+    async renderEmbedding() {
+        const controls = this.controls;
+        const meta = this.embedding;
+        if (!controls || !meta) {
+            this.purgePlot();
+            return;
+        }
+        if (!controls.getEmbedding) {
+            this.notice = 'This data source does not serve embeddings.';
+            this.purgePlot();
+            return;
+        }
+        // Sequenced on the shared token: the coordinates are a round-trip, and a slower one
+        // must not paint over a kind the user has already moved on from.
+        const mine = ++this.token;
+        // Computed here, not served: a local result is the same shape as a fetched one, so
+        // everything downstream — colouring, lasso selection, the camera — is unchanged.
+        const local = this.computed.get(meta.name);
+        if (local) {
+            this.embeddingCoords = local;
+        }
+        else if (this.isComputable) {
+            // Offered but not yet computed. The panel shows the Compute button; drawing nothing
+            // is right, and an error would be wrong — there is no failure here.
+            this.purgePlot();
+            this.notice = null;
+            return;
+        }
+        else if (!this.embeddingCoords || this.embeddingCoords.meta.name !== meta.name) {
+            this.busy = true;
+            try {
+                const loaded = await controls.getEmbedding(meta.name);
+                if (mine !== this.token)
+                    return;
+                this.embeddingCoords = loaded;
+            }
+            catch (err) {
+                if (mine !== this.token)
+                    return;
+                this.notice = `Could not load ${meta.label ?? meta.name}: `
+                    + `${err?.message ?? err}`;
+                this.purgePlot();
+                return;
+            }
+            finally {
+                if (mine === this.token)
+                    this.busy = false;
+            }
+        }
+        const coords = this.embeddingCoords;
+        if (!coords)
+            return;
+        const target = this.plotTarget;
+        const el = document.getElementById(target);
+        if (!el)
+            return; // the window is closed, or not rendered yet
+        const view = this.liveView(el);
+        this.notice = null;
+        const input = {
+            x: coords.x,
+            y: coords.y,
+            // The third dimension when the embedding has one — what switches the plot to a
+            // rotatable 3D scatter. Decoded only for a 3-dim embedding, so its presence here
+            // is the same question as `meta.dims === 3`.
+            ...(coords.z ? { z: coords.z } : {}),
+            label: meta.label ?? meta.name,
+            derived: meta.derived,
+            // Present for a PCA, absent for a UMAP — see `varianceRatio` on the meta.
+            ...(meta.varianceRatio ? { varianceRatio: meta.varianceRatio } : {}),
+            ...(this.categorical
+                ? {
+                    categories: {
+                        codes: this.categorical.codes,
+                        names: this.categorical.categories,
+                        colors: this.categorical.colors,
+                    },
+                }
+                : {}),
+            ...(this.selection.count > 0 ? { selection: this.selection.mask } : {}),
+            // Whatever view the user has set up, read from the LIVE plot — which is where
+            // rotating and zooming leave it.
+            ...(view ? { view } : {}),
+        };
+        await this.draw(buildEmbeddingTraces(input), embeddingLayout(input), EMBEDDING_CONFIG, target);
+        this.bindEmbeddingSelection(target);
+    }
+    /**
+     * Turn a lasso in the embedding into a selection of observations.
+     *
+     * This is what makes two views of one dataset worth having side by side: draw round a
+     * cluster here and those cells light up on the tissue, because every view reads the
+     * same mask.
+     *
+     * Bound after each draw, and the previous listener removed first: `Plotly.react`
+     * preserves handlers, so re-binding without removing would fire the selection once per
+     * redraw the plot had ever had.
+     */
+    bindEmbeddingSelection(div) {
+        const el = document.getElementById(div);
+        if (!el?.on)
+            return;
+        el.removeAllListeners?.('plotly_selected');
+        el.removeAllListeners?.('plotly_deselect');
+        el.on('plotly_selected', (ev) => {
+            // A lasso that selects nothing arrives as an event with no points; treat it as a
+            // clear, which is what dragging an empty patch looks like it should do.
+            const points = ev?.points ?? [];
+            const indices = [];
+            for (const p of points) {
+                // The observation index rides on `customdata` — see `buildEmbeddingTraces`. A point's
+                // index within its trace is not the observation once the points are split by
+                // category, so this is the only correct source.
+                const id = p.customdata;
+                if (typeof id === 'number')
+                    indices.push(id);
+            }
+            if (indices.length === 0) {
+                this.controls?.clearSelection();
+                return;
+            }
+            this.controls?.selectIndices(indices);
+        });
+        // The modebar's deselect, and a plain click on empty space.
+        el.on('plotly_deselect', () => this.controls?.clearSelection());
+    }
+    /**
+     * Drop the embedding's selection handlers from a div another kind is about to use.
+     *
+     * The detached window outlives any one kind — switching tabs swaps its content and
+     * keeps the div — so without this the lasso handlers bound for a UMAP stay live under
+     * the counts plot that replaces it. `plotly_deselect` fires on a plain click in ANY
+     * Plotly chart, so the first click on a bar would silently clear the map's selection.
+     */
+    unbindEmbeddingSelection(div) {
+        const el = document.getElementById(div);
+        if (!el?.removeAllListeners)
+            return;
+        el.removeAllListeners('plotly_selected');
+        el.removeAllListeners('plotly_deselect');
+    }
+    /**
+     * The view the user has set up on the live plot, to carry across a redraw.
+     *
+     * `Plotly.react` resets a 3D scene camera and any zoomed 2D range unless the layout
+     * carries them, so selecting a category or recolouring would throw away an orientation
+     * that took work to find. Rotating a cloud to see a structure and losing it on the next
+     * click makes the plot useless for what it is for.
+     */
+    liveView(el) {
+        const full = el._fullLayout;
+        if (!full)
+            return null; // nothing drawn here yet
+        if (full.scene?.camera)
+            return { camera: full.scene.camera };
+        // 2D: only once the user has actually zoomed. Passing an autoranged range back would
+        // freeze the axes and stop the plot re-fitting when the data changes.
+        const zoomed = full.xaxis?.autorange === false && full.yaxis?.autorange === false;
+        if (zoomed && full.xaxis?.range && full.yaxis?.range) {
+            return { ranges: { x: full.xaxis.range, y: full.yaxis.range } };
+        }
+        return null;
+    }
+    /**
+     * Whether the plot on screen fixed its own height.
+     *
+     * The counts and heatmap layouts size themselves to their row count, so in the detached
+     * window they can be TALLER than the window — which has to scroll rather than clip. An
+     * embedding fixes no height and fills the window instead. The template needs to know
+     * which, because the two want opposite `flex` and `overflow`.
+     */
+    get hasFixedHeight() {
+        return this.drawnHeight !== null;
+    }
+    /** Where the active kind draws: its own window, or the shared chart div. */
+    get plotTarget() {
+        return this.detached ? this.detachedDiv : this.chartDiv;
+    }
+    /**
+     * Header for the detached window — what it is showing, named as its tab is.
+     *
+     * The embedding names the embedding rather than the tab, because "Embedding" beside a
+     * window drawing a t-SNE says less than "t-SNE" does.
+     */
+    get detachedTitle() {
+        if (this.kind === 'embedding') {
+            return this.embedding?.label ?? this.embedding?.name ?? 'Embedding';
+        }
+        const label = this.kindOptions.find((k) => k.value === this.kind)?.label ?? 'Chart';
+        return this.subject ? `${label} · ${this.subject}` : label;
+    }
+    /**
+     * Move the active kind between its own window and the panel.
+     *
+     * Purges the div it is LEAVING first. Plotly keeps per-div state, and a graph left
+     * behind in a div that Angular then removes leaks its WebGL context — and if the div
+     * comes back, react would resize a plot whose data belongs to the other place.
+     */
+    toggleDetached() {
+        const leaving = this.plotTarget;
+        this.detached = !this.detached;
+        try {
+            Plotly.purge(leaving);
+        }
+        catch {
+            // Nothing was plotted there.
+        }
+        // Going back INLINE, the div appears with the next change detection, so a task is
+        // enough. Going OUT, the window's div does not exist yet — PrimeNG mounts the dialog
+        // with a transition — so the dialog's own `onShow` drives that draw instead. A single
+        // deferred attempt drew nothing and never retried.
+        if (!this.detached)
+            setTimeout(() => void this.render(), 0);
+    }
+    /** The detached window is up and its div exists — now the plot can be drawn into it. */
+    onDetachedWindowShown() {
+        void this.render();
+    }
+    /** Re-fit the detached window's plot after it is resized. */
+    onDetachedResizeEnd() {
+        this.refit(this.detachedDiv);
+    }
+    /**
+     * Rebuild the visible options: the best matches for what is typed, plus what is chosen.
+     *
+     * A capped multi-select that drops its own selections cannot resolve their labels, and
+     * the model loses them on the next change — the chips vanish for no reason the user
+     * can see.
+     */
+    refreshGeneOptions() {
+        this.geneOptions = geneOptionsFor(this.geneNames, this.geneQuery, this.heatmapGenes)
+            .map((n) => ({ label: n, value: n }));
+    }
+    /** The gene picker's filter box changed: search the resident names, show the best. */
+    onGeneFilter(query) {
+        this.geneQuery = query ?? '';
+        this.refreshGeneOptions();
+    }
+    /**
+     * Roughly how long a run will take, in seconds, from the measured anchor.
+     *
+     * Shown before the click. A progress bar tells you a job is going; only an estimate
+     * tells you whether to start it.
+     */
+    get computeEstimateSeconds() {
+        const n = this.observationCount;
+        const { seconds, observations } = SpatialChartsComponent.TSNE_SECONDS_AT;
+        return Math.max(1, Math.round(seconds * (n / observations) ** 2));
+    }
+    /** That estimate as something to put on a button. */
+    get computeEstimateLabel() {
+        const secs = this.computeEstimateSeconds;
+        if (secs < 90)
+            return `~${secs}s`;
+        return `~${Math.round(secs / 60)} min`;
+    }
+    /** Why the option is absent, when a dataset is past the threshold. */
+    get tsneTooLargeNote() {
+        const n = this.observationCount;
+        return `t-SNE is not offered here for ${n.toLocaleString()} observations — it is `
+            + `quadratic, so it would take roughly ${this.computeEstimateLabel} in the browser. `
+            + 'Compute it offline and serve it with the dataset.';
+    }
+    /** Whether the selected embedding is one this browser would have to compute. */
+    get isComputable() {
+        return !!this.embedding && this.embedding.name.startsWith('local:');
+    }
+    /** Whether it has already been computed in this session. */
+    get isComputed() {
+        return !!this.embedding && this.computed.has(this.embedding.name);
+    }
+    get isComputing() {
+        return !!this.computeRun?.running;
+    }
+    /**
+     * Compute the selected embedding here, in a worker.
+     *
+     * The PCA scores come from the port as an ordinary embedding — the server derives them,
+     * because PCA needs the whole expression matrix (185 MB for a Visium dataset) while
+     * t-SNE needs only the scores (0.51 MB). Sending the matrix to the browser to save a
+     * few seconds of arithmetic would be a far slower answer.
+     */
+    async computeEmbedding() {
+        const meta = this.embedding;
+        const controls = this.controls;
+        if (!meta || !controls?.getEmbedding || this.isComputing)
+            return;
+        this.computeError = null;
+        this.computeMessage = null;
+        this.computeFraction = null;
+        this.computeBackend = null;
+        // Every early return and every await below is checked against this. `run` is held
+        // locally as well as on the instance: after an await `this.computeRun` may already be
+        // a newer run's, and clearing or terminating that one is how a fresh computation gets
+        // killed by the tail of the one it replaced.
+        const mine = ++this.computeToken;
+        const superseded = () => mine !== this.computeToken;
+        let run = null;
+        try {
+            // Prefer the 3-D scores: they carry a third component for free, and t-SNE on more
+            // components than it needs is not better — the PCA basis is the input either way.
+            const source = await this.loadPcaScores(controls);
+            if (superseded())
+                return;
+            if (!source) {
+                this.computeError = 'This dataset serves no PCA to embed.';
+                return;
+            }
+            run = new EmbeddingComputeRun();
+            this.computeRun = run;
+            const result = await run.run({
+                scores: source.scores,
+                nObs: source.nObs,
+                nDims: source.nDims,
+                dims: meta.dims,
+            }, {
+                ...meta,
+                label: (meta.label ?? meta.name)
+                    .replace(SpatialChartsComponent.COMPUTE_SUFFIX, ''),
+            }, (progress) => {
+                // Progress from a superseded run must not drive the bar a newer one is using.
+                if (superseded())
+                    return;
+                this.computeFraction = progress.fraction;
+                this.computeBackend = progress.backend ?? this.computeBackend;
+                if (progress.message)
+                    this.computeMessage = progress.message;
+            });
+            // A terminated run resolves null, so this covers abandonment as well as Cancel —
+            // but the token is still checked, because the dataset can change between the
+            // worker's `done` and this line.
+            if (result && !superseded()) {
+                this.computed.set(meta.name, result);
+                this.embeddingCoords = result;
+                await this.render();
+            }
+        }
+        catch (err) {
+            if (!superseded())
+                this.computeError = err?.message ?? String(err);
+        }
+        finally {
+            run?.terminate();
+            // Only if it is still ours: a dataset switch has already terminated this run and
+            // may have started another, and `this.computeRun = null` here would orphan it —
+            // leaving a worker nothing can cancel and a Cancel button that does nothing.
+            if (this.computeRun === run) {
+                this.computeRun = null;
+                this.computeFraction = null;
+            }
+        }
+    }
+    /** Stop a run. It settles shortly after, leaving no embedding. */
+    cancelCompute() {
+        this.computeRun?.cancel();
+    }
+    /**
+     * Drop any computation in progress, because what it is computing no longer applies.
+     *
+     * Distinct from {@link cancelCompute}, which is the user's Cancel and asks the worker to
+     * stop politely. This one does not wait: the run is settled and the worker killed, so a
+     * dataset switch or a teardown cannot leave a t-SNE grinding on in the background over
+     * observations nothing is showing any more.
+     */
+    abandonCompute() {
+        this.computeToken++;
+        this.computeRun?.terminate();
+        this.computeRun = null;
+        this.computeFraction = null;
+        this.computeBackend = null;
+        this.computeMessage = null;
+    }
+    /**
+     * The dataset's PCA, as row-major scores.
+     *
+     * Assembled from whichever PCA the source offers, widest first — a 3-D one gives t-SNE
+     * three components instead of two for the same request.
+     */
+    async loadPcaScores(controls) {
+        const candidates = this.embeddings
+            .filter((e) => /pca/i.test(e.label ?? e.name) && !e.name.startsWith('local:'))
+            .sort((a, b) => b.dims - a.dims);
+        for (const candidate of candidates) {
+            try {
+                const pca = await controls.getEmbedding(candidate.name);
+                const planes = [pca.x, pca.y, ...(pca.z ? [pca.z] : [])];
+                const nObs = pca.x.length;
+                const nDims = planes.length;
+                const scores = new Float32Array(nObs * nDims);
+                for (let i = 0; i < nObs; i++) {
+                    for (let d = 0; d < nDims; d++)
+                        scores[i * nDims + d] = planes[d][i];
+                }
+                return { scores, nObs, nDims };
+            }
+            catch {
+                // Try the next; a source may advertise one it cannot actually serve.
+            }
+        }
+        return null;
+    }
+    /** Which embedding to draw, when the dataset publishes more than one. */
+    onEmbedding(name) {
+        const next = this.embeddings.find((e) => e.name === name);
+        if (!next || next.name === this.embedding?.name)
+            return;
+        this.embedding = next;
+        this.embeddingCoords = null;
+        void this.render();
+    }
+    /**
+     * What the chart on screen actually shows, and what it cannot be read for.
+     *
+     * Shown on hover from a `?` beside the tabs. Each of these plots answers a different
+     * question and two of them are routinely over-read — a UMAP's distances and a heatmap's
+     * unscaled colours — so the caveat is part of the explanation rather than a footnote.
+     *
+     * HTML, because the tooltip renders with `[escape]="false"`: a paragraph and a caveat
+     * read as two thoughts, and a single run-on line is skipped rather than read.
+     */
+    get kindHelp() {
+        switch (this.kind) {
+            case 'counts':
+                return '<b>Counts</b> — how many observations fall in each category of the column '
+                    + 'the map is coloured by, largest first.<br><br>A category code is a label, not '
+                    + 'a magnitude, so a frequency is the only distribution it has: there is no '
+                    + 'histogram of a cell type.';
+            case 'histogram':
+                return '<b>Histogram</b> — how the active value is distributed over all '
+                    + 'observations.<br><br>With a selection, it is overlaid on the full '
+                    + 'distribution rather than replacing it, so you can see where the selected '
+                    + 'cells sit within the whole.';
+            case 'violin':
+                return '<b>Violin</b> — the active value\'s distribution within each category of '
+                    + 'the grouping column, drawn as a smoothed density.<br><br>Shows shape a box '
+                    + 'plot hides: two groups with the same median can be one peak or two.';
+            case 'box':
+                return '<b>Box</b> — median, quartiles and range of the active value within each '
+                    + 'category of the grouping column.<br><br>Compact and comparable across many '
+                    + 'groups, at the cost of hiding whether a group is bimodal.';
+            case 'heatmap':
+                return '<b>Heatmap</b> — mean expression of each picked gene within each group: '
+                    + 'genes down, groups across.<br><br>Each gene is <b>z-scored across the '
+                    + 'groups</b> by default, so a colour says "above or below this gene\'s own '
+                    + 'average", not "highly expressed". Without that one loud gene saturates the '
+                    + 'scale and the rest of the panel reads as blank. Turning it off compares '
+                    + 'genes on their raw scale instead.';
+            case 'embedding':
+                return this.embeddingHelp;
+            default:
+                return '';
+        }
+    }
+    /**
+     * What the embedding on screen is, and how far its geometry can be trusted.
+     *
+     * Per METHOD, because that is the part people get wrong: a PCA's axes are ordered and
+     * measurable while a UMAP's are neither, and the same picture read the two ways supports
+     * opposite conclusions.
+     */
+    get embeddingHelp() {
+        const shared = '<br><br>Every cell is in all views at once: lasso a group here and '
+            + 'those cells light up on the tissue, because both read the same selection.';
+        const name = (this.embedding?.label ?? this.embedding?.name ?? '').toLowerCase();
+        if (name.includes('pca')) {
+            return '<b>PCA</b> — a <b>linear</b> projection onto the directions of greatest '
+                + 'variance, in order.<br><br>Alone among these, its axes mean something '
+                + 'measurable: each reports the share of total variance it explains, which is why '
+                + 'the labels carry a percentage. Distances are real, and a low percentage tells '
+                + 'you the picture is a thin slice of the variation.' + shared;
+        }
+        if (name.includes('t-sne') || name.includes('tsne')) {
+            return '<b>t-SNE</b> — cells placed so that close neighbours in expression stay '
+                + 'close.<br><br>Stricter about local neighbourhoods than UMAP and less '
+                + 'trustworthy about anything global: it tends to spread clusters into '
+                + 'evenly-sized islands whose sizes and separations mean little. Read which cells '
+                + 'group together, not how far apart the groups are.' + shared;
+        }
+        return '<b>UMAP</b> — cells placed so that close neighbours in expression stay '
+            + 'close.<br><br>The axes are arbitrary: unordered, unitless, and reproducible only '
+            + 'up to a rotation, which is why they carry no percentage. Read which cells group '
+            + 'together and which groups touch; do not read the distance between distant '
+            + 'clusters, or the direction of an axis.' + shared;
+    }
+    /** What the embedding view is showing, said plainly. */
+    get embeddingNote() {
+        const meta = this.embeddingCoords?.meta ?? this.embedding;
+        if (!meta)
+            return 'This dataset publishes no embedding.';
+        // A derived embedding says so, and says HOW when the parameters are known: a t-SNE or
+        // UMAP at different settings is a different picture of the same cells, so "computed
+        // here" alone leaves a reader unable to reproduce or compare it.
+        const derived = meta.derived
+            ? ` Computed here${meta.params ? ` (${meta.params})` : ''}, `
+                + 'not published with the dataset.'
+            : '';
+        const coloured = this.categorical
+            ? ' Coloured to match the map.'
+            : ' Colour the map by a categorical column to colour these points.';
+        const sel = this.selection.count > 0
+            ? ` ${this.selection.count.toLocaleString()} selected are highlighted.`
+            : '';
+        return `${meta.label ?? meta.name}.${coloured}${sel}${derived}`;
+    }
+    purgePlot() {
+        try {
+            // The ACTIVE target: purging the inline div while detached would leave the
+            // window showing a plot the component believes it has cleared.
+            Plotly.purge(this.plotTarget);
+        }
+        catch {
+            // Nothing plotted.
+        }
+    }
+    /**
+     * Draw, remembering whether this layout fixed its own height.
+     *
+     * The layout builders return `unknown` on purpose — they keep Plotly's layout
+     * types out of the pure module — so the height is read back by narrowing
+     * rather than declared. `height` is Plotly's own key, not ours.
+     */
+    async draw(traces, layout, config = CHART_CONFIG, div = this.plotTarget) {
+        const height = layout?.height;
+        this.drawnHeight = typeof height === 'number' ? height : null;
+        await Plotly.react(div, traces, layout, config);
+    }
+    async render() {
+        if (!this.isActive)
+            return;
+        // Guard on the div the ACTIVE kind will draw into, not always the shared one. While a
+        // kind is detached the inline div is removed by its `*ngIf`, so checking that one
+        // bailed here and the detached window never got a plot.
+        const target = this.plotTarget;
+        if (!document.getElementById(target))
+            return;
+        // Anything but the embedding inherits a div the embedding may have bound handlers on.
+        if (this.kind !== 'embedding')
+            this.unbindEmbeddingSelection(target);
+        // The heatmap answers a different question from the other kinds — which
+        // genes distinguish which groups — so it is driven by its own gene list and
+        // grouping rather than by whatever the map is coloured by.
+        if (this.kind === 'heatmap') {
+            await this.renderHeatmap();
+            return;
+        }
+        // Also independent of the active colour source: the coordinates are the dataset's,
+        // and the colouring merely follows whatever the map is using.
+        if (this.kind === 'embedding') {
+            await this.renderEmbedding();
+            return;
+        }
+        if (!this.colorBy || (!this.values && !this.categorical)) {
+            this.purgePlot();
+            return;
+        }
+        if (this.categorical) {
+            const counts = {
+                group: this.categorical,
+                selection: this.selection.count > 0 ? this.selection.mask : null,
+                name: this.colorBy.name,
+            };
+            await this.draw(buildCountTraces(counts), countsLayout(counts));
+            return;
+        }
+        if (!this.values)
+            return;
+        const input = {
+            values: this.values,
+            name: this.colorBy.kind === 'feature' ? this.colorBy.name : this.colorBy.name,
+            group: benefitsFromGrouping(this.kind) ? this.grouping : null,
+            selection: this.selection.count > 0 ? this.selection.mask : null,
+            log: this.view.logScale,
+        };
+        const traces = buildOmicsTraces(this.kind, input);
+        await this.draw(traces, omicsLayout(this.kind, input));
+    }
+    /**
+     * Genes × groups mean expression.
+     *
+     * Columns are the grouping column's categories — or, inside a SMALL
+     * selection, the selected cells themselves. A two-column class matrix is a
+     * poor answer for an ROI holding forty cells; "what is in front of me" is the
+     * question there, and each cell earns a column.
+     */
+    async renderHeatmap() {
+        const controls = this.controls;
+        const genes = this.heatmapGenes
+            .map((name) => ({ name, values: this.geneCache.get(name) }))
+            .filter((g) => !!g.values);
+        if (!controls || genes.length === 0 || !this.grouping) {
+            this.purgePlot();
+            return;
+        }
+        const selected = this.selection.count > 0 ? maskToIndices(this.selection.mask) : null;
+        const perCell = !!selected && selected.length <= SpatialChartsComponent.HEATMAP_CELL_COLUMNS;
+        const cells = perCell && selected
+            ? cellsAsGroups(selected, this.grouping.codes.length, SpatialChartsComponent.HEATMAP_CELL_COLUMNS)
+            : null;
+        const matrix = heatmapMatrix(genes, cells ? cells.groups : { codes: this.grouping.codes, categories: this.grouping.categories }, {
+            ...(cells ? { indices: cells.indices, minCells: 1 } : {}),
+            // Outside the per-cell view a selection still narrows the means, the way
+            // the violin and box narrow rather than overlay.
+            ...(!cells && selected ? { indices: selected } : {}),
+            // Only the grouped view: `cellsAsGroups` already caps by even thinning,
+            // and re-ranking those columns would lose the selection's spread.
+            ...(cells ? {} : { maxCols: SpatialChartsComponent.HEATMAP_MAX_COLUMNS }),
+            zScore: this.heatmapZScore,
+        });
+        if (!matrix) {
+            this.purgePlot();
+            this.notice = 'No group has enough measured cells for a mean.';
+            return;
+        }
+        this.notice = null;
+        this.heatmapHidden = matrix.hiddenCols;
+        const input = {
+            rows: matrix.rows,
+            cols: matrix.cols,
+            values: matrix.values,
+            counts: matrix.counts,
+            zScored: this.heatmapZScore,
+            groupLabel: cells ? 'selected cells' : (this.groupBy ?? ''),
+        };
+        await this.draw(buildHeatmapTraces(input), heatmapLayout(input));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SpatialChartsComponent, deps: [{ token: VISUALIZER }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: SpatialChartsComponent, selector: "spatial-charts", inputs: { active: "active" }, ngImport: i0, template: "<div class=\"sx-body\" *ngIf=\"controls\">\n\n  <!-- The chart follows whatever the map is coloured by, so the two can never\n       disagree about what is being shown. -->\n  <div class=\"sx-head\">\n    <span class=\"sx-subject\" *ngIf=\"subject\">{{ subject }}</span>\n    <span class=\"sx-subject sx-muted\" *ngIf=\"!subject\">nothing selected to chart</span>\n    <span class=\"sx-badge\" *ngIf=\"selectionCount\">\n      {{ selectionCount | number }} selected\n    </span>\n    <i class=\"pi pi-spin pi-spinner sx-busy\" *ngIf=\"busy\" aria-label=\"loading\"></i>\n  </div>\n\n  <div class=\"sx-controls\">\n    <p-selectButton [options]=\"kindOptions\" optionLabel=\"label\" optionValue=\"value\"\n                    [ngModel]=\"kind\" (ngModelChange)=\"onKind($event)\"\n                    styleClass=\"sx-kind\"></p-selectButton>\n    <p-dropdown [options]=\"groupOptions\" optionLabel=\"label\" optionValue=\"value\"\n                [ngModel]=\"groupBy\" (ngModelChange)=\"onGroupBy($event)\"\n                placeholder=\"No grouping\" appendTo=\"body\"\n                [disabled]=\"kind === 'histogram'\"\n                [pTooltip]=\"kind === 'heatmap'\n                  ? 'The categorical column the heatmap\\'s columns come from'\n                  : 'Split a violin or box by a categorical column'\"\n                tooltipPosition=\"top\"></p-dropdown>\n    <!-- What the chart on screen shows, and what it must NOT be read for. Each of these\n         answers a different question and two are routinely over-read, so the caveat\n         travels with the explanation. -->\n    <i class=\"pi pi-question-circle sx-help\"\n       [pTooltip]=\"kindHelp\" [escape]=\"false\" tooltipPosition=\"left\"\n       tooltipStyleClass=\"sx-help-tip\"\n       [attr.aria-label]=\"'About the ' + kind + ' chart'\" tabindex=\"0\"></i>\n  </div>\n\n  <!-- The heatmap's rows are a gene LIST, so it needs its own picker: the other\n       kinds chart whatever single source the map is coloured by. -->\n  <div class=\"sx-controls\" *ngIf=\"kind === 'heatmap'\">\n    <p-multiSelect [options]=\"geneOptions\" optionLabel=\"label\" optionValue=\"value\"\n                   [ngModel]=\"heatmapGenes\" (ngModelChange)=\"onHeatmapGenes($event)\"\n                   [filter]=\"true\" filterBy=\"label\" (onFilter)=\"onGeneFilter($event.filter)\"\n                   [virtualScroll]=\"true\" [virtualScrollItemSize]=\"30\" appendTo=\"body\"\n                   [showToggleAll]=\"false\" [maxSelectedLabels]=\"3\"\n                   selectedItemsLabel=\"{0} genes\"\n                   placeholder=\"Pick genes for the rows\"\n                   pTooltip=\"One row per gene, averaged within each group\"\n                   tooltipPosition=\"top\" styleClass=\"sx-genes\"></p-multiSelect>\n    <p-checkbox [binary]=\"true\" [ngModel]=\"heatmapZScore\"\n                (onChange)=\"onHeatmapZScore($event.checked)\"\n                label=\"z-score\"\n                pTooltip=\"Scale each gene across the groups. Without it one highly-expressed gene saturates the colour scale and the rest reads as blank\"\n                tooltipPosition=\"top\"></p-checkbox>\n  </div>\n\n  <!-- Detach applies to EVERY kind: the dialog is only so wide, and a counts plot read\n       against a heatmap is the same argument as a UMAP read against the map. -->\n  <div class=\"sx-controls\">\n    <!-- A picker only when the dataset publishes more than one embedding. -->\n    <p-dropdown *ngIf=\"kind === 'embedding' && embeddings.length > 1\"\n                [options]=\"embeddings\" optionLabel=\"label\" optionValue=\"name\"\n                [ngModel]=\"embedding?.name\" (ngModelChange)=\"onEmbedding($event)\"\n                appendTo=\"body\"\n                pTooltip=\"Which embedding to draw\" tooltipPosition=\"top\"></p-dropdown>\n    <!-- Offered only for an embedding this dataset does not publish. It runs in a Web\n         Worker on the GPU, so the panel stays usable while it goes. -->\n    <p-button *ngIf=\"kind === 'embedding' && isComputable && !isComputed && !isComputing\"\n              icon=\"pi pi-play\" size=\"small\" [text]=\"true\"\n              [label]=\"'Compute (' + computeEstimateLabel + ')'\"\n              pTooltip=\"Run t-SNE here, in a background worker on the GPU, from this dataset's PCA. The panel stays usable, and it can be cancelled.\"\n              tooltipPosition=\"top\"\n              (onClick)=\"computeEmbedding()\"></p-button>\n    <p-button *ngIf=\"isComputing\"\n              icon=\"pi pi-times\" size=\"small\" [text]=\"true\" severity=\"secondary\"\n              label=\"Cancel\" (onClick)=\"cancelCompute()\"></p-button>\n    <p-button [icon]=\"detached ? 'pi pi-window-minimize' : 'pi pi-external-link'\"\n              size=\"small\" [text]=\"true\"\n              [label]=\"detached ? 'Put back' : 'Detach'\"\n              [pTooltip]=\"detached\n                ? 'Show this chart in the panel again'\n                : 'Open this chart in its own window, alongside this panel'\"\n              tooltipPosition=\"top\"\n              (onClick)=\"toggleDetached()\"></p-button>\n  </div>\n\n  <!-- Progress while a computation runs. `mode=\"indeterminate\"` until the first report,\n       because the run starts with a neighbour graph and there is nothing honest to show\n       as a percentage yet. -->\n  <div class=\"sx-compute\" *ngIf=\"isComputing\">\n    <p-progressBar\n      [mode]=\"computeFraction === null ? 'indeterminate' : 'determinate'\"\n      [value]=\"computeFraction === null ? 0 : (computeFraction * 100)\"\n      [showValue]=\"computeFraction !== null\"\n      [style]=\"{ height: '0.6rem' }\"></p-progressBar>\n    <small class=\"sx-hint\">\n      {{ computeFraction === null ? 'Building the neighbour graph\u2026' : 'Optimising\u2026' }}\n      <ng-container *ngIf=\"computeBackend\"> on {{ computeBackend }}</ng-container>\n    </small>\n    <small class=\"sx-hint sx-warn\" *ngIf=\"computeMessage\">{{ computeMessage }}</small>\n  </div>\n  <small class=\"sx-hint sx-warn\" *ngIf=\"computeError\">{{ computeError }}</small>\n  <!-- Withheld rather than offered with a warning: an hour-long job is not a choice a\n       reader can meaningfully consent to from a dialog. -->\n  <small class=\"sx-hint\" *ngIf=\"kind === 'embedding' && tsneTooLarge\">{{ tsneTooLargeNote }}</small>\n\n  <div [id]=\"chartDiv\" class=\"sx-plot\" *ngIf=\"!detached\"></div>\n\n  <!-- Detached: the chart keeps drawing, in its own window. Says so rather than\n       leaving a blank panel that looks broken. -->\n  <div class=\"sx-detached\" *ngIf=\"detached\">\n    Shown in its own window.\n  </div>\n\n  <ng-container *ngTemplateOutlet=\"hints\"></ng-container>\n\n</div>\n\n<!-- Declared once and rendered in both the panel and the detached window: the ladder is\n     deliberately not mutually exclusive (a heatmap still needs its grouping prompt), so\n     collapsing it to a single expression would drop a hint rather than move it. -->\n<ng-template #hints>\n  <small class=\"sx-hint\" *ngIf=\"notice\">{{ notice }}</small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && suggestsGrouping\">\n    Pick a grouping to compare categories.\n  </small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && selectionCount && kind === 'histogram'\">\n    The selection is overlaid on the full distribution.\n  </small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && selectionCount && kind !== 'histogram' && kind !== 'heatmap'\">\n    Showing the selection only.\n  </small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && kind === 'heatmap'\">{{ heatmapNote }}</small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && kind === 'embedding'\">{{ embeddingNote }}</small>\n</ng-template>\n\n<!-- The detached chart. Its own non-modal, draggable, resizable window so it can be put\n     beside the spatial-omics dialog. `appendTo=\"body\"` keeps it out of the dialog's\n     stacking context, or it would be clipped by the panel it is meant to sit next to. -->\n<p-dialog *ngIf=\"detached\"\n          [header]=\"detachedTitle\"\n          [visible]=\"true\" (visibleChange)=\"toggleDetached()\"\n          [modal]=\"false\" [resizable]=\"true\" [draggable]=\"true\"\n          position=\"right\" appendTo=\"body\"\n          (onShow)=\"onDetachedWindowShown()\"\n          (onResizeEnd)=\"onDetachedResizeEnd()\"\n          [style]=\"{ width: '34rem', height: '30rem' }\"\n          [contentStyle]=\"{\n            display: 'flex', flexDirection: 'column', gap: '0.25rem',\n            padding: '0.4rem 0.6rem 0.5rem', flex: '1 1 auto', minHeight: '0',\n            overflow: 'auto'\n          }\"\n          styleClass=\"spatial-detached-dialog\">\n  <div [id]=\"detachedDiv\" class=\"sx-detached-plot\"\n       [class.sx-plot-fixed]=\"hasFixedHeight\"></div>\n  <ng-container *ngTemplateOutlet=\"hints\"></ng-container>\n</p-dialog>\n", styles: [":host ::ng-deep .spatial-charts-dialog .p-dialog-content{padding:.75rem 1rem 1rem}.sx-empty{padding:.5rem 0;font-size:.85rem;color:var(--text-color-secondary, #6c757d);line-height:1.4}.sx-body{display:flex;flex-direction:column;gap:.6rem}.sx-head{display:flex;align-items:center;gap:.5rem;padding-bottom:.4rem;border-bottom:1px solid var(--surface-border, #dee2e6)}.sx-subject{font-weight:600;font-size:.9rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sx-muted{font-weight:400;color:var(--text-color-secondary, #6c757d)}.sx-badge{margin-left:auto;padding:.1rem .4rem;border-radius:10px;font-size:.7rem;font-variant-numeric:tabular-nums;background:var(--surface-hover, rgba(213, 94, 0, .12));color:#a8480a;white-space:nowrap}.sx-busy{font-size:.8rem;color:var(--text-color-secondary, #6c757d)}.sx-controls{display:flex;align-items:center;gap:.5rem;flex-wrap:wrap}.sx-controls p-dropdown{flex:1 1 8rem;min-width:0}:host ::ng-deep .sx-controls p-dropdown .p-dropdown{width:100%}:host ::ng-deep .sx-kind .p-button{padding:.25rem .6rem;font-size:.78rem}.sx-plot{width:100%;min-height:15rem;flex:1}.sx-hint{font-size:.75rem;color:var(--text-color-secondary, #6c757d);line-height:1.35}.sx-detached{flex:1;min-height:6rem;display:flex;align-items:center;justify-content:center;font-size:.78rem;color:var(--text-color-secondary, #6c757d)}.sx-detached-plot{flex:1;width:100%;min-height:0;overflow:hidden}.sx-detached-plot.sx-plot-fixed{flex:0 0 auto;min-height:auto;overflow:visible}.sx-help{margin-left:auto;align-self:center;font-size:.95rem;color:var(--text-color-secondary, #6c757d);cursor:help}.sx-help:hover,.sx-help:focus-visible{color:var(--primary-color, #3b82f6)}.sx-compute{display:flex;flex-direction:column;gap:.3rem;padding:.5rem 0}.sx-warn{color:var(--orange-600, #c2410c)}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i3.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "style", "styleClass", "badgeClass", "ariaLabel", "autofocus"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "directive", type: i4.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "component", type: i5.Dropdown, selector: "p-dropdown", inputs: ["id", "scrollHeight", "filter", "name", "style", "panelStyle", "styleClass", "panelStyleClass", "readonly", "required", "editable", "appendTo", "tabindex", "placeholder", "loadingIcon", "filterPlaceholder", "filterLocale", "variant", "inputId", "dataKey", "filterBy", "filterFields", "autofocus", "resetFilterOnHide", "checkmark", "dropdownIcon", "loading", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "autoDisplayFirst", "group", "showClear", "emptyFilterMessage", "emptyMessage", "lazy", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "ariaLabel", "ariaLabelledBy", "filterMatchMode", "maxlength", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "focusOnHover", "selectOnFocus", "autoOptionFocus", "autofocusFilter", "autoShowPanelOnPrintableCharacterKeyDown", "disabled", "itemSize", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "filterValue", "options"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onShow", "onHide", "onClear", "onLazyLoad"] }, { kind: "component", type: i6.Dialog, selector: "p-dialog", inputs: ["header", "draggable", "resizable", "positionLeft", "positionTop", "contentStyle", "contentStyleClass", "modal", "closeOnEscape", "dismissableMask", "rtl", "closable", "responsive", "appendTo", "breakpoints", "styleClass", "maskStyleClass", "maskStyle", "showHeader", "breakpoint", "blockScroll", "autoZIndex", "baseZIndex", "minX", "minY", "focusOnShow", "maximizable", "keepInViewport", "focusTrap", "transitionOptions", "closeIcon", "closeAriaLabel", "closeTabindex", "minimizeIcon", "maximizeIcon", "visible", "style", "position"], outputs: ["onShow", "onHide", "visibleChange", "onResizeInit", "onResizeEnd", "onDragEnd", "onMaximize"] }, { kind: "component", type: i7.ProgressBar, selector: "p-progressBar", inputs: ["value", "showValue", "styleClass", "style", "unit", "mode", "color"] }, { kind: "component", type: i8.Checkbox, selector: "p-checkbox", inputs: ["value", "name", "disabled", "binary", "label", "ariaLabelledBy", "ariaLabel", "tabindex", "inputId", "style", "styleClass", "labelStyleClass", "formControl", "checkboxIcon", "readonly", "required", "autofocus", "trueValue", "falseValue", "variant"], outputs: ["onChange", "onFocus", "onBlur"] }, { kind: "component", type: i9.MultiSelect, selector: "p-multiSelect", inputs: ["id", "ariaLabel", "style", "styleClass", "panelStyle", "panelStyleClass", "inputId", "disabled", "readonly", "group", "filter", "filterPlaceHolder", "filterLocale", "overlayVisible", "tabindex", "variant", "appendTo", "dataKey", "name", "ariaLabelledBy", "displaySelectedLabel", "maxSelectedLabels", "selectionLimit", "selectedItemsLabel", "showToggleAll", "emptyFilterMessage", "emptyMessage", "resetFilterOnHide", "dropdownIcon", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "showHeader", "filterBy", "scrollHeight", "lazy", "virtualScroll", "loading", "virtualScrollItemSize", "loadingIcon", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "filterMatchMode", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "autofocusFilter", "display", "autocomplete", "showClear", "autofocus", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "defaultLabel", "placeholder", "options", "filterValue", "itemSize", "selectAll", "focusOnHover", "filterFields", "selectOnFocus", "autoOptionFocus"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onClear", "onPanelShow", "onPanelHide", "onLazyLoad", "onRemove", "onSelectAllChange"] }, { kind: "component", type: i10.SelectButton, selector: "p-selectButton", inputs: ["options", "optionLabel", "optionValue", "optionDisabled", "unselectable", "tabindex", "multiple", "allowEmpty", "style", "styleClass", "ariaLabelledBy", "disabled", "dataKey", "autofocus"], outputs: ["onOptionClick", "onChange"] }, { kind: "pipe", type: i1.DecimalPipe, name: "number" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SpatialChartsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'spatial-charts', template: "<div class=\"sx-body\" *ngIf=\"controls\">\n\n  <!-- The chart follows whatever the map is coloured by, so the two can never\n       disagree about what is being shown. -->\n  <div class=\"sx-head\">\n    <span class=\"sx-subject\" *ngIf=\"subject\">{{ subject }}</span>\n    <span class=\"sx-subject sx-muted\" *ngIf=\"!subject\">nothing selected to chart</span>\n    <span class=\"sx-badge\" *ngIf=\"selectionCount\">\n      {{ selectionCount | number }} selected\n    </span>\n    <i class=\"pi pi-spin pi-spinner sx-busy\" *ngIf=\"busy\" aria-label=\"loading\"></i>\n  </div>\n\n  <div class=\"sx-controls\">\n    <p-selectButton [options]=\"kindOptions\" optionLabel=\"label\" optionValue=\"value\"\n                    [ngModel]=\"kind\" (ngModelChange)=\"onKind($event)\"\n                    styleClass=\"sx-kind\"></p-selectButton>\n    <p-dropdown [options]=\"groupOptions\" optionLabel=\"label\" optionValue=\"value\"\n                [ngModel]=\"groupBy\" (ngModelChange)=\"onGroupBy($event)\"\n                placeholder=\"No grouping\" appendTo=\"body\"\n                [disabled]=\"kind === 'histogram'\"\n                [pTooltip]=\"kind === 'heatmap'\n                  ? 'The categorical column the heatmap\\'s columns come from'\n                  : 'Split a violin or box by a categorical column'\"\n                tooltipPosition=\"top\"></p-dropdown>\n    <!-- What the chart on screen shows, and what it must NOT be read for. Each of these\n         answers a different question and two are routinely over-read, so the caveat\n         travels with the explanation. -->\n    <i class=\"pi pi-question-circle sx-help\"\n       [pTooltip]=\"kindHelp\" [escape]=\"false\" tooltipPosition=\"left\"\n       tooltipStyleClass=\"sx-help-tip\"\n       [attr.aria-label]=\"'About the ' + kind + ' chart'\" tabindex=\"0\"></i>\n  </div>\n\n  <!-- The heatmap's rows are a gene LIST, so it needs its own picker: the other\n       kinds chart whatever single source the map is coloured by. -->\n  <div class=\"sx-controls\" *ngIf=\"kind === 'heatmap'\">\n    <p-multiSelect [options]=\"geneOptions\" optionLabel=\"label\" optionValue=\"value\"\n                   [ngModel]=\"heatmapGenes\" (ngModelChange)=\"onHeatmapGenes($event)\"\n                   [filter]=\"true\" filterBy=\"label\" (onFilter)=\"onGeneFilter($event.filter)\"\n                   [virtualScroll]=\"true\" [virtualScrollItemSize]=\"30\" appendTo=\"body\"\n                   [showToggleAll]=\"false\" [maxSelectedLabels]=\"3\"\n                   selectedItemsLabel=\"{0} genes\"\n                   placeholder=\"Pick genes for the rows\"\n                   pTooltip=\"One row per gene, averaged within each group\"\n                   tooltipPosition=\"top\" styleClass=\"sx-genes\"></p-multiSelect>\n    <p-checkbox [binary]=\"true\" [ngModel]=\"heatmapZScore\"\n                (onChange)=\"onHeatmapZScore($event.checked)\"\n                label=\"z-score\"\n                pTooltip=\"Scale each gene across the groups. Without it one highly-expressed gene saturates the colour scale and the rest reads as blank\"\n                tooltipPosition=\"top\"></p-checkbox>\n  </div>\n\n  <!-- Detach applies to EVERY kind: the dialog is only so wide, and a counts plot read\n       against a heatmap is the same argument as a UMAP read against the map. -->\n  <div class=\"sx-controls\">\n    <!-- A picker only when the dataset publishes more than one embedding. -->\n    <p-dropdown *ngIf=\"kind === 'embedding' && embeddings.length > 1\"\n                [options]=\"embeddings\" optionLabel=\"label\" optionValue=\"name\"\n                [ngModel]=\"embedding?.name\" (ngModelChange)=\"onEmbedding($event)\"\n                appendTo=\"body\"\n                pTooltip=\"Which embedding to draw\" tooltipPosition=\"top\"></p-dropdown>\n    <!-- Offered only for an embedding this dataset does not publish. It runs in a Web\n         Worker on the GPU, so the panel stays usable while it goes. -->\n    <p-button *ngIf=\"kind === 'embedding' && isComputable && !isComputed && !isComputing\"\n              icon=\"pi pi-play\" size=\"small\" [text]=\"true\"\n              [label]=\"'Compute (' + computeEstimateLabel + ')'\"\n              pTooltip=\"Run t-SNE here, in a background worker on the GPU, from this dataset's PCA. The panel stays usable, and it can be cancelled.\"\n              tooltipPosition=\"top\"\n              (onClick)=\"computeEmbedding()\"></p-button>\n    <p-button *ngIf=\"isComputing\"\n              icon=\"pi pi-times\" size=\"small\" [text]=\"true\" severity=\"secondary\"\n              label=\"Cancel\" (onClick)=\"cancelCompute()\"></p-button>\n    <p-button [icon]=\"detached ? 'pi pi-window-minimize' : 'pi pi-external-link'\"\n              size=\"small\" [text]=\"true\"\n              [label]=\"detached ? 'Put back' : 'Detach'\"\n              [pTooltip]=\"detached\n                ? 'Show this chart in the panel again'\n                : 'Open this chart in its own window, alongside this panel'\"\n              tooltipPosition=\"top\"\n              (onClick)=\"toggleDetached()\"></p-button>\n  </div>\n\n  <!-- Progress while a computation runs. `mode=\"indeterminate\"` until the first report,\n       because the run starts with a neighbour graph and there is nothing honest to show\n       as a percentage yet. -->\n  <div class=\"sx-compute\" *ngIf=\"isComputing\">\n    <p-progressBar\n      [mode]=\"computeFraction === null ? 'indeterminate' : 'determinate'\"\n      [value]=\"computeFraction === null ? 0 : (computeFraction * 100)\"\n      [showValue]=\"computeFraction !== null\"\n      [style]=\"{ height: '0.6rem' }\"></p-progressBar>\n    <small class=\"sx-hint\">\n      {{ computeFraction === null ? 'Building the neighbour graph\u2026' : 'Optimising\u2026' }}\n      <ng-container *ngIf=\"computeBackend\"> on {{ computeBackend }}</ng-container>\n    </small>\n    <small class=\"sx-hint sx-warn\" *ngIf=\"computeMessage\">{{ computeMessage }}</small>\n  </div>\n  <small class=\"sx-hint sx-warn\" *ngIf=\"computeError\">{{ computeError }}</small>\n  <!-- Withheld rather than offered with a warning: an hour-long job is not a choice a\n       reader can meaningfully consent to from a dialog. -->\n  <small class=\"sx-hint\" *ngIf=\"kind === 'embedding' && tsneTooLarge\">{{ tsneTooLargeNote }}</small>\n\n  <div [id]=\"chartDiv\" class=\"sx-plot\" *ngIf=\"!detached\"></div>\n\n  <!-- Detached: the chart keeps drawing, in its own window. Says so rather than\n       leaving a blank panel that looks broken. -->\n  <div class=\"sx-detached\" *ngIf=\"detached\">\n    Shown in its own window.\n  </div>\n\n  <ng-container *ngTemplateOutlet=\"hints\"></ng-container>\n\n</div>\n\n<!-- Declared once and rendered in both the panel and the detached window: the ladder is\n     deliberately not mutually exclusive (a heatmap still needs its grouping prompt), so\n     collapsing it to a single expression would drop a hint rather than move it. -->\n<ng-template #hints>\n  <small class=\"sx-hint\" *ngIf=\"notice\">{{ notice }}</small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && suggestsGrouping\">\n    Pick a grouping to compare categories.\n  </small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && selectionCount && kind === 'histogram'\">\n    The selection is overlaid on the full distribution.\n  </small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && selectionCount && kind !== 'histogram' && kind !== 'heatmap'\">\n    Showing the selection only.\n  </small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && kind === 'heatmap'\">{{ heatmapNote }}</small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && kind === 'embedding'\">{{ embeddingNote }}</small>\n</ng-template>\n\n<!-- The detached chart. Its own non-modal, draggable, resizable window so it can be put\n     beside the spatial-omics dialog. `appendTo=\"body\"` keeps it out of the dialog's\n     stacking context, or it would be clipped by the panel it is meant to sit next to. -->\n<p-dialog *ngIf=\"detached\"\n          [header]=\"detachedTitle\"\n          [visible]=\"true\" (visibleChange)=\"toggleDetached()\"\n          [modal]=\"false\" [resizable]=\"true\" [draggable]=\"true\"\n          position=\"right\" appendTo=\"body\"\n          (onShow)=\"onDetachedWindowShown()\"\n          (onResizeEnd)=\"onDetachedResizeEnd()\"\n          [style]=\"{ width: '34rem', height: '30rem' }\"\n          [contentStyle]=\"{\n            display: 'flex', flexDirection: 'column', gap: '0.25rem',\n            padding: '0.4rem 0.6rem 0.5rem', flex: '1 1 auto', minHeight: '0',\n            overflow: 'auto'\n          }\"\n          styleClass=\"spatial-detached-dialog\">\n  <div [id]=\"detachedDiv\" class=\"sx-detached-plot\"\n       [class.sx-plot-fixed]=\"hasFixedHeight\"></div>\n  <ng-container *ngTemplateOutlet=\"hints\"></ng-container>\n</p-dialog>\n", styles: [":host ::ng-deep .spatial-charts-dialog .p-dialog-content{padding:.75rem 1rem 1rem}.sx-empty{padding:.5rem 0;font-size:.85rem;color:var(--text-color-secondary, #6c757d);line-height:1.4}.sx-body{display:flex;flex-direction:column;gap:.6rem}.sx-head{display:flex;align-items:center;gap:.5rem;padding-bottom:.4rem;border-bottom:1px solid var(--surface-border, #dee2e6)}.sx-subject{font-weight:600;font-size:.9rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sx-muted{font-weight:400;color:var(--text-color-secondary, #6c757d)}.sx-badge{margin-left:auto;padding:.1rem .4rem;border-radius:10px;font-size:.7rem;font-variant-numeric:tabular-nums;background:var(--surface-hover, rgba(213, 94, 0, .12));color:#a8480a;white-space:nowrap}.sx-busy{font-size:.8rem;color:var(--text-color-secondary, #6c757d)}.sx-controls{display:flex;align-items:center;gap:.5rem;flex-wrap:wrap}.sx-controls p-dropdown{flex:1 1 8rem;min-width:0}:host ::ng-deep .sx-controls p-dropdown .p-dropdown{width:100%}:host ::ng-deep .sx-kind .p-button{padding:.25rem .6rem;font-size:.78rem}.sx-plot{width:100%;min-height:15rem;flex:1}.sx-hint{font-size:.75rem;color:var(--text-color-secondary, #6c757d);line-height:1.35}.sx-detached{flex:1;min-height:6rem;display:flex;align-items:center;justify-content:center;font-size:.78rem;color:var(--text-color-secondary, #6c757d)}.sx-detached-plot{flex:1;width:100%;min-height:0;overflow:hidden}.sx-detached-plot.sx-plot-fixed{flex:0 0 auto;min-height:auto;overflow:visible}.sx-help{margin-left:auto;align-self:center;font-size:.95rem;color:var(--text-color-secondary, #6c757d);cursor:help}.sx-help:hover,.sx-help:focus-visible{color:var(--primary-color, #3b82f6)}.sx-compute{display:flex;flex-direction:column;gap:.3rem;padding:.5rem 0}.sx-warn{color:var(--orange-600, #c2410c)}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VISUALIZER]
+                }] }], propDecorators: { active: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-charts.component.js","sourceRoot":"","sources":["../../../../../src/lib/spatial-controls/spatial-charts/spatial-charts.component.ts","../../../../../src/lib/spatial-controls/spatial-charts/spatial-charts.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit, Component, Inject, Input, OnDestroy, OnInit,\n} from '@angular/core';\nimport { Subscription, combineLatest } from 'rxjs';\nimport * as Plotly from 'plotly.js-dist-min';\n\nimport { VISUALIZER, IVisualizer, ISpatialControls } from '../../contracts/visualizer.contract';\nimport {\n  SpatialEmbedding,\n  SpatialEmbeddingMeta,\n} from '../../contracts/spatial-dataset.contract';\nimport { SpatialColorBy, SpatialViewState, DEFAULT_SPATIAL_VIEW } from '../../contracts/display-types';\nimport {\n  SpatialSelectionMask, emptySelection, maskToIndices,\n} from '../../spatial/spatial-selection';\nimport { cellsAsGroups, heatmapMatrix } from '../../spatial/spatial-heatmap';\nimport { geneOptionsFor } from '../../spatial/gene-search';\nimport { ComputeProgress, EmbeddingComputeRun } from '../../spatial/embedding-compute';\nimport {\n  OmicsChartKind, OmicsGrouping, benefitsFromGrouping, buildCountTraces, buildHeatmapTraces,\n  buildOmicsTraces, buildEmbeddingTraces, countsLayout, heatmapLayout, omicsLayout, embeddingLayout,\n} from '../../implementations/plotly/omics-trace-builders';\n\n/**\n * Widen the help tooltip, once per document.\n *\n * PrimeNG caps `.p-tooltip` at 12.5rem and appends it to `<body>`, so a component\n * stylesheet cannot reach it — the same reason the detached dialog is sized inline. At\n * 200 px the chart explanations render as a tall thread of two-word lines, which is worse\n * than not showing them. The library ships no global stylesheet to put this in, so one\n * rule is injected instead: scoped to this component's own tooltip class, idempotent, and\n * skipped where there is no document.\n */\nconst HELP_TIP_STYLE_ID = 'sx-help-tip-style';\nfunction ensureHelpTipStyle(): void {\n  if (typeof document === 'undefined') return;\n  if (document.getElementById(HELP_TIP_STYLE_ID)) return;\n  const style = document.createElement('style');\n  style.id = HELP_TIP_STYLE_ID;\n  style.textContent = '.sx-help-tip .p-tooltip-text { max-width: none; width: 24rem; '\n    + 'line-height: 1.45; }\\n.sx-help-tip { max-width: none; }';\n  document.head.appendChild(style);\n}\n\n/** Per-instance chart-div id source — see {@link SpatialChartsComponent.chartDiv}. */\nlet chartInstanceSeq = 0;\n\n\n/** Plotly config: a static-ish analysis chart, not an editable figure. */\nconst CHART_CONFIG = {\n  displaylogo: false,\n  responsive: true,\n  modeBarButtonsToRemove: ['lasso2d', 'select2d', 'autoScale2d'],\n};\n\n/**\n * Config for the embedding, which unlike the distributions is a plot you SELECT in.\n *\n * The lasso and box-select are kept — drawing round a cluster is how a population gets\n * picked out of a UMAP — and the wheel zooms, because exploring an embedding means\n * zooming into a cluster and reaching for a toolbar button to do it breaks that.\n */\nconst EMBEDDING_CONFIG = {\n  displaylogo: false,\n  responsive: true,\n  scrollZoom: true,\n  modeBarButtonsToRemove: ['autoScale2d'],\n};\n\n/**\n * Distribution charts over the spatial-omics values — histogram, violin, box —\n * **linked to the map**: they chart whatever the map is coloured by, and narrow\n * to the current selection.\n *\n * Embedded INSIDE `<spatial-controls>` rather than owning a dialog of its own:\n * the two are one workflow (change the colour source, watch the distribution\n * move), and splitting them across two floating windows made the link harder to\n * see, not easier. It stays a separate component so the pure trace builders and\n * its own tests keep their boundary.\n *\n * Charting the active colour source rather than offering its own value picker is\n * deliberate: it keeps one source of truth, so what you see on the map and what\n * you see in the chart cannot disagree, and it makes the link legible without\n * explaining it.\n *\n * Depends only on {@link ISpatialControls} through the `VISUALIZER` contract\n * token, like `SpatialControlsComponent`. Trace building lives in the pure\n * `omics-trace-builders`; this component only moves data and owns the div.\n */\n@Component({\n  selector: 'spatial-charts',\n  templateUrl: './spatial-charts.component.html',\n  styleUrls: ['./spatial-charts.component.scss'],\n})\nexport class SpatialChartsComponent implements OnInit, AfterViewInit, OnDestroy {\n  /**\n   * Whether the host panel is on screen. The chart only draws when it is: the\n   * enclosing dialog creates and destroys its content, so without this the\n   * component would mount with a div present but no state change to trigger a\n   * first draw.\n   */\n  @Input() set active(on: boolean) {\n    const was = this.isActive;\n    this.isActive = on;\n    // Deferred by a task: when a collapsed section expands, the host is still\n    // `hidden` at the moment this setter runs, so plotting now would size the\n    // chart to a zero-height div.\n    if (on && !was) setTimeout(() => void this.reload(), 0);\n    else if (on) void this.reload();\n  }\n  get active(): boolean {\n    return this.isActive;\n  }\n  private isActive = true;\n\n  /** Per-instance, for the same reason the visualizer's plot div is\n   *  (`visualizer.component.ts`): two mounted charts sharing one DOM id means\n   *  `getElementById` hands both of them the first element, so one instance draws\n   *  into — or purges — the other's canvas. */\n  /** One increment per INSTANCE — a static initializer would run once per class and\n   *  hand every instance the same id, which is the bug this id exists to avoid. Declared\n   *  before the ids because field initializers run in order. */\n  private readonly seq = ++chartInstanceSeq;\n  readonly chartDiv = `spatial-charts-plot-${this.seq}`;\n  /**\n   * The div inside the detached window.\n   *\n   * A separate id rather than moving the existing div: Angular destroys and recreates a\n   * div across an `*ngIf`, so Plotly would be left holding a detached node. Two divs and\n   * a redraw is both simpler and correct.\n   *\n   * ONE is enough for every kind, because only the active kind is ever plotted. Detaching\n   * is remembered per kind, but at most one window is open at a time.\n   */\n  readonly detachedDiv = `spatial-charts-detached-${this.seq}`;\n\n  /**\n   * Whether the chart is shown in its own window rather than inline.\n   *\n   * Detached, it sits ALONGSIDE the spatial-omics dialog instead of inside it — which is\n   * the point: these are read against the map, not instead of it. The dialog is only so\n   * wide.\n   *\n   * One flag for the PANEL, not one per kind. Where the window is, is a property of the\n   * workspace someone has arranged, not of the tab they happen to be on: having put the\n   * charts beside the map, switching from the heatmap to the counts should swap what the\n   * window shows, not yank it back into the dialog and make them detach it again.\n   */\n  detached = false;\n  private static readonly CONTINUOUS_KINDS: { label: string; value: OmicsChartKind }[] = [\n    { label: 'Histogram', value: 'histogram' },\n    { label: 'Violin', value: 'violin' },\n    { label: 'Box', value: 'box' },\n  ];\n  private static readonly CATEGORICAL_KINDS: { label: string; value: OmicsChartKind }[] = [\n    { label: 'Counts', value: 'counts' },\n  ];\n\n  /** Available whatever the map is coloured by: the heatmap's subject is a GENE\n   *  LIST crossed with a grouping, not the active colour source. */\n  private static readonly ALWAYS_KINDS: { label: string; value: OmicsChartKind }[] = [\n    { label: 'Heatmap', value: 'heatmap' },\n  ];\n\n  /**\n   * A t-SNE the dataset does not publish, offered so it can be computed here.\n   *\n   * A dropped-in `.h5ad` typically carries one UMAP and a PCA, and no t-SNE — the two\n   * views answer different questions, so having only one is a real gap. Computing it\n   * needs no expression data: t-SNE runs on the PCA scores, which is why this can happen\n   * in the browser at all while PCA cannot.\n   */\n  private static readonly COMPUTABLE: SpatialEmbeddingMeta[] = [\n    { name: 'local:tsne', label: 't-SNE (compute)', dims: 2, derived: true },\n    { name: 'local:tsne3d', label: 't-SNE 3D (compute)', dims: 3, derived: true },\n  ];\n\n  /** The menu suffix that says a click will start work; not part of the name. */\n  private static readonly COMPUTE_SUFFIX = ' (compute)';\n\n  /**\n   * Largest dataset this will offer to embed in the browser.\n   *\n   * t-SNE is O(N²) per iteration — vectorised on the GPU, but not approximated — so the\n   * cost is quadratic in observations. Measured end to end in Firefox on WebGPU: 2,688\n   * points took 95 s. That scales to roughly five and a half minutes at this threshold,\n   * and to about 76 minutes at seqFISH's 19,416, which was also measured offline.\n   *\n   * Past this the option is WITHDRAWN rather than offered with a warning. An hour-long\n   * job started from a button is not a choice a reader can meaningfully consent to in a\n   * dialog, and a t-SNE that large belongs in the offline pipeline, where it can run\n   * once and be served to everyone.\n   */\n  static readonly BROWSER_TSNE_MAX_OBSERVATIONS = 5000;\n\n  /** Measured anchor for the estimate: seconds for 2,688 points on WebGPU. */\n  private static readonly TSNE_SECONDS_AT = { seconds: 95, observations: 2688 };\n\n  /** Coordinates computed in this browser, by name. Not persisted: a reload recomputes. */\n  private readonly computed = new Map<string, SpatialEmbedding>();\n\n  /** The live run, when one is going. */\n  private computeRun: EmbeddingComputeRun | null = null;\n\n  /**\n   * Bumped by every dataset change and by teardown, so a computation in progress can tell\n   * that what it is computing is no longer what is on screen.\n   *\n   * A run is several awaits long — the PCA scores arrive over HTTP, then the worker takes\n   * a minute or more — and the dataset can change at any of them, including BEFORE\n   * `computeRun` exists to be terminated. Without a token, the scores fetched for one\n   * dataset get embedded and drawn over another's observations: a plot of two datasets at\n   * once, which reads as a strange-looking t-SNE rather than as a bug.\n   */\n  private computeToken = 0;\n\n  /** 0..1 while running, or null before the first report. Drives the progress bar. */\n  computeFraction: number | null = null;\n\n  /** Which backend the worker got — 'webgpu', 'wasm' or 'cpu'. Shown while running. */\n  computeBackend: string | null = null;\n\n  computeMessage: string | null = null;\n\n  computeError: string | null = null;\n\n  /** True when a t-SNE is missing but the dataset is too big to embed here. */\n  tsneTooLarge = false;\n\n  /** Observations in the live dataset, kept for the cost estimate. */\n  private observationCount = 0;\n\n  /** Offered only when the dataset publishes an embedding to draw. */\n  // Labelled for what it is rather than for one instance of it: this view draws whatever\n  // embedding the dataset publishes — a UMAP, a PCA, a t-SNE — and calling the tab \"UMAP\"\n  // while it showed a PCA would be a lie the picker beneath it immediately contradicts.\n  private static readonly EMBEDDING_KINDS: { label: string; value: OmicsChartKind }[] = [\n    { label: 'Embedding', value: 'embedding' },\n  ];\n\n  /** The kinds the ACTIVE subject can be drawn as. A category code is a label,\n   *  not a magnitude, so a histogram of it would be meaningless — what a\n   *  categorical column has is a frequency distribution. */\n  get kindOptions(): { label: string; value: OmicsChartKind }[] {\n    return [\n      ...(this.categorical\n        ? SpatialChartsComponent.CATEGORICAL_KINDS\n        : SpatialChartsComponent.CONTINUOUS_KINDS),\n      ...SpatialChartsComponent.ALWAYS_KINDS,\n      // An embedding is a property of the DATASET, not of the active colour source, so\n      // it is offered whenever one is published and never otherwise — a tab that draws\n      // nothing is worse than an absent one.\n      ...(this.embeddings.length > 0 ? SpatialChartsComponent.EMBEDDING_KINDS : []),\n    ];\n  }\n\n  controls: ISpatialControls | null = null;\n  kind: OmicsChartKind = 'histogram';\n  /** Embeddings the dataset publishes, and which of them is drawn. */\n  embeddings: SpatialEmbeddingMeta[] = [];\n  embedding: SpatialEmbeddingMeta | null = null;\n  private embeddingCoords: SpatialEmbedding | null = null;\n  /** The categorical colouring behind the embedding's colours, kept so a redraw for a\n   *  selection change does not refetch the column. */\n  private embeddingCodes: { codes: Uint16Array; names: string[]; colors: string[] } | null = null;\n  /**\n   * Genes the heatmap's rows are, and the vectors behind them.\n   *\n   * Local rather than in `SpatialViewState`, matching how the chart KIND is\n   * held: this is what the panel is charting, not what the map is drawing, and\n   * the renderer has no use for it.\n   */\n  heatmapGenes: string[] = [];\n  /** Z-score each gene across the groups. On by default: without it one loud\n   *  gene saturates the scale and the rest of the panel reads as blank. */\n  heatmapZScore = true;\n  /** Past this many selected cells the per-cell view is a texture, not a\n   *  readable panel, so the columns go back to being classes. */\n  private static readonly HEATMAP_CELL_COLUMNS = 200;\n  /**\n   * Column cap for the grouped heatmap.\n   *\n   * Any categorical column can be the x axis, and they are not the same size:\n   * `neurotransmitter` has 9 categories, `class` 34, `subclass` 338. At 338 the\n   * panel is a texture — columns a couple of pixels wide, no readable label —\n   * so past this many the strongest columns are kept and the note says how many\n   * were dropped. See `maxCols` in `spatial-heatmap.ts`.\n   */\n  private static readonly HEATMAP_MAX_COLUMNS = 40;\n  /** Columns the cap dropped from the last render, for the note. */\n  private heatmapHidden = 0;\n  geneOptions: { label: string; value: string }[] = [];\n  /** Every gene the dataset inlined. `geneOptions` is only ever the best few hundred of\n   *  these — see `gene-search.ts` for why a whole-transcriptome list cannot be handed to\n   *  the control whole. */\n  private geneNames: string[] = [];\n  /** What is typed in the picker's filter box, so the options can be rebuilt when the\n   *  selection changes without losing the query. */\n  private geneQuery = '';\n  /** Fetched vectors by gene name, so adding a fourth gene does not refetch the\n   *  first three — each is a full per-observation Float32Array. */\n  private readonly geneCache = new Map<string, Float32Array>();\n  /** Categorical column the violin/box splits by; null = one trace for all. */\n  groupBy: string | null = null;\n  groupOptions: { label: string; value: string | null }[] = [];\n\n  /** What the map is coloured by — the chart's subject. */\n  colorBy: SpatialColorBy | null = null;\n  selectionCount = 0;\n  /** Set when the active colour source cannot be charted, for an inline hint. */\n  notice: string | null = null;\n  busy = false;\n\n  private view: SpatialViewState = { ...DEFAULT_SPATIAL_VIEW };\n  private selection: SpatialSelectionMask = emptySelection();\n  private values: Float32Array | null = null;\n  /** Set instead of `values` when the colour source is a categorical column: its\n   *  distribution is counts per category, not a histogram of its codes. */\n  private categorical: OmicsGrouping | null = null;\n  private grouping: OmicsGrouping | null = null;\n  /** Guards the async value fetch: a fast colour-source change can resolve out\n   *  of order, and a stale vector would be charted against the new label. */\n  private token = 0;\n  /** The same guard for the grouping fetch, which the user can change as fast. */\n  private groupToken = 0;\n  /** Whether the first view emission has been handled. */\n  private primed = false;\n  private readonly subs = new Subscription();\n\n  constructor(@Inject(VISUALIZER) private readonly viz: IVisualizer) {}\n\n  ngOnInit(): void {\n    // Before the port check: the help icon is in the template either way, and a panel\n    // with no data source is exactly where someone reads it.\n    ensureHelpTipStyle();\n    this.controls = this.viz.getSpatialControls?.() ?? null;\n    if (!this.controls) return;\n\n    this.subs.add(combineLatest([\n      this.controls.getViewState$(), this.controls.getSelection$(),\n    ]).subscribe(([view, selection]) => {\n      const sourceChanged = view.colorBy?.kind !== this.view.colorBy?.kind\n        || view.colorBy?.name !== this.view.colorBy?.name;\n      this.view = view;\n      this.colorBy = view.colorBy;\n      this.selection = selection;\n      this.selectionCount = selection.count;\n      // A selection or log change only needs a re-render; a new colour source\n      // needs its vector fetched first. The FIRST emission always reloads:\n      // otherwise `null -> null` reads as \"unchanged\" and the component sits\n      // with no data and no explanation until something else moves.\n      if (!this.primed || sourceChanged) {\n        this.primed = true;\n        void this.reload();\n      } else {\n        // A selection or log-scale change needs only a redraw of the same vector.\n        void this.render();\n      }\n    }));\n\n    this.subs.add(this.controls.getDataset$().subscribe((dataset) => {\n      this.groupOptions = [\n        { label: 'No grouping', value: null },\n        ...(this.controls?.categoricalColumns() ?? []).map((n) => ({ label: n, value: n })),\n      ];\n      // A new dataset's columns are different; a carried-over group is meaningless.\n      if (this.groupBy && !this.groupOptions.some((o) => o.value === this.groupBy)) {\n        this.groupBy = null;\n        this.grouping = null;\n      }\n      // The heatmap's rows come from the dataset's gene list. A dataset too wide\n      // to inline its names offers none here — the panel's typeahead is the way\n      // in for those, and the heatmap needs names it can list.\n      this.geneNames = [...(dataset?.features?.names ?? [])];\n      this.geneQuery = '';\n      // Validated against the WHOLE list, not the visible options: those are capped, and\n      // filtering the selection by them would drop genes the dataset still has.\n      const known = new Set(this.geneNames);\n      this.heatmapGenes = this.heatmapGenes.filter((n) => known.has(n));\n      this.refreshGeneOptions();\n      this.geneCache.clear();\n\n      // Embeddings belong to the dataset, so they are re-read with it and the loaded\n      // coordinates dropped: a UMAP from the previous dataset over these observations\n      // would be a plot of two different things at once.\n      this.computed.clear();\n      this.abandonCompute();\n      const published = dataset?.embeddings ? [...dataset.embeddings] : [];\n      // Offer to compute a t-SNE only where the dataset has PCA to embed and no t-SNE of\n      // its own — otherwise the menu advertises work that cannot start, or duplicates\n      // what is already served.\n      const hasPca = published.some((e) => /pca/i.test(e.label ?? e.name));\n      const hasTsne = published.some((e) => /tsne|t-sne/i.test(e.label ?? e.name));\n      this.observationCount = dataset?.observations.count ?? 0;\n      this.tsneTooLarge = hasPca && !hasTsne\n        && this.observationCount > SpatialChartsComponent.BROWSER_TSNE_MAX_OBSERVATIONS;\n      this.embeddings = hasPca && !hasTsne && !this.tsneTooLarge\n        ? [...published, ...SpatialChartsComponent.COMPUTABLE]\n        : published;\n      this.embedding = this.embeddings[0] ?? null;\n      this.embeddingCoords = null;\n      this.embeddingCodes = null;\n      // Nothing to draw for the kind that was selected; fall back rather than sit blank.\n      if (this.kind === 'embedding' && this.embeddings.length === 0) this.kind = 'histogram';\n    }));\n  }\n\n  /**\n   * The height the drawn layout asked for, or null where it autosizes.\n   *\n   * {@link resize} needs this: the counts and heatmap layouts size their height\n   * to their content — one band per bar, per gene row — while the distribution\n   * kinds want to fill whatever height they are given.\n   */\n  private drawnHeight: number | null = null;\n\n  /**\n   * Re-fit the plot to the panel's current width.\n   *\n   * Called by the host when the dialog finishes resizing. Plotly does not notice\n   * a container resize on its own — its `responsive` option listens for WINDOW\n   * resizes only, so dragging a dialog edge reaches it through nothing at all.\n   */\n  resize(): void {\n    this.refit(this.chartDiv);\n  }\n\n  /**\n   * Re-fit whatever is plotted in `div` to its container.\n   *\n   * Shared by the panel and the detached window because the rule is the same and getting\n   * it wrong is invisible until it is not: `autosize` takes BOTH dimensions from the\n   * container, which is right only where the layout did not fix its own height. Measured:\n   * autosizing a layout with an explicit height of 500 replaced it with the container's\n   * 400. The counts and heatmap layouts size themselves to their row count, so the\n   * window resize has to set the width ALONE for them and let the height stand.\n   */\n  private refit(div: string): void {\n    const el = document.getElementById(div);\n    if (!el) return;\n    const width = Math.round(el.clientWidth);\n    // Zero while the section is collapsed or the dialog is closed; relaying out\n    // to a zero box makes Plotly compute a layout it does not recover from.\n    if (width <= 0) return;\n    try {\n      Plotly.relayout(el, this.drawnHeight === null ? { autosize: true } : { width });\n    } catch {\n      // Nothing plotted yet.\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.subs.unsubscribe();\n    // A worker outlives the component that started it: closing the panel mid-run would\n    // otherwise leave a t-SNE saturating a GPU for minutes with nothing left to receive\n    // the answer.\n    this.abandonCompute();\n    // BOTH divs: a chart left detached at teardown holds its WebGL context in the\n    // window's div, which the inline id would never reach.\n    for (const div of [this.chartDiv, this.detachedDiv]) {\n      try {\n        Plotly.purge(div);\n      } catch {\n        // The div may already be gone with the dialog; nothing to clean up.\n      }\n    }\n  }\n\n  ngAfterViewInit(): void {\n    // The div exists only now, so this is the earliest a first draw can land.\n    void this.reload();\n  }\n\n  onKind(kind: OmicsChartKind): void {\n    this.kind = kind;\n    if (kind === 'heatmap') {\n      // Seed with the gene already on screen, so the chart says something the\n      // moment it opens rather than showing an empty grid and a prompt.\n      if (this.heatmapGenes.length === 0 && this.colorBy?.kind === 'feature') {\n        this.heatmapGenes = [this.colorBy.name];\n      }\n      void (async () => {\n        await this.ensureHeatmapGrouping();\n        await this.loadHeatmapGenes();\n        void this.render();\n      })();\n      return;\n    }\n    void this.render();\n  }\n\n  /**\n   * The grouping the heatmap's columns come from, defaulting rather than\n   * demanding one: a heatmap with no columns is not a chart, and \"No grouping\"\n   * is a sensible answer for a violin but not for this.\n   */\n  private async ensureHeatmapGrouping(): Promise<void> {\n    if (this.grouping || !this.controls) return;\n    const first = this.groupOptions.find((o) => o.value)?.value;\n    if (!first) return;\n    await this.onGroupBy(first);\n  }\n\n  onHeatmapZScore(on: boolean): void {\n    this.heatmapZScore = on;\n    void this.render();\n  }\n\n  /** What the heatmap is currently showing, said plainly. */\n  get heatmapNote(): string {\n    if (this.heatmapGenes.length === 0) return 'Pick one or more genes for the rows.';\n    const perCell = this.selectionCount > 0\n      && this.selectionCount <= SpatialChartsComponent.HEATMAP_CELL_COLUMNS;\n    if (perCell) {\n      return `One column per selected cell (${this.selectionCount}). `\n        + 'Mean expression per cell, so the columns are cells rather than classes.';\n    }\n    const scope = this.selectionCount > 0 ? 'the selected cells' : 'all cells';\n    const scaled = this.heatmapZScore\n      ? ' Each gene is z-scored across the columns, so the colour is above or below that gene\\'s own average.'\n      : ' Raw means, so a highly-expressed gene dominates the scale.';\n    // Saying so matters: without it the panel looks like the whole column.\n    const capped = this.heatmapHidden > 0\n      ? ` Showing the ${SpatialChartsComponent.HEATMAP_MAX_COLUMNS} strongest of `\n        + `${SpatialChartsComponent.HEATMAP_MAX_COLUMNS + this.heatmapHidden}, `\n        + 'ranked by the largest value any picked gene reaches.'\n      : '';\n    return `Mean expression of each gene within each ${this.groupBy ?? 'group'}, over ${scope}.`\n      + `${scaled}${capped}`;\n  }\n\n  /** Gene rows for the heatmap. */\n  async onHeatmapGenes(names: string[]): Promise<void> {\n    this.heatmapGenes = names ?? [];\n    // Chosen genes must stay in the options or the control cannot label its chips.\n    this.refreshGeneOptions();\n    await this.loadHeatmapGenes();\n    void this.render();\n  }\n\n  /**\n   * Fetch any gene the heatmap needs and does not already hold.\n   *\n   * Sequenced on the same token the colour-source load uses: each vector is a\n   * separate request, and a slower one must not paint rows for a gene list the\n   * user has already moved on from.\n   */\n  private async loadHeatmapGenes(): Promise<void> {\n    const controls = this.controls;\n    if (!controls) return;\n    const missing = this.heatmapGenes.filter((n) => !this.geneCache.has(n));\n    if (missing.length === 0) return;\n    const mine = ++this.token;\n    this.busy = true;\n    try {\n      for (const name of missing) {\n        const values = await controls.continuousValues({ kind: 'feature', name });\n        if (mine !== this.token) return;\n        this.geneCache.set(name, values);\n      }\n      this.notice = null;\n    } catch (err) {\n      if (mine !== this.token) return;\n      this.notice = `A gene could not be charted: ${(err as Error)?.message ?? err}`;\n    } finally {\n      if (mine === this.token) this.busy = false;\n    }\n  }\n\n  async onGroupBy(name: string | null): Promise<void> {\n    this.groupBy = name;\n    if (!name || !this.controls) {\n      this.grouping = null;\n      void this.render();\n      return;\n    }\n    // Sequenced: pick A then B and a slower A would otherwise land last, charting\n    // A's categories under a dropdown that says B.\n    const mine = ++this.groupToken;\n    try {\n      const view = await this.controls.categoricalView(name);\n      if (mine !== this.groupToken) return;\n      this.grouping = { codes: view.codes, categories: view.categories, colors: view.colors };\n    } catch {\n      if (mine !== this.groupToken) return;\n      this.grouping = null;\n      this.groupBy = null;\n    }\n    void this.render();\n  }\n\n  /** True when the current kind would read better with a grouping chosen. */\n  get suggestsGrouping(): boolean {\n    return benefitsFromGrouping(this.kind) && !this.groupBy && this.groupOptions.length > 1;\n  }\n\n  get subject(): string {\n    if (!this.colorBy) return '';\n    return this.colorBy.kind === 'feature' ? `gene ${this.colorBy.name}` : this.colorBy.name;\n  }\n\n  // ── internals ───────────────────────────────────────────────────────────\n\n  /** Fetch the active colour source's vector, then draw. */\n  private async reload(): Promise<void> {\n    const controls = this.controls;\n    const source = this.view.colorBy;\n    const mine = ++this.token;\n    if (!controls || !source) {\n      this.values = null;\n      this.categorical = null;\n      this.notice = controls\n        ? 'Colour the map by a column or a gene to chart its distribution.'\n        : null;\n      void this.render();\n      return;\n    }\n    this.busy = true;\n    // A categorical column charts as COUNTS per category — asked for by name\n    // rather than discovered by catching the continuous fetch's error, so a\n    // genuine failure still reads as a failure.\n    const isCategorical = source.kind === 'column'\n      && (controls.categoricalColumns() ?? []).includes(source.name);\n    try {\n      if (isCategorical) {\n        const view = await controls.categoricalView(source.name);\n        if (mine !== this.token) return; // superseded\n        this.categorical = { codes: view.codes, categories: view.categories, colors: view.colors };\n        this.values = null;\n        this.kind = 'counts';\n        this.notice = null;\n      } else {\n        const values = await controls.continuousValues(source);\n        if (mine !== this.token) return;\n        this.values = values;\n        this.categorical = null;\n        if (this.kind === 'counts') this.kind = 'histogram';\n        this.notice = null;\n      }\n    } catch (err) {\n      if (mine !== this.token) return;\n      this.values = null;\n      this.categorical = null;\n      this.notice = `\"${source.name}\" could not be charted: ${(err as Error)?.message ?? err}`;\n    } finally {\n      if (mine === this.token) this.busy = false;\n    }\n    void this.render();\n  }\n\n  /**\n   * The embedding scatter — a UMAP over the same observations.\n   *\n   * Answers what the map cannot: the map says WHERE a population sits, this says which\n   * populations there are and how close they are in expression.\n   *\n   * Linked to the map without asking for anything: it reuses `this.categorical`, the same\n   * loaded colouring the counts chart draws from, so the two cannot disagree about what a\n   * colour means and no second fetch happens. A selection dims the rest rather than\n   * dropping it — the embedding's shape is the context that makes a selection legible.\n   */\n  private async renderEmbedding(): Promise<void> {\n    const controls = this.controls;\n    const meta = this.embedding;\n    if (!controls || !meta) {\n      this.purgePlot();\n      return;\n    }\n    if (!controls.getEmbedding) {\n      this.notice = 'This data source does not serve embeddings.';\n      this.purgePlot();\n      return;\n    }\n\n    // Sequenced on the shared token: the coordinates are a round-trip, and a slower one\n    // must not paint over a kind the user has already moved on from.\n    const mine = ++this.token;\n    // Computed here, not served: a local result is the same shape as a fetched one, so\n    // everything downstream — colouring, lasso selection, the camera — is unchanged.\n    const local = this.computed.get(meta.name);\n    if (local) {\n      this.embeddingCoords = local;\n    } else if (this.isComputable) {\n      // Offered but not yet computed. The panel shows the Compute button; drawing nothing\n      // is right, and an error would be wrong — there is no failure here.\n      this.purgePlot();\n      this.notice = null;\n      return;\n    } else if (!this.embeddingCoords || this.embeddingCoords.meta.name !== meta.name) {\n      this.busy = true;\n      try {\n        const loaded = await controls.getEmbedding(meta.name);\n        if (mine !== this.token) return;\n        this.embeddingCoords = loaded;\n      } catch (err) {\n        if (mine !== this.token) return;\n        this.notice = `Could not load ${meta.label ?? meta.name}: `\n          + `${(err as Error)?.message ?? err}`;\n        this.purgePlot();\n        return;\n      } finally {\n        if (mine === this.token) this.busy = false;\n      }\n    }\n    const coords = this.embeddingCoords;\n    if (!coords) return;\n\n    const target = this.plotTarget;\n    const el = document.getElementById(target);\n    if (!el) return; // the window is closed, or not rendered yet\n    const view = this.liveView(el);\n\n    this.notice = null;\n    const input = {\n      x: coords.x,\n      y: coords.y,\n      // The third dimension when the embedding has one — what switches the plot to a\n      // rotatable 3D scatter. Decoded only for a 3-dim embedding, so its presence here\n      // is the same question as `meta.dims === 3`.\n      ...(coords.z ? { z: coords.z } : {}),\n      label: meta.label ?? meta.name,\n      derived: meta.derived,\n      // Present for a PCA, absent for a UMAP — see `varianceRatio` on the meta.\n      ...(meta.varianceRatio ? { varianceRatio: meta.varianceRatio } : {}),\n      ...(this.categorical\n        ? {\n          categories: {\n            codes: this.categorical.codes,\n            names: this.categorical.categories,\n            colors: this.categorical.colors,\n          },\n        }\n        : {}),\n      ...(this.selection.count > 0 ? { selection: this.selection.mask } : {}),\n      // Whatever view the user has set up, read from the LIVE plot — which is where\n      // rotating and zooming leave it.\n      ...(view ? { view } : {}),\n    };\n    await this.draw(buildEmbeddingTraces(input), embeddingLayout(input), EMBEDDING_CONFIG, target);\n    this.bindEmbeddingSelection(target);\n  }\n\n  /**\n   * Turn a lasso in the embedding into a selection of observations.\n   *\n   * This is what makes two views of one dataset worth having side by side: draw round a\n   * cluster here and those cells light up on the tissue, because every view reads the\n   * same mask.\n   *\n   * Bound after each draw, and the previous listener removed first: `Plotly.react`\n   * preserves handlers, so re-binding without removing would fire the selection once per\n   * redraw the plot had ever had.\n   */\n  private bindEmbeddingSelection(div: string): void {\n    const el = document.getElementById(div) as (Plotly.PlotlyHTMLElement | null);\n    if (!el?.on) return;\n    el.removeAllListeners?.('plotly_selected');\n    el.removeAllListeners?.('plotly_deselect');\n    el.on('plotly_selected', (ev) => {\n      // A lasso that selects nothing arrives as an event with no points; treat it as a\n      // clear, which is what dragging an empty patch looks like it should do.\n      const points = (ev as { points?: readonly unknown[] } | undefined)?.points ?? [];\n      const indices: number[] = [];\n      for (const p of points) {\n        // The observation index rides on `customdata` — see `buildEmbeddingTraces`. A point's\n        // index within its trace is not the observation once the points are split by\n        // category, so this is the only correct source.\n        const id = (p as { customdata?: unknown }).customdata;\n        if (typeof id === 'number') indices.push(id);\n      }\n      if (indices.length === 0) {\n        this.controls?.clearSelection();\n        return;\n      }\n      this.controls?.selectIndices(indices);\n    });\n    // The modebar's deselect, and a plain click on empty space.\n    el.on('plotly_deselect', () => this.controls?.clearSelection());\n  }\n\n  /**\n   * Drop the embedding's selection handlers from a div another kind is about to use.\n   *\n   * The detached window outlives any one kind — switching tabs swaps its content and\n   * keeps the div — so without this the lasso handlers bound for a UMAP stay live under\n   * the counts plot that replaces it. `plotly_deselect` fires on a plain click in ANY\n   * Plotly chart, so the first click on a bar would silently clear the map's selection.\n   */\n  private unbindEmbeddingSelection(div: string): void {\n    const el = document.getElementById(div) as (Plotly.PlotlyHTMLElement | null);\n    if (!el?.removeAllListeners) return;\n    el.removeAllListeners('plotly_selected');\n    el.removeAllListeners('plotly_deselect');\n  }\n\n  /**\n   * The view the user has set up on the live plot, to carry across a redraw.\n   *\n   * `Plotly.react` resets a 3D scene camera and any zoomed 2D range unless the layout\n   * carries them, so selecting a category or recolouring would throw away an orientation\n   * that took work to find. Rotating a cloud to see a structure and losing it on the next\n   * click makes the plot useless for what it is for.\n   */\n  private liveView(\n    el: HTMLElement,\n  ): { camera?: unknown; ranges?: { x: unknown; y: unknown } } | null {\n    const full = (el as {\n      _fullLayout?: {\n        scene?: { camera?: unknown };\n        xaxis?: { range?: unknown; autorange?: boolean };\n        yaxis?: { range?: unknown; autorange?: boolean };\n      };\n    })._fullLayout;\n    if (!full) return null; // nothing drawn here yet\n    if (full.scene?.camera) return { camera: full.scene.camera };\n    // 2D: only once the user has actually zoomed. Passing an autoranged range back would\n    // freeze the axes and stop the plot re-fitting when the data changes.\n    const zoomed = full.xaxis?.autorange === false && full.yaxis?.autorange === false;\n    if (zoomed && full.xaxis?.range && full.yaxis?.range) {\n      return { ranges: { x: full.xaxis.range, y: full.yaxis.range } };\n    }\n    return null;\n  }\n\n  /**\n   * Whether the plot on screen fixed its own height.\n   *\n   * The counts and heatmap layouts size themselves to their row count, so in the detached\n   * window they can be TALLER than the window — which has to scroll rather than clip. An\n   * embedding fixes no height and fills the window instead. The template needs to know\n   * which, because the two want opposite `flex` and `overflow`.\n   */\n  get hasFixedHeight(): boolean {\n    return this.drawnHeight !== null;\n  }\n\n  /** Where the active kind draws: its own window, or the shared chart div. */\n  get plotTarget(): string {\n    return this.detached ? this.detachedDiv : this.chartDiv;\n  }\n\n  /**\n   * Header for the detached window — what it is showing, named as its tab is.\n   *\n   * The embedding names the embedding rather than the tab, because \"Embedding\" beside a\n   * window drawing a t-SNE says less than \"t-SNE\" does.\n   */\n  get detachedTitle(): string {\n    if (this.kind === 'embedding') {\n      return this.embedding?.label ?? this.embedding?.name ?? 'Embedding';\n    }\n    const label = this.kindOptions.find((k) => k.value === this.kind)?.label ?? 'Chart';\n    return this.subject ? `${label} · ${this.subject}` : label;\n  }\n\n  /**\n   * Move the active kind between its own window and the panel.\n   *\n   * Purges the div it is LEAVING first. Plotly keeps per-div state, and a graph left\n   * behind in a div that Angular then removes leaks its WebGL context — and if the div\n   * comes back, react would resize a plot whose data belongs to the other place.\n   */\n  toggleDetached(): void {\n    const leaving = this.plotTarget;\n    this.detached = !this.detached;\n    try {\n      Plotly.purge(leaving);\n    } catch {\n      // Nothing was plotted there.\n    }\n    // Going back INLINE, the div appears with the next change detection, so a task is\n    // enough. Going OUT, the window's div does not exist yet — PrimeNG mounts the dialog\n    // with a transition — so the dialog's own `onShow` drives that draw instead. A single\n    // deferred attempt drew nothing and never retried.\n    if (!this.detached) setTimeout(() => void this.render(), 0);\n  }\n\n  /** The detached window is up and its div exists — now the plot can be drawn into it. */\n  onDetachedWindowShown(): void {\n    void this.render();\n  }\n\n  /** Re-fit the detached window's plot after it is resized. */\n  onDetachedResizeEnd(): void {\n    this.refit(this.detachedDiv);\n  }\n\n  /**\n   * Rebuild the visible options: the best matches for what is typed, plus what is chosen.\n   *\n   * A capped multi-select that drops its own selections cannot resolve their labels, and\n   * the model loses them on the next change — the chips vanish for no reason the user\n   * can see.\n   */\n  private refreshGeneOptions(): void {\n    this.geneOptions = geneOptionsFor(this.geneNames, this.geneQuery, this.heatmapGenes)\n      .map((n) => ({ label: n, value: n }));\n  }\n\n  /** The gene picker's filter box changed: search the resident names, show the best. */\n  onGeneFilter(query: string): void {\n    this.geneQuery = query ?? '';\n    this.refreshGeneOptions();\n  }\n\n  /**\n   * Roughly how long a run will take, in seconds, from the measured anchor.\n   *\n   * Shown before the click. A progress bar tells you a job is going; only an estimate\n   * tells you whether to start it.\n   */\n  get computeEstimateSeconds(): number {\n    const n = this.observationCount;\n    const { seconds, observations } = SpatialChartsComponent.TSNE_SECONDS_AT;\n    return Math.max(1, Math.round(seconds * (n / observations) ** 2));\n  }\n\n  /** That estimate as something to put on a button. */\n  get computeEstimateLabel(): string {\n    const secs = this.computeEstimateSeconds;\n    if (secs < 90) return `~${secs}s`;\n    return `~${Math.round(secs / 60)} min`;\n  }\n\n  /** Why the option is absent, when a dataset is past the threshold. */\n  get tsneTooLargeNote(): string {\n    const n = this.observationCount;\n    return `t-SNE is not offered here for ${n.toLocaleString()} observations — it is `\n      + `quadratic, so it would take roughly ${this.computeEstimateLabel} in the browser. `\n      + 'Compute it offline and serve it with the dataset.';\n  }\n\n  /** Whether the selected embedding is one this browser would have to compute. */\n  get isComputable(): boolean {\n    return !!this.embedding && this.embedding.name.startsWith('local:');\n  }\n\n  /** Whether it has already been computed in this session. */\n  get isComputed(): boolean {\n    return !!this.embedding && this.computed.has(this.embedding.name);\n  }\n\n  get isComputing(): boolean {\n    return !!this.computeRun?.running;\n  }\n\n  /**\n   * Compute the selected embedding here, in a worker.\n   *\n   * The PCA scores come from the port as an ordinary embedding — the server derives them,\n   * because PCA needs the whole expression matrix (185 MB for a Visium dataset) while\n   * t-SNE needs only the scores (0.51 MB). Sending the matrix to the browser to save a\n   * few seconds of arithmetic would be a far slower answer.\n   */\n  async computeEmbedding(): Promise<void> {\n    const meta = this.embedding;\n    const controls = this.controls;\n    if (!meta || !controls?.getEmbedding || this.isComputing) return;\n    this.computeError = null;\n    this.computeMessage = null;\n    this.computeFraction = null;\n    this.computeBackend = null;\n\n    // Every early return and every await below is checked against this. `run` is held\n    // locally as well as on the instance: after an await `this.computeRun` may already be\n    // a newer run's, and clearing or terminating that one is how a fresh computation gets\n    // killed by the tail of the one it replaced.\n    const mine = ++this.computeToken;\n    const superseded = () => mine !== this.computeToken;\n    let run: EmbeddingComputeRun | null = null;\n\n    try {\n      // Prefer the 3-D scores: they carry a third component for free, and t-SNE on more\n      // components than it needs is not better — the PCA basis is the input either way.\n      const source = await this.loadPcaScores(controls);\n      if (superseded()) return;\n      if (!source) {\n        this.computeError = 'This dataset serves no PCA to embed.';\n        return;\n      }\n      run = new EmbeddingComputeRun();\n      this.computeRun = run;\n      const result = await run.run(\n        {\n          scores: source.scores,\n          nObs: source.nObs,\n          nDims: source.nDims,\n          dims: meta.dims,\n        },\n        {\n          ...meta,\n          label: (meta.label ?? meta.name)\n            .replace(SpatialChartsComponent.COMPUTE_SUFFIX, ''),\n        },\n        (progress: ComputeProgress) => {\n          // Progress from a superseded run must not drive the bar a newer one is using.\n          if (superseded()) return;\n          this.computeFraction = progress.fraction;\n          this.computeBackend = progress.backend ?? this.computeBackend;\n          if (progress.message) this.computeMessage = progress.message;\n        },\n      );\n      // A terminated run resolves null, so this covers abandonment as well as Cancel —\n      // but the token is still checked, because the dataset can change between the\n      // worker's `done` and this line.\n      if (result && !superseded()) {\n        this.computed.set(meta.name, result);\n        this.embeddingCoords = result;\n        await this.render();\n      }\n    } catch (err) {\n      if (!superseded()) this.computeError = (err as Error)?.message ?? String(err);\n    } finally {\n      run?.terminate();\n      // Only if it is still ours: a dataset switch has already terminated this run and\n      // may have started another, and `this.computeRun = null` here would orphan it —\n      // leaving a worker nothing can cancel and a Cancel button that does nothing.\n      if (this.computeRun === run) {\n        this.computeRun = null;\n        this.computeFraction = null;\n      }\n    }\n  }\n\n  /** Stop a run. It settles shortly after, leaving no embedding. */\n  cancelCompute(): void {\n    this.computeRun?.cancel();\n  }\n\n  /**\n   * Drop any computation in progress, because what it is computing no longer applies.\n   *\n   * Distinct from {@link cancelCompute}, which is the user's Cancel and asks the worker to\n   * stop politely. This one does not wait: the run is settled and the worker killed, so a\n   * dataset switch or a teardown cannot leave a t-SNE grinding on in the background over\n   * observations nothing is showing any more.\n   */\n  private abandonCompute(): void {\n    this.computeToken++;\n    this.computeRun?.terminate();\n    this.computeRun = null;\n    this.computeFraction = null;\n    this.computeBackend = null;\n    this.computeMessage = null;\n  }\n\n  /**\n   * The dataset's PCA, as row-major scores.\n   *\n   * Assembled from whichever PCA the source offers, widest first — a 3-D one gives t-SNE\n   * three components instead of two for the same request.\n   */\n  private async loadPcaScores(\n    controls: ISpatialControls,\n  ): Promise<{ scores: Float32Array; nObs: number; nDims: number } | null> {\n    const candidates = this.embeddings\n      .filter((e) => /pca/i.test(e.label ?? e.name) && !e.name.startsWith('local:'))\n      .sort((a, b) => b.dims - a.dims);\n    for (const candidate of candidates) {\n      try {\n        const pca = await controls.getEmbedding!(candidate.name);\n        const planes = [pca.x, pca.y, ...(pca.z ? [pca.z] : [])];\n        const nObs = pca.x.length;\n        const nDims = planes.length;\n        const scores = new Float32Array(nObs * nDims);\n        for (let i = 0; i < nObs; i++) {\n          for (let d = 0; d < nDims; d++) scores[i * nDims + d] = planes[d][i];\n        }\n        return { scores, nObs, nDims };\n      } catch {\n        // Try the next; a source may advertise one it cannot actually serve.\n      }\n    }\n    return null;\n  }\n\n  /** Which embedding to draw, when the dataset publishes more than one. */\n  onEmbedding(name: string): void {\n    const next = this.embeddings.find((e) => e.name === name);\n    if (!next || next.name === this.embedding?.name) return;\n    this.embedding = next;\n    this.embeddingCoords = null;\n    void this.render();\n  }\n\n  /**\n   * What the chart on screen actually shows, and what it cannot be read for.\n   *\n   * Shown on hover from a `?` beside the tabs. Each of these plots answers a different\n   * question and two of them are routinely over-read — a UMAP's distances and a heatmap's\n   * unscaled colours — so the caveat is part of the explanation rather than a footnote.\n   *\n   * HTML, because the tooltip renders with `[escape]=\"false\"`: a paragraph and a caveat\n   * read as two thoughts, and a single run-on line is skipped rather than read.\n   */\n  get kindHelp(): string {\n    switch (this.kind) {\n      case 'counts':\n        return '<b>Counts</b> — how many observations fall in each category of the column '\n          + 'the map is coloured by, largest first.<br><br>A category code is a label, not '\n          + 'a magnitude, so a frequency is the only distribution it has: there is no '\n          + 'histogram of a cell type.';\n      case 'histogram':\n        return '<b>Histogram</b> — how the active value is distributed over all '\n          + 'observations.<br><br>With a selection, it is overlaid on the full '\n          + 'distribution rather than replacing it, so you can see where the selected '\n          + 'cells sit within the whole.';\n      case 'violin':\n        return '<b>Violin</b> — the active value\\'s distribution within each category of '\n          + 'the grouping column, drawn as a smoothed density.<br><br>Shows shape a box '\n          + 'plot hides: two groups with the same median can be one peak or two.';\n      case 'box':\n        return '<b>Box</b> — median, quartiles and range of the active value within each '\n          + 'category of the grouping column.<br><br>Compact and comparable across many '\n          + 'groups, at the cost of hiding whether a group is bimodal.';\n      case 'heatmap':\n        return '<b>Heatmap</b> — mean expression of each picked gene within each group: '\n          + 'genes down, groups across.<br><br>Each gene is <b>z-scored across the '\n          + 'groups</b> by default, so a colour says \"above or below this gene\\'s own '\n          + 'average\", not \"highly expressed\". Without that one loud gene saturates the '\n          + 'scale and the rest of the panel reads as blank. Turning it off compares '\n          + 'genes on their raw scale instead.';\n      case 'embedding':\n        return this.embeddingHelp;\n      default:\n        return '';\n    }\n  }\n\n  /**\n   * What the embedding on screen is, and how far its geometry can be trusted.\n   *\n   * Per METHOD, because that is the part people get wrong: a PCA's axes are ordered and\n   * measurable while a UMAP's are neither, and the same picture read the two ways supports\n   * opposite conclusions.\n   */\n  private get embeddingHelp(): string {\n    const shared = '<br><br>Every cell is in all views at once: lasso a group here and '\n      + 'those cells light up on the tissue, because both read the same selection.';\n    const name = (this.embedding?.label ?? this.embedding?.name ?? '').toLowerCase();\n    if (name.includes('pca')) {\n      return '<b>PCA</b> — a <b>linear</b> projection onto the directions of greatest '\n        + 'variance, in order.<br><br>Alone among these, its axes mean something '\n        + 'measurable: each reports the share of total variance it explains, which is why '\n        + 'the labels carry a percentage. Distances are real, and a low percentage tells '\n        + 'you the picture is a thin slice of the variation.' + shared;\n    }\n    if (name.includes('t-sne') || name.includes('tsne')) {\n      return '<b>t-SNE</b> — cells placed so that close neighbours in expression stay '\n        + 'close.<br><br>Stricter about local neighbourhoods than UMAP and less '\n        + 'trustworthy about anything global: it tends to spread clusters into '\n        + 'evenly-sized islands whose sizes and separations mean little. Read which cells '\n        + 'group together, not how far apart the groups are.' + shared;\n    }\n    return '<b>UMAP</b> — cells placed so that close neighbours in expression stay '\n      + 'close.<br><br>The axes are arbitrary: unordered, unitless, and reproducible only '\n      + 'up to a rotation, which is why they carry no percentage. Read which cells group '\n      + 'together and which groups touch; do not read the distance between distant '\n      + 'clusters, or the direction of an axis.' + shared;\n  }\n\n  /** What the embedding view is showing, said plainly. */\n  get embeddingNote(): string {\n    const meta = this.embeddingCoords?.meta ?? this.embedding;\n    if (!meta) return 'This dataset publishes no embedding.';\n    // A derived embedding says so, and says HOW when the parameters are known: a t-SNE or\n    // UMAP at different settings is a different picture of the same cells, so \"computed\n    // here\" alone leaves a reader unable to reproduce or compare it.\n    const derived = meta.derived\n      ? ` Computed here${meta.params ? ` (${meta.params})` : ''}, `\n        + 'not published with the dataset.'\n      : '';\n    const coloured = this.categorical\n      ? ' Coloured to match the map.'\n      : ' Colour the map by a categorical column to colour these points.';\n    const sel = this.selection.count > 0\n      ? ` ${this.selection.count.toLocaleString()} selected are highlighted.`\n      : '';\n    return `${meta.label ?? meta.name}.${coloured}${sel}${derived}`;\n  }\n\n  private purgePlot(): void {\n    try {\n      // The ACTIVE target: purging the inline div while detached would leave the\n      // window showing a plot the component believes it has cleared.\n      Plotly.purge(this.plotTarget);\n    } catch {\n      // Nothing plotted.\n    }\n  }\n\n  /**\n   * Draw, remembering whether this layout fixed its own height.\n   *\n   * The layout builders return `unknown` on purpose — they keep Plotly's layout\n   * types out of the pure module — so the height is read back by narrowing\n   * rather than declared. `height` is Plotly's own key, not ours.\n   */\n  private async draw(\n    traces: unknown, layout: unknown, config: unknown = CHART_CONFIG, div = this.plotTarget,\n  ): Promise<void> {\n    const height = (layout as { height?: unknown } | null)?.height;\n    this.drawnHeight = typeof height === 'number' ? height : null;\n    await Plotly.react(div, traces as never, layout as never, config as never);\n  }\n\n  private async render(): Promise<void> {\n    if (!this.isActive) return;\n    // Guard on the div the ACTIVE kind will draw into, not always the shared one. While a\n    // kind is detached the inline div is removed by its `*ngIf`, so checking that one\n    // bailed here and the detached window never got a plot.\n    const target = this.plotTarget;\n    if (!document.getElementById(target)) return;\n    // Anything but the embedding inherits a div the embedding may have bound handlers on.\n    if (this.kind !== 'embedding') this.unbindEmbeddingSelection(target);\n    // The heatmap answers a different question from the other kinds — which\n    // genes distinguish which groups — so it is driven by its own gene list and\n    // grouping rather than by whatever the map is coloured by.\n    if (this.kind === 'heatmap') {\n      await this.renderHeatmap();\n      return;\n    }\n    // Also independent of the active colour source: the coordinates are the dataset's,\n    // and the colouring merely follows whatever the map is using.\n    if (this.kind === 'embedding') {\n      await this.renderEmbedding();\n      return;\n    }\n    if (!this.colorBy || (!this.values && !this.categorical)) {\n      this.purgePlot();\n      return;\n    }\n    if (this.categorical) {\n      const counts = {\n        group: this.categorical,\n        selection: this.selection.count > 0 ? this.selection.mask : null,\n        name: this.colorBy.name,\n      };\n      await this.draw(buildCountTraces(counts), countsLayout(counts));\n      return;\n    }\n    if (!this.values) return;\n    const input = {\n      values: this.values,\n      name: this.colorBy.kind === 'feature' ? this.colorBy.name : this.colorBy.name,\n      group: benefitsFromGrouping(this.kind) ? this.grouping : null,\n      selection: this.selection.count > 0 ? this.selection.mask : null,\n      log: this.view.logScale,\n    };\n    const traces = buildOmicsTraces(this.kind, input);\n    await this.draw(traces, omicsLayout(this.kind, input));\n  }\n\n  /**\n   * Genes × groups mean expression.\n   *\n   * Columns are the grouping column's categories — or, inside a SMALL\n   * selection, the selected cells themselves. A two-column class matrix is a\n   * poor answer for an ROI holding forty cells; \"what is in front of me\" is the\n   * question there, and each cell earns a column.\n   */\n  private async renderHeatmap(): Promise<void> {\n    const controls = this.controls;\n    const genes = this.heatmapGenes\n      .map((name) => ({ name, values: this.geneCache.get(name) }))\n      .filter((g): g is { name: string; values: Float32Array } => !!g.values);\n    if (!controls || genes.length === 0 || !this.grouping) {\n      this.purgePlot();\n      return;\n    }\n\n    const selected = this.selection.count > 0 ? maskToIndices(this.selection.mask) : null;\n    const perCell = !!selected && selected.length <= SpatialChartsComponent.HEATMAP_CELL_COLUMNS;\n    const cells = perCell && selected\n      ? cellsAsGroups(selected, this.grouping.codes.length,\n        SpatialChartsComponent.HEATMAP_CELL_COLUMNS)\n      : null;\n\n    const matrix = heatmapMatrix(\n      genes,\n      cells ? cells.groups : { codes: this.grouping.codes, categories: this.grouping.categories },\n      {\n        ...(cells ? { indices: cells.indices, minCells: 1 } : {}),\n        // Outside the per-cell view a selection still narrows the means, the way\n        // the violin and box narrow rather than overlay.\n        ...(!cells && selected ? { indices: selected } : {}),\n        // Only the grouped view: `cellsAsGroups` already caps by even thinning,\n        // and re-ranking those columns would lose the selection's spread.\n        ...(cells ? {} : { maxCols: SpatialChartsComponent.HEATMAP_MAX_COLUMNS }),\n        zScore: this.heatmapZScore,\n      },\n    );\n    if (!matrix) {\n      this.purgePlot();\n      this.notice = 'No group has enough measured cells for a mean.';\n      return;\n    }\n    this.notice = null;\n    this.heatmapHidden = matrix.hiddenCols;\n    const input = {\n      rows: matrix.rows,\n      cols: matrix.cols,\n      values: matrix.values,\n      counts: matrix.counts,\n      zScored: this.heatmapZScore,\n      groupLabel: cells ? 'selected cells' : (this.groupBy ?? ''),\n    };\n    await this.draw(buildHeatmapTraces(input), heatmapLayout(input));\n  }\n}\n","<div class=\"sx-body\" *ngIf=\"controls\">\n\n  <!-- The chart follows whatever the map is coloured by, so the two can never\n       disagree about what is being shown. -->\n  <div class=\"sx-head\">\n    <span class=\"sx-subject\" *ngIf=\"subject\">{{ subject }}</span>\n    <span class=\"sx-subject sx-muted\" *ngIf=\"!subject\">nothing selected to chart</span>\n    <span class=\"sx-badge\" *ngIf=\"selectionCount\">\n      {{ selectionCount | number }} selected\n    </span>\n    <i class=\"pi pi-spin pi-spinner sx-busy\" *ngIf=\"busy\" aria-label=\"loading\"></i>\n  </div>\n\n  <div class=\"sx-controls\">\n    <p-selectButton [options]=\"kindOptions\" optionLabel=\"label\" optionValue=\"value\"\n                    [ngModel]=\"kind\" (ngModelChange)=\"onKind($event)\"\n                    styleClass=\"sx-kind\"></p-selectButton>\n    <p-dropdown [options]=\"groupOptions\" optionLabel=\"label\" optionValue=\"value\"\n                [ngModel]=\"groupBy\" (ngModelChange)=\"onGroupBy($event)\"\n                placeholder=\"No grouping\" appendTo=\"body\"\n                [disabled]=\"kind === 'histogram'\"\n                [pTooltip]=\"kind === 'heatmap'\n                  ? 'The categorical column the heatmap\\'s columns come from'\n                  : 'Split a violin or box by a categorical column'\"\n                tooltipPosition=\"top\"></p-dropdown>\n    <!-- What the chart on screen shows, and what it must NOT be read for. Each of these\n         answers a different question and two are routinely over-read, so the caveat\n         travels with the explanation. -->\n    <i class=\"pi pi-question-circle sx-help\"\n       [pTooltip]=\"kindHelp\" [escape]=\"false\" tooltipPosition=\"left\"\n       tooltipStyleClass=\"sx-help-tip\"\n       [attr.aria-label]=\"'About the ' + kind + ' chart'\" tabindex=\"0\"></i>\n  </div>\n\n  <!-- The heatmap's rows are a gene LIST, so it needs its own picker: the other\n       kinds chart whatever single source the map is coloured by. -->\n  <div class=\"sx-controls\" *ngIf=\"kind === 'heatmap'\">\n    <p-multiSelect [options]=\"geneOptions\" optionLabel=\"label\" optionValue=\"value\"\n                   [ngModel]=\"heatmapGenes\" (ngModelChange)=\"onHeatmapGenes($event)\"\n                   [filter]=\"true\" filterBy=\"label\" (onFilter)=\"onGeneFilter($event.filter)\"\n                   [virtualScroll]=\"true\" [virtualScrollItemSize]=\"30\" appendTo=\"body\"\n                   [showToggleAll]=\"false\" [maxSelectedLabels]=\"3\"\n                   selectedItemsLabel=\"{0} genes\"\n                   placeholder=\"Pick genes for the rows\"\n                   pTooltip=\"One row per gene, averaged within each group\"\n                   tooltipPosition=\"top\" styleClass=\"sx-genes\"></p-multiSelect>\n    <p-checkbox [binary]=\"true\" [ngModel]=\"heatmapZScore\"\n                (onChange)=\"onHeatmapZScore($event.checked)\"\n                label=\"z-score\"\n                pTooltip=\"Scale each gene across the groups. Without it one highly-expressed gene saturates the colour scale and the rest reads as blank\"\n                tooltipPosition=\"top\"></p-checkbox>\n  </div>\n\n  <!-- Detach applies to EVERY kind: the dialog is only so wide, and a counts plot read\n       against a heatmap is the same argument as a UMAP read against the map. -->\n  <div class=\"sx-controls\">\n    <!-- A picker only when the dataset publishes more than one embedding. -->\n    <p-dropdown *ngIf=\"kind === 'embedding' && embeddings.length > 1\"\n                [options]=\"embeddings\" optionLabel=\"label\" optionValue=\"name\"\n                [ngModel]=\"embedding?.name\" (ngModelChange)=\"onEmbedding($event)\"\n                appendTo=\"body\"\n                pTooltip=\"Which embedding to draw\" tooltipPosition=\"top\"></p-dropdown>\n    <!-- Offered only for an embedding this dataset does not publish. It runs in a Web\n         Worker on the GPU, so the panel stays usable while it goes. -->\n    <p-button *ngIf=\"kind === 'embedding' && isComputable && !isComputed && !isComputing\"\n              icon=\"pi pi-play\" size=\"small\" [text]=\"true\"\n              [label]=\"'Compute (' + computeEstimateLabel + ')'\"\n              pTooltip=\"Run t-SNE here, in a background worker on the GPU, from this dataset's PCA. The panel stays usable, and it can be cancelled.\"\n              tooltipPosition=\"top\"\n              (onClick)=\"computeEmbedding()\"></p-button>\n    <p-button *ngIf=\"isComputing\"\n              icon=\"pi pi-times\" size=\"small\" [text]=\"true\" severity=\"secondary\"\n              label=\"Cancel\" (onClick)=\"cancelCompute()\"></p-button>\n    <p-button [icon]=\"detached ? 'pi pi-window-minimize' : 'pi pi-external-link'\"\n              size=\"small\" [text]=\"true\"\n              [label]=\"detached ? 'Put back' : 'Detach'\"\n              [pTooltip]=\"detached\n                ? 'Show this chart in the panel again'\n                : 'Open this chart in its own window, alongside this panel'\"\n              tooltipPosition=\"top\"\n              (onClick)=\"toggleDetached()\"></p-button>\n  </div>\n\n  <!-- Progress while a computation runs. `mode=\"indeterminate\"` until the first report,\n       because the run starts with a neighbour graph and there is nothing honest to show\n       as a percentage yet. -->\n  <div class=\"sx-compute\" *ngIf=\"isComputing\">\n    <p-progressBar\n      [mode]=\"computeFraction === null ? 'indeterminate' : 'determinate'\"\n      [value]=\"computeFraction === null ? 0 : (computeFraction * 100)\"\n      [showValue]=\"computeFraction !== null\"\n      [style]=\"{ height: '0.6rem' }\"></p-progressBar>\n    <small class=\"sx-hint\">\n      {{ computeFraction === null ? 'Building the neighbour graph…' : 'Optimising…' }}\n      <ng-container *ngIf=\"computeBackend\"> on {{ computeBackend }}</ng-container>\n    </small>\n    <small class=\"sx-hint sx-warn\" *ngIf=\"computeMessage\">{{ computeMessage }}</small>\n  </div>\n  <small class=\"sx-hint sx-warn\" *ngIf=\"computeError\">{{ computeError }}</small>\n  <!-- Withheld rather than offered with a warning: an hour-long job is not a choice a\n       reader can meaningfully consent to from a dialog. -->\n  <small class=\"sx-hint\" *ngIf=\"kind === 'embedding' && tsneTooLarge\">{{ tsneTooLargeNote }}</small>\n\n  <div [id]=\"chartDiv\" class=\"sx-plot\" *ngIf=\"!detached\"></div>\n\n  <!-- Detached: the chart keeps drawing, in its own window. Says so rather than\n       leaving a blank panel that looks broken. -->\n  <div class=\"sx-detached\" *ngIf=\"detached\">\n    Shown in its own window.\n  </div>\n\n  <ng-container *ngTemplateOutlet=\"hints\"></ng-container>\n\n</div>\n\n<!-- Declared once and rendered in both the panel and the detached window: the ladder is\n     deliberately not mutually exclusive (a heatmap still needs its grouping prompt), so\n     collapsing it to a single expression would drop a hint rather than move it. -->\n<ng-template #hints>\n  <small class=\"sx-hint\" *ngIf=\"notice\">{{ notice }}</small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && suggestsGrouping\">\n    Pick a grouping to compare categories.\n  </small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && selectionCount && kind === 'histogram'\">\n    The selection is overlaid on the full distribution.\n  </small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && selectionCount && kind !== 'histogram' && kind !== 'heatmap'\">\n    Showing the selection only.\n  </small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && kind === 'heatmap'\">{{ heatmapNote }}</small>\n  <small class=\"sx-hint\" *ngIf=\"!notice && kind === 'embedding'\">{{ embeddingNote }}</small>\n</ng-template>\n\n<!-- The detached chart. Its own non-modal, draggable, resizable window so it can be put\n     beside the spatial-omics dialog. `appendTo=\"body\"` keeps it out of the dialog's\n     stacking context, or it would be clipped by the panel it is meant to sit next to. -->\n<p-dialog *ngIf=\"detached\"\n          [header]=\"detachedTitle\"\n          [visible]=\"true\" (visibleChange)=\"toggleDetached()\"\n          [modal]=\"false\" [resizable]=\"true\" [draggable]=\"true\"\n          position=\"right\" appendTo=\"body\"\n          (onShow)=\"onDetachedWindowShown()\"\n          (onResizeEnd)=\"onDetachedResizeEnd()\"\n          [style]=\"{ width: '34rem', height: '30rem' }\"\n          [contentStyle]=\"{\n            display: 'flex', flexDirection: 'column', gap: '0.25rem',\n            padding: '0.4rem 0.6rem 0.5rem', flex: '1 1 auto', minHeight: '0',\n            overflow: 'auto'\n          }\"\n          styleClass=\"spatial-detached-dialog\">\n  <div [id]=\"detachedDiv\" class=\"sx-detached-plot\"\n       [class.sx-plot-fixed]=\"hasFixedHeight\"></div>\n  <ng-container *ngTemplateOutlet=\"hints\"></ng-container>\n</p-dialog>\n"]}