@jax-data-science/sci-image-visualizer 0.6.0 → 0.8.0

package/esm2022/lib/implementations/napari-js/napari-spatial-tiles.mjs

@@ -0,0 +1,1487 @@
+import { Colormap, colormapFromLut } from 'napari-js';
+import { ALL_GENES } from '../../contracts/ports/spatial-data.port';
+import { NO_CATEGORY, NO_OBSERVATION, isCategoricalColumn, } from '../../contracts/spatial-dataset.contract';
+import { DEFAULT_CATEGORICAL_PALETTE, MISSING_COLOR, contrastWindow, lutFor, parseHex, resolveCategoryColors, } from '../../spatial/spatial-encoding';
+import { INFERNO_SCALE, POLYGON_LEVEL_MIN_CELL_PX, allGenesPlan, cellTypeColumnFor, cellsShown, colorDensityWindow, densityAutoRange, groupedMarkerPx, quantileOf, tilesInRectFrom, defaultGlyphFor, discreteColormapStops, glyphOutline, glyphRings, pixelsPerDataUnit, polygonLevelFor, tileId, tilesInRect, transcriptLevelFor, transcriptMarkerPx, typicalCellDiameter, visibleArea, visibleDataRect, geneBinSize, groupTranscripts, clipTranscripts, clusterColorMap, } from '../../spatial/spatial-tiles';
+/** The all-gene pyramid's finest bin (250 µm source tiles / 128) and default level count, used
+ *  to group a gene selection on the same ladder when a dataset has no pyramid. */
+const PYRAMID_BASE_BIN_UM = 250 / 128;
+const PYRAMID_LEVELS = 7;
+/** Icons get a dark rim only while there are at most this many, at least this big (px). */
+const GLYPH_OUTLINE_MAX = 20_000;
+const GLYPH_OUTLINE_MIN_PX = 8;
+const ORDER = [
+    'cellFill', 'cellOutline', 'nucleusOutline', 'density', 'transcripts', 'transcriptOutline',
+];
+/** Transcripts drawn at once. Past this a screen is solid colour anyway; the level
+ *  policy keeps a normal view far below it. */
+const MAX_TRANSCRIPTS = 400_000;
+const MAX_CELL_TILES = 48;
+const MAX_TRANSCRIPT_TILES = 36;
+const MAX_BIN_TILES = 64;
+const CAMERA_IDLE_MS = 120;
+/** First retry of a view with a failed tile; doubles each time, up to MAX_TILE_RETRIES. */
+const TILE_RETRY_MS = 1000;
+const MAX_TILE_RETRIES = 3;
+const UNASSIGNED_RGBA = [0.62, 0.62, 0.62, 0.55];
+export class NapariSpatialTileLayers {
+    constructor(port, host) {
+        this.port = port;
+        this.host = host;
+        this.viewer = null;
+        this.cameraOff = null;
+        this.timer = null;
+        /** Set when a tile of the current plan failed to load (see fetchAll). */
+        this.planIncomplete = false;
+        /** Consecutive retries of an incomplete view. */
+        this.tileRetries = 0;
+        this.token = 0;
+        this.layers = new Map();
+        /** What each group currently shows, so an unchanged plan is a no-op. */
+        this.keys = new Map();
+        this.polygonsShown = false;
+        /** Rings currently drawn and the (dataset, set, tiles) they came from. */
+        this.currentRings = null;
+        this.cellGeometryKey = null;
+        this.currentNuclei = null;
+        this.cellStyleKey = null;
+        /** Selection identity → revision, so a change key can name a selection cheaply. */
+        this.lastSelection = null;
+        this.selectionRevision = 0;
+        /** µm per observation unit of the drawn dataset, for describing a grouped marker's area. */
+        this.micronsPerUnit = null;
+        /** Loads in flight, per layer label, for the loading badge. */
+        this.loading = new Map();
+        /** The loaded per-gene transcripts the in-view counts are taken from. */
+        this.countSource = null;
+        // ── hover ─────────────────────────────────────────────────────────────────────────
+        this.drawn = null;
+        this.hoverTypes = null;
+        /** Details already fetched, by hovered entry. */
+        this.hoverCache = new Map();
+        this.hoverKey = null;
+        this.hoverTimer = null;
+        this.densityCache = new Map();
+        this.countsCache = null;
+        /** The density window in use and the densest bin, for the panel's threshold control. */
+        this.densityStats = null;
+    }
+    // ── lifecycle ─────────────────────────────────────────────────────────────────────
+    attach(viewer) {
+        if (this.viewer === viewer)
+            return;
+        this.detach();
+        this.viewer = viewer;
+        this.cameraOff = viewer.camera.changed.connect(() => this.schedule());
+    }
+    /**
+     * Group a gene selection for the zoom: one marker per gene-tree cluster (a gene in no
+     * cluster is its own) per bin of the pyramid ladder, starting at the finest bin whose
+     * markers are 14 px apart and stepping up while the markers would exceed the budget.
+     * Null to draw every transcript: zoomed in, with the selection within the budget.
+     */
+    groupSelection(t, view, ladder, pxPerUnit) {
+        const budget = Math.max(1, view.transcriptBudget);
+        const genes = view.transcriptGenes;
+        const groups = view.transcriptGeneGroups;
+        const names = [...groups.map((g) => g.name), ...genes];
+        const clusterOf = genes.map((gene, slot) => {
+            const g = groups.findIndex((x) => x.genes.includes(gene));
+            return g >= 0 ? g : groups.length + slot;
+        });
+        const keyOf = (slot) => clusterOf[slot] ?? groups.length + slot;
+        let bin = ladder.start;
+        if (bin === null) {
+            // Every transcript, if they fit the max and none was cut off at the cap.
+            if (t.count <= budget && t.count < MAX_TRANSCRIPTS)
+                return null;
+            bin = ladder.baseBin;
+        }
+        const top = ladder.baseBin * 2 ** (ladder.levels - 1);
+        let grouped = groupTranscripts(t, bin, keyOf);
+        // Over the max: combine into larger markers, a level at a time.
+        while (grouped.tile.count > budget && bin < top) {
+            bin *= 2;
+            grouped = groupTranscripts(t, bin, keyOf);
+        }
+        const refCount = quantileOf(grouped.tile.weight, 0.95);
+        const binPx = bin * pxPerUnit;
+        const px = new Float32Array(grouped.tile.count);
+        for (let i = 0; i < grouped.tile.count; i++) {
+            px[i] = groupedMarkerPx(grouped.tile.weight[i], refCount, binPx, view.transcriptScale);
+        }
+        return { merged: grouped.tile, px, bin, group: grouped.group, names };
+    }
+    /** Report `label` loading while `work` is in flight. */
+    async track(label, work) {
+        this.loading.set(label, (this.loading.get(label) ?? 0) + 1);
+        this.host.loadingChanged?.([...this.loading.keys()]);
+        try {
+            return await work;
+        }
+        finally {
+            const n = (this.loading.get(label) ?? 1) - 1;
+            if (n > 0)
+                this.loading.set(label, n);
+            else
+                this.loading.delete(label);
+            this.host.loadingChanged?.([...this.loading.keys()]);
+        }
+    }
+    /**
+     * Transcripts of each selected gene inside `rect`: each entry counts for the transcripts it
+     * stands for (an aggregate at a coarse level holds several). Null without per-gene data.
+     */
+    geneCountsIn(rect) {
+        const src = this.countSource;
+        if (!src)
+            return null;
+        const out = {};
+        for (const g of src.genes)
+            out[g] = 0;
+        const { x, y, weight, gene } = src.merged;
+        for (let i = 0; i < src.merged.count; i++) {
+            if (x[i] < rect.x0 || x[i] > rect.x1 || y[i] < rect.y0 || y[i] > rect.y1)
+                continue;
+            const name = src.genes[gene[i]];
+            if (name !== undefined)
+                out[name] += weight[i];
+        }
+        return out;
+    }
+    /** Whether `layer` is one of the overlays drawn here (density, cells, transcripts). */
+    owns(layer) {
+        for (const l of this.layers.values())
+            if (l === layer)
+                return true;
+        return false;
+    }
+    detach() {
+        if (this.hoverTimer)
+            clearTimeout(this.hoverTimer);
+        this.hoverTimer = null;
+        this.drawn = null;
+        this.cameraOff?.();
+        this.cameraOff = null;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        this.token++;
+        this.tileRetries = 0;
+        this.countSource = null;
+        this.loading.clear();
+        this.host.loadingChanged?.([]);
+        if (this.viewer) {
+            for (const layer of this.layers.values()) {
+                if (this.viewer.layers.items.includes(layer))
+                    this.viewer.layers.remove(layer);
+            }
+        }
+        this.layers.clear();
+        this.keys.clear();
+        this.setPolygonsShown(false);
+        this.viewer = null;
+    }
+    /** True while outlines are on screen — the service hides its dots then. */
+    get outlinesShown() {
+        return this.polygonsShown;
+    }
+    /** Dataset, view or selection changed: re-plan now rather than on camera idle. */
+    refresh() {
+        this.schedule(0);
+    }
+    /** Called right after the service adds its marker layer: everything goes back on top. */
+    afterObservations() {
+        const v = this.viewer;
+        if (!v)
+            return;
+        for (const g of ORDER) {
+            const layer = this.layers.get(g);
+            if (!layer)
+                continue;
+            if (v.layers.items.includes(layer))
+                v.layers.remove(layer);
+            v.layers.add(layer);
+        }
+    }
+    // ── planning ──────────────────────────────────────────────────────────────────────
+    schedule(delay = CAMERA_IDLE_MS) {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.plan();
+        }, delay);
+    }
+    async plan() {
+        const viewer = this.viewer;
+        const latest = this.host.latest();
+        if (!viewer || !latest)
+            return;
+        const [dataset, view, selection] = latest;
+        const token = ++this.token;
+        const stale = () => token !== this.token || this.viewer !== viewer;
+        this.planIncomplete = false;
+        if (!dataset) {
+            for (const g of ORDER)
+                this.drop(g);
+            this.dropCells();
+            return;
+        }
+        const [w, h] = this.host.canvasSize();
+        const ref = dataset.imageRef;
+        const rect = visibleDataRect(viewer.camera.center, viewer.camera.zoom, w, h, ref);
+        const pxPerUnit = pixelsPerDataUnit(viewer.camera.zoom, ref);
+        if (!rect)
+            return;
+        void this.planEstimate(dataset, view, viewer, w, h, stale);
+        await Promise.all([
+            this.planDensity(dataset, view, stale),
+            this.planCells(dataset, view, selection, rect, pxPerUnit, stale),
+            this.planTranscripts(dataset, view, rect, pxPerUnit, stale),
+        ]);
+        if (stale())
+            return;
+        this.host.geneCountsChanged?.(this.geneCountsIn(rect));
+        // A tile that failed left a hole the cache keys do not record, so try the same view
+        // again, backing off, a bounded number of times.
+        if (!this.planIncomplete) {
+            this.tileRetries = 0;
+        }
+        else if (this.tileRetries < MAX_TILE_RETRIES) {
+            this.schedule(TILE_RETRY_MS * 2 ** this.tileRetries++);
+        }
+    }
+    // ── cells ─────────────────────────────────────────────────────────────────────────
+    async planCells(dataset, view, selection, rect, pxPerUnit, stale) {
+        const tiled = dataset.polygonTiles;
+        const whole = !tiled && dataset.polygons && this.port.getPolygons;
+        if (!cellsShown(dataset, view) || (!tiled && !whole)) {
+            this.dropCells();
+            return;
+        }
+        const diameter = typicalCellDiameter(dataset.observations.radius);
+        // Whole-dataset rings have one level and no coarser fallback, so they are drawn as
+        // soon as a cell is big enough to read as a shape rather than a dot.
+        const level = tiled
+            ? polygonLevelFor(pxPerUnit, diameter, tiled.levels.length)
+            : (pxPerUnit * diameter >= POLYGON_LEVEL_MIN_CELL_PX[2] ? 0 : -1);
+        if (level < 0) {
+            this.dropCells();
+            return;
+        }
+        // Groups switched off in the list: their cells are left out of the geometry.
+        const hidden = await this.hiddenCodes(dataset, view);
+        if (stale())
+            return;
+        const label = view.cellSet === 'both' ? 'Cells and nuclei'
+            : view.cellSet === 'nucleus' ? 'Nuclei' : 'Cells';
+        const geometry = await this.track(label, this.cellGeometry(dataset, view, rect, level, hidden, stale));
+        if (!geometry)
+            return;
+        const { rings, nuclei, geometryKey } = geometry;
+        const geometryChanged = geometryKey !== this.cellGeometryKey;
+        const styleKey = [
+            geometryKey, view.cellColorMode, view.cellColorGene, view.cellSingleColor,
+            this.cellTypeColumnName(dataset, view),
+            this.selectionRev(selection), view.logScale, view.percentileClip.join(),
+            JSON.stringify(view.continuousColormap), view.cellDraw, view.cellOpacity,
+        ].join('|');
+        const present = ['cellFill', 'cellOutline', 'nucleusOutline'].some((g) => {
+            const l = this.layers.get(g);
+            return l && this.viewer.layers.items.includes(l);
+        });
+        if (!geometryChanged && styleKey === this.cellStyleKey && present) {
+            this.setPolygonsShown(true);
+            return;
+        }
+        const colors = await this.cellColors(dataset, view, selection, rings.observation);
+        if (stale())
+            return;
+        this.currentRings = rings;
+        this.currentNuclei = nuclei;
+        // A geometry missing a failed tile is drawn but not remembered, so the retry refetches it.
+        this.cellGeometryKey = this.planIncomplete ? null : geometryKey;
+        this.cellStyleKey = styleKey;
+        const ref = dataset.imageRef;
+        const common = { scale: ref?.scale ?? [1, 1], translate: ref?.translate ?? [0, 0] };
+        const fill = view.cellDraw !== 'outline';
+        const outline = view.cellDraw !== 'fill';
+        this.upsertShapes('cellFill', fill, geometryChanged, rings, {
+            name: 'cells', draw: 'fill', opacity: view.cellOpacity, ...colors, ...common,
+        });
+        this.upsertShapes('cellOutline', outline, geometryChanged, rings, fill
+            // Over a fill, a dark outline separates neighbours of the same type.
+            ? { name: 'cell outlines', draw: 'outline', color: [0.08, 0.08, 0.1, 1], opacity: 0.7, ...common }
+            : { name: 'cell outlines', draw: 'outline', opacity: 1, ...colors, ...common });
+        // "Both": nuclei outlined over the cells, light so they read against any fill.
+        if (nuclei) {
+            this.upsertShapes('nucleusOutline', true, geometryChanged, nuclei, {
+                name: 'nucleus outlines', draw: 'outline', color: [0.95, 0.95, 0.98, 1], opacity: 0.8, ...common,
+            });
+        }
+        else {
+            this.drop('nucleusOutline');
+        }
+        this.setPolygonsShown(true);
+    }
+    selectionRev(selection) {
+        if (selection !== this.lastSelection) {
+            this.lastSelection = selection;
+            this.selectionRevision++;
+        }
+        return this.selectionRevision;
+    }
+    /** Per-shape values + colormap for the rings' owners. */
+    /**
+     * Per-shape values + colormap for the rings' owners, by the view's cell-colour mode
+     * (Xenium Explorer's "Cell Color"). A selection mutes what it leaves out.
+     */
+    async cellColors(dataset, view, selection, owners) {
+        const muted = selection.count > 0 ? selection.mask : null;
+        const mode = view.cellColorMode;
+        if (mode === 'single') {
+            const [r, g, b] = parseHex(view.cellSingleColor);
+            return { color: [r / 255, g / 255, b / 255, 1] };
+        }
+        const continuous = async (raw, log) => {
+            const values = new Float32Array(owners.length);
+            for (let i = 0; i < owners.length; i++) {
+                const v = raw[owners[i]] ?? NaN;
+                values[i] = log ? Math.log1p(Math.max(0, v)) : v;
+            }
+            const [lo, hi] = contrastWindow(log ? raw.map((v) => Math.log1p(Math.max(0, v))) : raw, view.percentileClip[0], view.percentileClip[1]);
+            return {
+                values,
+                colormap: colormapFromLut('spatial-continuous', this.host.continuousLut(view)),
+                contrastLimits: [lo, hi],
+            };
+        };
+        if (mode === 'gene' && view.cellColorGene) {
+            return continuous(await this.port.getFeatureVector(view.cellColorGene), true);
+        }
+        if (mode === 'transcriptDensity' && dataset.columns.some((c) => c.name === 'transcript_density')) {
+            const column = await this.port.getColumn('transcript_density');
+            if (!isCategoricalColumn(column))
+                return continuous(column.values, false);
+        }
+        const name = mode === 'segmentation' && dataset.columns.some((c) => c.name === 'segmentation_method')
+            ? 'segmentation_method'
+            : this.cellTypeColumnName(dataset, view);
+        const codes = name ? await this.categoricalCodes(name) : null;
+        const { colormap, valueOf } = this.categoricalColormap(codes?.meta ?? null);
+        const values = new Float32Array(owners.length);
+        for (let i = 0; i < owners.length; i++) {
+            const o = owners[i];
+            const code = !codes || (muted && !muted[o]) ? -1 : codes.codes[o];
+            values[i] = valueOf(code === NO_CATEGORY ? -1 : code);
+        }
+        return { values, colormap, contrastLimits: [0, 1] };
+    }
+    /** Codes of the group column that are switched off, or null when none are. */
+    async hiddenCodes(dataset, view) {
+        if (!view.hiddenGroups.length)
+            return null;
+        const name = this.cellTypeColumnName(dataset, view);
+        const col = name ? await this.categoricalCodes(name) : null;
+        if (!col || col.meta.kind !== 'categorical')
+            return null;
+        const off = new Set(view.hiddenGroups);
+        const hidden = Uint8Array.from(col.meta.categories, (c) => (off.has(c) ? 1 : 0));
+        return { codes: col.codes, hidden };
+    }
+    cellTypeColumnName(dataset, view) {
+        return cellTypeColumnFor(dataset, view);
+    }
+    async categoricalCodes(name) {
+        const column = await this.port.getColumn(name);
+        return isCategoricalColumn(column) ? { codes: column.codes, meta: column.meta } : null;
+    }
+    categoricalColormap(meta) {
+        const hex = meta && meta.kind === 'categorical'
+            ? resolveCategoryColors(meta)
+            : [DEFAULT_CATEGORICAL_PALETTE[0]];
+        const rgb = hex.map(parseHex);
+        const { stops, valueOf } = discreteColormapStops(rgb, MISSING_COLOR);
+        return { colormap: new Colormap('spatial-categories', stops), valueOf, rgb };
+    }
+    /**
+     * The cell rings (and, for "both", the nucleus rings) covering `rect` at `level`, minus
+     * the hidden groups — reused when nothing that decides them changed. Null when the
+     * view went stale or the dataset has no set to draw.
+     */
+    async cellGeometry(dataset, view, rect, level, hidden, stale) {
+        const tiled = dataset.polygonTiles;
+        const hiddenKey = view.hiddenGroups.join('\u0001');
+        let rings;
+        let nuclei = null;
+        let geometryKey;
+        if (tiled) {
+            const both = view.cellSet === 'both';
+            const set = !both && view.cellSet && tiled.sets.some((s) => s.name === view.cellSet)
+                ? view.cellSet : (tiled.defaultSet ?? tiled.sets[0]?.name);
+            if (!set)
+                return null;
+            const nucleusSet = both ? tiled.sets.find((s) => s.name !== set)?.name : undefined;
+            const keys = tilesInRect(rect, level, tiled.levels, tiled.bounds, MAX_CELL_TILES);
+            geometryKey = `${dataset.id}|${set}|${nucleusSet ?? ''}|${hiddenKey}|${keys.map(tileId).join(',')}`;
+            if (geometryKey === this.cellGeometryKey && this.currentRings) {
+                rings = this.currentRings;
+                nuclei = this.currentNuclei;
+            }
+            else {
+                const [tiles, nucleusTiles] = await Promise.all([
+                    this.fetchAll(keys, (k) => this.port.getPolygonTile(set, k.level, k.gx, k.gy)),
+                    nucleusSet
+                        ? this.fetchAll(keys, (k) => this.port.getPolygonTile(nucleusSet, k.level, k.gx, k.gy))
+                        : Promise.resolve(null),
+                ]);
+                if (stale())
+                    return null;
+                rings = filterRings(mergePolygonTiles(tiles), hidden);
+                nuclei = nucleusTiles ? filterRings(mergePolygonTiles(nucleusTiles), hidden) : null;
+            }
+        }
+        else {
+            geometryKey = `${dataset.id}|whole|${hiddenKey}`;
+            if (geometryKey === this.cellGeometryKey && this.currentRings) {
+                rings = this.currentRings;
+            }
+            else {
+                const polys = await this.port.getPolygons();
+                if (stale())
+                    return null;
+                // Whole-dataset rings are index-aligned with the observations.
+                rings = filterRings({ ...polys, observation: Uint32Array.from({ length: polys.count }, (_v, i) => i) }, hidden);
+            }
+        }
+        return { rings, nuclei, geometryKey };
+    }
+    // ── transcripts ───────────────────────────────────────────────────────────────────
+    async planTranscripts(dataset, view, rect, pxPerUnit, stale) {
+        const mode = view.transcriptMode;
+        const job = (mode === 'circles' || mode === 'glyphs')
+            && (this.port.getTranscriptTile || (this.port.getTranscriptGeneBins && dataset.transcriptGeneBins))
+            ? (view.transcriptAllGenes
+                ? this.allGenesJob(dataset, view, rect, pxPerUnit)
+                : this.geneJob(dataset, view, rect, pxPerUnit))
+            : null;
+        if (!job) {
+            this.drop('transcripts');
+            this.drop('transcriptOutline');
+            this.drawn = null;
+            this.countSource = null;
+            return;
+        }
+        // Marker sizes follow the zoom, so the zoom is part of the key; a pan that keeps
+        // the same tiles on screen changes nothing.
+        const planKey = [
+            dataset.id, mode, job.key, view.transcriptColorBy, this.cellTypeColumnName(dataset, view),
+            view.transcriptScale, view.transcriptOpacity, JSON.stringify(view.transcriptGlyphs),
+            pxPerUnit.toPrecision(4), view.hiddenGroups.join('\u0001'), view.transcriptHiddenGenes.join(','),
+            JSON.stringify(view.transcriptGeneColors), JSON.stringify(view.transcriptGeneGroups),
+        ].join('|');
+        const current = this.layers.get('transcripts');
+        if (planKey === this.keys.get('transcripts') && current && this.viewer.layers.items.includes(current)) {
+            return;
+        }
+        const loaded = await this.track('Transcripts', job.load());
+        if (stale())
+            return;
+        // Per-gene counts in view come from what was loaded, before hidden genes are dropped:
+        // a hidden gene still has transcripts there. Summed density grids (no per-gene levels,
+        // zoomed out) hold clusters, not genes: no per-gene counts there, rather than a guess.
+        this.countSource = (loaded.kind ?? job.kind) === 'genes' && !loaded.clustered
+            ? { merged: loaded.merged, genes: [...view.transcriptGenes] } : null;
+        const hidden = await this.hiddenCodes(dataset, view);
+        if (stale())
+            return;
+        // Density-grid markers carry no cells and were built from the visible genes only.
+        const filtered = loaded.clustered ? { merged: loaded.merged, px: loaded.px }
+            : filterTranscripts(loaded.merged, loaded.px, hidden, (loaded.kind ?? job.kind) === 'genes' ? hiddenGeneSlots(view) : null);
+        let { merged, px } = filtered;
+        let selectionBin = loaded.clustered?.bin ?? null;
+        let entryGroup = loaded.clustered?.group ?? null;
+        let groupNames = loaded.clustered?.names ?? null;
+        if (loaded.ladder) {
+            const g = this.groupSelection(merged, view, loaded.ladder, pxPerUnit);
+            if (g)
+                ({ merged, px, bin: selectionBin, group: entryGroup, names: groupNames } = g);
+        }
+        // A bin of the all-gene pyramid mixes genes and carries none, so it cannot be coloured
+        // by gene: colour it by its dominant cell's type until individual transcripts show.
+        const kind = loaded.kind ?? job.kind;
+        const colorView = kind === 'bins' && view.transcriptColorBy !== 'cellType'
+            ? { ...view, transcriptColorBy: 'cellType' }
+            // Density-grid markers have no cell to take a type from: they take their cluster's colour.
+            : loaded.clustered && view.transcriptColorBy === 'cellType'
+                ? { ...view, transcriptColorBy: 'cluster' } : view;
+        // Each entry's cluster: its marker's group, or the gene-tree group its gene is in.
+        const geneCluster = view.transcriptGenes.map((g) => view.transcriptGeneGroups.find((x) => x.genes.includes(g))?.name ?? g);
+        const clusterOf = (i) => (entryGroup && groupNames
+            ? groupNames[entryGroup[i]] ?? null
+            : geneCluster[merged.gene[i]] ?? null);
+        const faces = await this.transcriptColors(dataset, colorView, merged, kind === 'genes' ? clusterOf : undefined);
+        if (stale())
+            return;
+        if (this.planIncomplete)
+            this.keys.delete('transcripts');
+        else
+            this.keys.set('transcripts', planKey);
+        const diam = px.map((d) => d / pxPerUnit);
+        this.drawn = {
+            kind: loaded.kind ?? job.kind,
+            bin: selectionBin ? { size: selectionBin, origin: loaded.clustered?.origin ?? [0, 0] }
+                : (loaded.kind ? loaded.bin : job.bin),
+            merged, radius: diam.map((d) => d / 2),
+            genes: [...view.transcriptGenes], ref: dataset.imageRef ?? null, grid: null,
+            ...(entryGroup && groupNames ? { entryGroup, groupNames } : {}),
+            ...(loaded.clustered ? { groupGenes: loaded.clustered.genes } : {}),
+        };
+        this.hoverCache.clear();
+        this.micronsPerUnit = dataset.micronsPerUnit ?? null;
+        const typeColumn = this.cellTypeColumnName(dataset, view);
+        this.hoverTypes = typeColumn ? await this.categoricalCodes(typeColumn).catch(() => null) : null;
+        if (stale())
+            return;
+        const ref = dataset.imageRef;
+        const place = { scale: ref?.scale ?? [1, 1], translate: ref?.translate ?? [0, 0] };
+        if (mode === 'circles') {
+            this.drop('transcriptOutline');
+            this.drawTranscriptCircles(merged, diam, faces.rgba, view, place);
+        }
+        else {
+            this.drawTranscriptGlyphs(merged, diam, faces, view, place, pxPerUnit);
+        }
+    }
+    /** One sized circle per entry, the size saying how many transcripts it stands for. */
+    drawTranscriptCircles(merged, diam, rgba, view, { scale, translate }) {
+        const positions = new Float32Array(merged.count * 2);
+        for (let i = 0; i < merged.count; i++) {
+            positions[2 * i] = merged.x[i];
+            positions[2 * i + 1] = merged.y[i];
+        }
+        const layer = this.viewer.addPoints(positions, {
+            name: 'transcripts',
+            size: diam,
+            faceColor: rgba,
+            // A dark rim: a transcript coloured by its cell's type is otherwise the same
+            // colour as the cell fill it sits on, and vanishes into it.
+            borderColor: [0.04, 0.04, 0.05, 0.9],
+            borderWidth: 0.18 * median(diam),
+            opacity: view.transcriptOpacity,
+            scale,
+            translate,
+        });
+        this.replace('transcripts', layer);
+    }
+    drawTranscriptGlyphs(merged, diam, faces, view, { scale, translate }, pxPerUnit) {
+        // Glyphs: each entry becomes its gene's icon polygon, filled through a discrete
+        // colormap and outlined dark so small icons stay readable over the tissue. With every
+        // gene drawn there is one icon for all of them — 18,000 shapes would say nothing.
+        const genes = view.transcriptGenes;
+        const glyphFor = (slot) => view.transcriptGlyphs[genes[slot]] ?? defaultGlyphFor(slot);
+        const single = view.transcriptAllGenes
+            ? glyphOutline(view.transcriptGlyphs[ALL_GENES] ?? 'circle')
+            : null;
+        const outlines = single ? [] : genes.map((_g, slot) => glyphOutline(glyphFor(slot)));
+        const radius = diam.map((d) => d / 2);
+        const { coords, offsets } = glyphRings(merged.x, merged.y, radius, (i) => single ?? outlines[merged.gene[i]]);
+        const fill = this.viewer.addShapes(coords, offsets, {
+            name: 'transcripts',
+            draw: 'fill',
+            values: faces.values,
+            colormap: faces.colormap,
+            contrastLimits: [0, 1],
+            opacity: view.transcriptOpacity,
+            scale,
+            translate,
+        });
+        this.replace('transcripts', fill);
+        // A dark rim keeps a few large icons readable over the tissue; on many small ones the
+        // rims merge into a solid dark sheet that hides every colour, so they are left off.
+        const medianPx = median(diam) * pxPerUnit;
+        if (merged.count > GLYPH_OUTLINE_MAX || medianPx < GLYPH_OUTLINE_MIN_PX) {
+            this.drop('transcriptOutline');
+            return;
+        }
+        const edge = this.viewer.addShapes(coords, offsets, {
+            name: 'transcript outlines',
+            draw: 'outline',
+            color: [0.05, 0.05, 0.05, 1],
+            opacity: Math.min(1, view.transcriptOpacity + 0.1),
+            scale,
+            translate,
+        });
+        this.replace('transcriptOutline', edge);
+    }
+    /**
+     * Tooltip lines for the transcript marker under world point `(wx, wy)`, or null.
+     *
+     * Returns what is known at once (gene, count, cell type); anything that needs the
+     * server — distinct genes in a group, its top genes and cells, the cell's display id —
+     * arrives through `onDetails` once the pointer has rested on the marker briefly.
+     */
+    hoverAt(wx, wy, radiusWorld, onDetails) {
+        const d = this.drawn;
+        const layer = this.layers.get('transcripts');
+        if (!d || !layer || !this.viewer?.layers.items.includes(layer) || !d.merged.count) {
+            this.hoverKey = null;
+            return null;
+        }
+        const sx = d.ref?.scale?.[0] ?? 1;
+        const sy = d.ref?.scale?.[1] ?? 1;
+        const x = (wx - (d.ref?.translate?.[0] ?? 0)) / sx;
+        const y = (wy - (d.ref?.translate?.[1] ?? 0)) / sy;
+        const i = pickNearest(d, x, y, radiusWorld / Math.abs(sx));
+        if (i < 0) {
+            this.hoverKey = null;
+            return null;
+        }
+        const key = `${d.kind}|${d.merged.x[i]}|${d.merged.y[i]}|${d.merged.gene[i]}`;
+        const cached = this.hoverCache.get(key);
+        if (cached)
+            return cached;
+        if (key !== this.hoverKey) {
+            this.hoverKey = key;
+            if (this.hoverTimer)
+                clearTimeout(this.hoverTimer);
+            this.hoverTimer = setTimeout(() => void this.fetchDetails(d, i, key, onDetails), 150);
+        }
+        return this.describe(d, i, null);
+    }
+    async fetchDetails(d, i, key, onDetails) {
+        if (!this.port.getTranscriptSummary || this.hoverKey !== key)
+            return;
+        const obs = d.merged.observation[i];
+        const cells = obs === NO_OBSERVATION ? [] : [obs];
+        let box;
+        if ((d.kind === 'bins' || d.kind === 'genes') && d.bin) {
+            const { size, origin } = d.bin;
+            const bx = Math.floor((d.merged.x[i] - origin[0]) / size);
+            const by = Math.floor((d.merged.y[i] - origin[1]) / size);
+            const x0 = origin[0] + bx * size;
+            const y0 = origin[1] + by * size;
+            box = [x0, y0, x0 + size, y0 + size];
+        }
+        else if (d.kind === 'individual') {
+            const e = 0.02;
+            box = [d.merged.x[i] - e, d.merged.y[i] - e, d.merged.x[i] + e, d.merged.y[i] + e];
+        }
+        const genes = d.groupGenes && d.entryGroup ? d.groupGenes[d.entryGroup[i]] : undefined;
+        try {
+            const summary = await this.port.getTranscriptSummary({ box, cells, ...(genes ? { genes } : {}) });
+            const lines = this.describe(d, i, summary);
+            this.hoverCache.set(key, lines);
+            if (this.hoverKey === key)
+                onDetails(lines);
+        }
+        catch (err) {
+            console.warn('[napari-js] transcript details unavailable', err);
+        }
+    }
+    /** The tooltip text for entry `i`, with the server's details when they have arrived. */
+    describe(d, i, s) {
+        const t = d.merged;
+        const n = t.weight[i];
+        const obs = t.observation[i];
+        const fmt = (v) => v.toLocaleString();
+        const typeOf = (o) => {
+            const types = this.hoverTypes;
+            if (!types || o === NO_OBSERVATION || types.meta.kind !== 'categorical')
+                return null;
+            const c = types.codes[o];
+            return c === NO_CATEGORY ? null : types.meta.categories[c] ?? null;
+        };
+        const cellLine = (o, prefix) => {
+            if (o === NO_OBSERVATION)
+                return 'outside any cell';
+            const id = s?.cellIds?.[o] ?? `#${o}`;
+            const type = typeOf(o);
+            return `${prefix} ${id}${type ? ` · ${type}` : ''}`;
+        };
+        if (d.kind === 'bins') {
+            const lines = [`${fmt(n)} transcripts · all genes`];
+            if (d.bin)
+                lines.push(`${d.bin.size.toFixed(1)} × ${d.bin.size.toFixed(1)} µm area`);
+            if (s?.transcripts !== undefined) {
+                lines.push(`${fmt(s.genes ?? 0)} distinct genes · ${fmt(s.cells ?? 0)} cell${s.cells === 1 ? '' : 's'}`
+                    + (s.unassigned ? ` · ${fmt(s.unassigned)} outside cells` : ''));
+                if (s.topGenes?.length) {
+                    lines.push(`top genes: ${s.topGenes.slice(0, 5).map((g) => `${g.name} ${fmt(g.count)}`).join(', ')}`);
+                }
+            }
+            lines.push(cellLine(obs, 'mostly cell'));
+            if (!s && this.port.getTranscriptSummary)
+                lines.push('loading details…');
+            return lines;
+        }
+        if (d.kind === 'individual') {
+            const gene = s?.topGenes?.[0]?.name;
+            return [
+                gene ? `${gene} transcript` : 'Transcript',
+                cellLine(obs, 'in cell'),
+                ...(!s && this.port.getTranscriptSummary ? ['loading details…'] : []),
+            ];
+        }
+        const gene = d.genes[t.gene[i]] ?? 'transcript';
+        if (d.bin) {
+            const um = d.bin.size * (this.micronsPerUnit ?? 1);
+            const group = d.entryGroup && d.groupNames ? d.groupNames[d.entryGroup[i]] : gene;
+            const top = s?.topGenes?.length
+                ? [s.topGenes.slice(0, 6).map((g) => `${g.name} ${fmt(g.count)}`).join(', ')] : [];
+            return [
+                `${group} · ${fmt(n)} transcript${n === 1 ? '' : 's'}`,
+                ...(d.groupGenes ? top : group !== gene ? [`mostly ${gene}`] : []),
+                `${um.toFixed(1)} × ${um.toFixed(1)} µm area · zoom in to split`,
+                ...(obs === NO_OBSERVATION && d.groupGenes ? [] : [cellLine(obs, 'mostly cell')]),
+                ...(!s && d.groupGenes && this.port.getTranscriptSummary ? ['loading details…'] : []),
+            ];
+        }
+        return n > 1
+            ? [`${gene} · ${fmt(n)} transcripts`, 'grouped: zoom in to split', cellLine(obs, 'near cell')]
+            : [`${gene} transcript`, cellLine(obs, 'in cell')];
+    }
+    /** Physical marker size needs µm; null when the dataset's unit is unknown. */
+    pxPerMicron(dataset, pxPerUnit) {
+        return dataset.micronsPerUnit ? pxPerUnit / dataset.micronsPerUnit : undefined;
+    }
+    /**
+     * The chosen genes, at the level the zoom calls for — or coarser, while the markers in
+     * view would exceed the budget.
+     */
+    geneJob(dataset, view, rect, pxPerUnit) {
+        const meta = dataset.transcriptTiles;
+        const genes = view.transcriptGenes;
+        if (!meta || !genes.length)
+            return null;
+        const first = transcriptLevelFor(pxPerUnit, meta.levels);
+        const keysAt = (l) => tilesInRect(rect, l, meta.levels, meta.bounds, MAX_TRANSCRIPT_TILES);
+        const query = { genes, quality: view.transcriptQuality };
+        const pxPerMicron = this.pxPerMicron(dataset, pxPerUnit);
+        const mx = (rect.x1 - rect.x0) * 0.25;
+        const my = (rect.y1 - rect.y0) * 0.25;
+        const around = { x0: rect.x0 - mx, y0: rect.y0 - my, x1: rect.x1 + mx, y1: rect.y1 + my };
+        // Zoomed out, each gene's transcripts are grouped on the all-gene pyramid's bin ladder,
+        // so a gene selection reads like "all genes" does: one marker per gene per area, sized
+        // by how many it holds; zoomed in far enough, every transcript is its own marker.
+        const ladder = dataset.transcriptBins?.levels;
+        const baseBin = ladder?.[0]?.binSize
+            ?? (dataset.micronsPerUnit ? PYRAMID_BASE_BIN_UM / dataset.micronsPerUnit : 0);
+        const bin = geneBinSize(pxPerUnit, baseBin, ladder?.length ?? PYRAMID_LEVELS);
+        // Zoomed out to bins as wide as the density grid, a selection is drawn from the per-gene
+        // density grids — one cached request per cluster — rather than 10x's coarse per-gene
+        // tiles, which take minutes for a few hundred genes.
+        // With the pyramid's per-gene levels, every zoom of a selection reads them: the level the
+        // zoom calls for, coarser while the markers would exceed the max.
+        // Both are built from high-quality calls only: with low-quality calls included, the
+        // quality-aware tiles below serve every zoom (as long as there are tiles to serve).
+        const highOnly = view.transcriptQuality !== 'all' || !this.port.getTranscriptTile;
+        const geneBins = dataset.transcriptGeneBins;
+        const fromGeneBins = highOnly && geneBins && this.port.getTranscriptGeneBins;
+        if (fromGeneBins && (bin !== null || !this.port.getTranscriptTile)) {
+            return this.geneBinsJob(dataset, view, around, geneBins, bin ?? geneBins.levels[0].binSize, mx, my, rect);
+        }
+        const grid = dataset.density?.gridSize[0] ?? 0;
+        if (highOnly && bin !== null && grid > 0 && this.port.getDensity && bin >= grid * 0.75) {
+            return this.clusterDensityJob(dataset, view, around, pxPerUnit, Math.max(bin, grid), mx, my, rect);
+        }
+        return {
+            kind: 'genes',
+            // The clip window, in quarter-view steps: a pan past the margin re-clips.
+            key: `genes|${genes.join(',')}|${view.transcriptQuality}|${view.transcriptBudget}|${bin ?? 'each'}|`
+                + `${Math.floor(rect.x0 / (mx || 1))},${Math.floor(rect.y0 / (my || 1))}|${keysAt(first).map(tileId)}`,
+            load: async () => {
+                // The zoom's own level only: over the budget, the transcripts are combined into
+                // larger markers (groupSelection), never fetched from slower coarse levels.
+                const tiles = await this.fetchAll(keysAt(first), (k) => this.port.getTranscriptTile(k.level, k.gx, k.gy, query));
+                // Only what is on screen (and a margin, so a small pan needs nothing new) counts
+                // against the budget and the cap; a tile reaches far past the view.
+                const merged = mergeTranscriptTiles(tiles.map((t) => clipTranscripts(t, around)), MAX_TRANSCRIPTS);
+                const px = new Float32Array(merged.count);
+                for (let i = 0; i < merged.count; i++) {
+                    px[i] = transcriptMarkerPx(merged.weight[i], view.transcriptScale, pxPerMicron);
+                }
+                return baseBin > 0
+                    ? { merged, px, ladder: { baseBin, levels: ladder?.length ?? PYRAMID_LEVELS, start: bin } }
+                    : { merged, px };
+            },
+        };
+    }
+    /**
+     * A gene selection from the pyramid's per-gene levels: starting at the level whose bins are
+     * `startBin`, fetch the view's tiles for the selected genes and step to a coarser level while
+     * one marker per cluster per bin would exceed the max. Hidden genes are fetched too (their
+     * counts in view still show) and dropped before drawing; grouping by cluster happens there.
+     */
+    geneBinsJob(dataset, view, around, meta, startBin, mx, my, rect) {
+        const genes = view.transcriptGenes;
+        const levels = meta.levels;
+        let first = levels.findIndex((l) => l.binSize >= startBin * 0.999);
+        if (first < 0)
+            first = levels.length - 1;
+        const budget = Math.max(1, view.transcriptBudget);
+        const hidden = new Set(view.transcriptHiddenGenes);
+        const clusters = this.selectionClusters(view);
+        const clusterOf = new Map();
+        clusters.forEach((c, ci) => c.genes.forEach((g) => clusterOf.set(genes.indexOf(g), ci)));
+        const keysAt = (m) => tilesInRectFrom(meta.origin, around, m, levels.map((l) => ({ tileSize: l.tileSize })), null, MAX_BIN_TILES);
+        return {
+            kind: 'genes',
+            key: `gene-bins|${genes.join(',')}|${budget}|${first}|${JSON.stringify(view.transcriptGeneGroups)}|`
+                + `${Math.floor(rect.x0 / (mx || 1))},${Math.floor(rect.y0 / (my || 1))}`,
+            load: async () => {
+                let m = first;
+                for (;;) {
+                    const tiles = await this.fetchAll(keysAt(m), (k) => this.port.getTranscriptGeneBins(k.level, k.gx, k.gy, genes));
+                    const clipped = tiles.map((t) => clipTranscripts(t, around));
+                    // Past the cap a merge would drop whole genes (the tail of every tile): go coarser.
+                    if (clipped.reduce((n, t) => n + t.count, 0) > MAX_TRANSCRIPTS && m < levels.length - 1) {
+                        m++;
+                        continue;
+                    }
+                    const merged = mergeTranscriptTiles(clipped, MAX_TRANSCRIPTS);
+                    // Markers this level would draw: one per (visible cluster, bin).
+                    const seen = new Set();
+                    const bin = levels[m].binSize;
+                    for (let i = 0; i < merged.count; i++) {
+                        if (hidden.has(genes[merged.gene[i]]))
+                            continue;
+                        const c = clusterOf.get(merged.gene[i]);
+                        if (c === undefined)
+                            continue;
+                        seen.add(`${c}|${Math.floor(merged.x[i] / bin)}|${Math.floor(merged.y[i] / bin)}`);
+                    }
+                    if (seen.size <= budget || m >= levels.length - 1) {
+                        return { merged, px: new Float32Array(merged.count), ladder: { baseBin: bin, levels: 1, start: bin } };
+                    }
+                    m++;
+                }
+            },
+        };
+    }
+    /** The selection's clusters: each gene-tree group's visible genes, then each ungrouped gene. */
+    selectionClusters(view) {
+        const hidden = new Set(view.transcriptHiddenGenes);
+        const slots = new Map(view.transcriptGenes.map((g, i) => [g, i]));
+        const taken = new Set();
+        const out = [];
+        for (const g of view.transcriptGeneGroups) {
+            const genes = g.genes.filter((x) => slots.has(x) && !hidden.has(x) && !taken.has(x));
+            genes.forEach((x) => taken.add(x));
+            if (genes.length)
+                out.push({ name: g.name, genes, slot: slots.get(genes[0]) });
+        }
+        for (const gene of view.transcriptGenes) {
+            if (!taken.has(gene) && !hidden.has(gene))
+                out.push({ name: gene, genes: [gene], slot: slots.get(gene) });
+        }
+        return out;
+    }
+    /**
+     * Per-gene density grids summed for `genes`, cached (a cluster is asked for once per bin).
+     * Keyed by dataset too: this manager outlives a dataset, and another may share gene names.
+     */
+    densityFor(dataset, genes, bin) {
+        const key = `${dataset}|${bin}|${genes.join(',')}`;
+        let p = this.densityCache.get(key);
+        if (!p) {
+            p = this.port.getDensity(genes, bin);
+            p.catch(() => this.densityCache.delete(key));
+            this.densityCache.set(key, p);
+            if (this.densityCache.size > 256)
+                this.densityCache.delete(this.densityCache.keys().next().value);
+        }
+        return p;
+    }
+    /**
+     * A gene selection zoomed out: one marker per cluster per bin, from the per-gene density
+     * grids. The bin starts where markers are 14 px apart and doubles until the markers fit the
+     * max; each marker sits at the count-weighted centre of the finer grid inside it, so markers
+     * follow the tissue rather than a lattice.
+     */
+    clusterDensityJob(dataset, view, around, pxPerUnit, startBin, mx, my, rect) {
+        const grid = dataset.density.gridSize[0];
+        const clusters = this.selectionClusters(view);
+        let first = grid;
+        while (first < startBin * 0.999)
+            first *= 2;
+        const budget = Math.max(1, view.transcriptBudget);
+        return {
+            kind: 'genes',
+            key: `clusters|${clusters.map((c) => `${c.name}:${c.genes.join('+')}`).join(';')}|${budget}|${first}|`
+                + `${Math.floor(rect.x0 / (mx || 1))},${Math.floor(rect.y0 / (my || 1))}`,
+            load: async () => {
+                let bin = first;
+                for (;;) {
+                    // The finer grid gives each marker its centre; the server bins 1, 2, 4 or 8 cells.
+                    const fine = Math.min(bin >= grid * 2 ? bin / 2 : bin, grid * 8);
+                    const rasters = await Promise.all(clusters.map((c) => this.densityFor(dataset.id, c.genes, fine)));
+                    const out = clusterMarkers(rasters, clusters.map((c) => c.slot), bin, around);
+                    if (out.tile.count <= budget || bin >= grid * 2 ** 12) {
+                        const refCount = quantileOf(out.tile.weight, 0.95);
+                        const binPx = bin * pxPerUnit;
+                        const px = new Float32Array(out.tile.count);
+                        for (let i = 0; i < out.tile.count; i++) {
+                            px[i] = groupedMarkerPx(out.tile.weight[i], refCount, binPx, view.transcriptScale);
+                        }
+                        return {
+                            merged: out.tile, px, kind: 'genes',
+                            clustered: {
+                                group: out.group, names: clusters.map((c) => c.name), genes: clusters.map((c) => c.genes), bin,
+                                origin: rasters[0]?.meta.origin ?? [0, 0],
+                            },
+                        };
+                    }
+                    bin *= 2;
+                }
+            },
+        };
+    }
+    /**
+     * Every gene: the transcripts themselves once they fit the budget, else bins of the
+     * all-gene pyramid sized by how many transcripts each holds.
+     */
+    allGenesJob(dataset, view, rect, pxPerUnit) {
+        const bins = dataset.transcriptBins;
+        const tiles = dataset.transcriptTiles;
+        const bounds = bins?.bounds ?? tiles?.bounds;
+        if (!bounds)
+            return null;
+        const plan = allGenesPlan({
+            rect, bounds, pxPerUnit, budget: view.transcriptBudget,
+            total: bins?.count ?? tiles?.count ?? 0,
+            levels: bins && this.port.getTranscriptBins ? bins.levels : [],
+            canIndividual: !!tiles,
+        });
+        if (plan.kind === 'individual' && tiles) {
+            const keys = tilesInRect(rect, 0, tiles.levels, tiles.bounds, MAX_TRANSCRIPT_TILES);
+            // Each tile clipped to the view, rounded outward to 10 units so small pans hit cache.
+            const r10 = (v, up) => (up ? Math.ceil(v / 10) : Math.floor(v / 10)) * 10;
+            const size = tiles.levels[0].tileSize;
+            const boxes = keys.map((k) => [
+                Math.max(k.gx * size, r10(rect.x0, false)), Math.max(k.gy * size, r10(rect.y0, false)),
+                Math.min((k.gx + 1) * size, r10(rect.x1, true)), Math.min((k.gy + 1) * size, r10(rect.y1, true)),
+            ]);
+            const pxPerMicron = this.pxPerMicron(dataset, pxPerUnit);
+            return {
+                kind: 'individual',
+                key: `all|individual|${view.transcriptBudget}|${boxes.map((b) => b.join(',')).join(';')}`,
+                load: async () => {
+                    const got = await this.fetchAll(keys.map((k, i) => ({ ...k, box: boxes[i] })), (k) => this.port.getTranscriptTile(0, k.gx, k.gy, { genes: [ALL_GENES], box: k.box }));
+                    // The plan estimated the view from the dataset's average density; expression is
+                    // uneven, so a dense view can hold far more. Rather than cut the excess off, show
+                    // it grouped — the bin level the planner would pick if it had known.
+                    const cap = Math.max(view.transcriptBudget * 1.5, 1);
+                    const loaded = got.reduce((n, t) => n + t.count, 0);
+                    if (loaded > cap && bins && this.port.getTranscriptBins) {
+                        const fallback = allGenesPlan({
+                            rect, bounds, pxPerUnit, budget: view.transcriptBudget, total: bins.count,
+                            levels: bins.levels, canIndividual: false,
+                        });
+                        if (fallback.kind === 'bins') {
+                            const job = this.binsJob(view, rect, pxPerUnit, bounds, bins, fallback.level);
+                            return { ...(await job.load()), kind: job.kind, bin: job.bin };
+                        }
+                    }
+                    const merged = mergeTranscriptTiles(got, cap);
+                    const px = new Float32Array(merged.count);
+                    for (let i = 0; i < merged.count; i++)
+                        px[i] = transcriptMarkerPx(1, view.transcriptScale, pxPerMicron);
+                    return { merged, px };
+                },
+            };
+        }
+        if (plan.kind === 'bins' && bins && this.port.getTranscriptBins) {
+            return this.binsJob(view, rect, pxPerUnit, bounds, bins, plan.level);
+        }
+        return null;
+    }
+    /** Bins of the all-gene pyramid at `level`, sized by how many transcripts each holds. */
+    binsJob(view, rect, pxPerUnit, bounds, bins, level) {
+        const lv = bins.levels[level];
+        const keys = tilesInRectFrom(bins.origin, rect, level, bins.levels.map((l) => ({ tileSize: l.tileSize })), bounds, MAX_BIN_TILES);
+        return {
+            kind: 'bins',
+            bin: { size: lv.binSize, origin: bins.origin },
+            key: `all|bins|${level}|${view.transcriptBudget}|${keys.map(tileId)}`,
+            load: async () => {
+                const got = await this.fetchAll(keys, (k) => this.port.getTranscriptBins(k.level, k.gx, k.gy));
+                const merged = mergeTranscriptTiles(got, Math.max(view.transcriptBudget * 1.5, 1));
+                const refCount = quantileOf(merged.weight, 0.95);
+                const binPx = lv.binSize * pxPerUnit;
+                const px = new Float32Array(merged.count);
+                for (let i = 0; i < merged.count; i++) {
+                    px[i] = groupedMarkerPx(merged.weight[i], refCount, binPx, view.transcriptScale);
+                }
+                return { merged, px };
+            },
+        };
+    }
+    /** Per-entry colours both as RGBA (points) and as colormap values (glyph shapes). */
+    async transcriptColors(dataset, view, t, clusterOf) {
+        let rgb;
+        let codeOf;
+        if (view.transcriptColorBy === 'cluster' && clusterOf) {
+            // A cluster named like a group of the cells' grouping takes that group's colour, so a
+            // cluster's transcripts and its cells agree; any other cluster takes a palette colour.
+            const name = this.cellTypeColumnName(dataset, view);
+            const codes = name ? await this.categoricalCodes(name).catch(() => null) : null;
+            const cellColor = new Map();
+            if (codes?.meta.kind === 'categorical') {
+                const colors = resolveCategoryColors(codes.meta);
+                codes.meta.categories.forEach((c, k) => cellColor.set(c, colors[k]));
+            }
+            const colors = clusterColorMap(view.transcriptGenes, view.transcriptGeneGroups, cellColor, DEFAULT_CATEGORICAL_PALETTE);
+            const index = new Map();
+            const hex = [];
+            const codeFor = (cluster) => {
+                let k = index.get(cluster);
+                if (k === undefined) {
+                    k = hex.length;
+                    index.set(cluster, k);
+                    hex.push(colors.get(cluster) ?? cellColor.get(cluster) ?? DEFAULT_CATEGORICAL_PALETTE[0]);
+                }
+                return k;
+            };
+            const code = new Int32Array(t.count);
+            for (let i = 0; i < t.count; i++) {
+                const c = clusterOf(i);
+                code[i] = c === null ? -1 : codeFor(c);
+            }
+            rgb = hex.map(parseHex);
+            codeOf = (i) => code[i];
+        }
+        else if (view.transcriptColorBy === 'gene' || view.transcriptColorBy === 'cluster') {
+            // All genes: codes are the dataset's gene indices, folded onto the palette.
+            const n = view.transcriptAllGenes ? DEFAULT_CATEGORICAL_PALETTE.length : view.transcriptGenes.length;
+            rgb = Array.from({ length: n }, (_g, i) => parseHex((!view.transcriptAllGenes && view.transcriptGeneColors[view.transcriptGenes[i]])
+                || DEFAULT_CATEGORICAL_PALETTE[i % DEFAULT_CATEGORICAL_PALETTE.length]));
+            codeOf = view.transcriptAllGenes ? (i) => t.gene[i] % n : (i) => t.gene[i];
+        }
+        else {
+            const name = this.cellTypeColumnName(dataset, view);
+            const codes = name ? await this.categoricalCodes(name) : null;
+            rgb = codes?.meta.kind === 'categorical' ? resolveCategoryColors(codes.meta).map(parseHex) : [];
+            codeOf = (i) => {
+                const o = t.observation[i];
+                if (!codes || o === NO_OBSERVATION)
+                    return -1;
+                const c = codes.codes[o];
+                return c === NO_CATEGORY ? -1 : c;
+            };
+        }
+        const { stops, valueOf } = discreteColormapStops(rgb, MISSING_COLOR);
+        const rgba = new Array(t.count);
+        const values = new Float32Array(t.count);
+        const tuples = rgb.map(([r, g, b]) => [r / 255, g / 255, b / 255, 1]);
+        for (let i = 0; i < t.count; i++) {
+            const c = codeOf(i);
+            rgba[i] = c < 0 ? UNASSIGNED_RGBA : tuples[c];
+            values[i] = valueOf(c);
+        }
+        return { rgba, values, colormap: new Colormap('transcript-categories', stops) };
+    }
+    // ── density ───────────────────────────────────────────────────────────────────────
+    async planDensity(dataset, view, stale) {
+        const hiddenGenes = new Set(view.transcriptHiddenGenes);
+        const genes = view.transcriptAllGenes
+            ? [ALL_GENES]
+            : view.transcriptGenes.filter((g) => !hiddenGenes.has(g));
+        if (!dataset.density || !this.port.getDensity || view.transcriptMode !== 'density' || !genes.length) {
+            this.drop('density');
+            this.densityStats = null;
+            return;
+        }
+        const lut = lutFor(view.densityColormap ?? INFERNO_SCALE);
+        const key = [dataset.id, genes.join(','), view.densityBin, view.densityOpacity,
+            JSON.stringify(view.densityRange), JSON.stringify(view.densityColormap)].join('|');
+        if (key === this.keys.get('density') && this.layers.has('density'))
+            return;
+        const raster = await this.track('Transcript density', this.port.getDensity(genes, view.densityBin));
+        if (stale())
+            return;
+        // Bins drawn as squares, as Xenium Explorer does; the window is in transcripts/µm².
+        const meta = raster.meta;
+        const area = meta.gridSize[0] * meta.gridSize[1];
+        const perArea = raster.values.map((v) => v / area);
+        const [lo, hi] = view.densityRange ?? densityAutoRange(perArea);
+        this.densityStats = { lo, hi, max: perArea.reduce((m, v) => (v > m ? v : m), 0) };
+        const rgba = colorDensityWindow(perArea, lut, view.densityOpacity, lo, hi);
+        const ref = dataset.imageRef;
+        const sx = ref?.scale?.[0] ?? 1;
+        const sy = ref?.scale?.[1] ?? 1;
+        const layer = this.viewer.addImage({ kind: 'typed', width: meta.cols, height: meta.rows, channels: 4, dtype: 'uint8', data: rgba }, {
+            name: `density · ${view.transcriptAllGenes ? 'all genes' : genes.join(', ')}`,
+            scale: [meta.gridSize[0] * sx, meta.gridSize[1] * sy],
+            translate: [
+                meta.origin[0] * sx + (ref?.translate?.[0] ?? 0),
+                meta.origin[1] * sy + (ref?.translate?.[1] ?? 0),
+            ],
+            blending: 'translucent',
+            interpolation: 'nearest',
+        });
+        this.keys.set('density', key);
+        this.replace('density', layer);
+        this.host.densityChanged?.(this.densityStats);
+    }
+    /**
+     * Transcripts in view for the visible genes: each gene's dataset total times the share
+     * of the tissue on screen. An estimate — expression is not uniform — which is also what
+     * Xenium Explorer shows; it tells the user whether the budget will force grouping.
+     */
+    async planEstimate(dataset, view, viewer, w, h, stale) {
+        const tiles = dataset.transcriptTiles;
+        if (!tiles || !this.port.getTranscriptCounts || view.transcriptMode === 'off') {
+            this.host.estimateChanged?.(null);
+            return;
+        }
+        const hiddenGenes = new Set(view.transcriptHiddenGenes);
+        const genes = view.transcriptAllGenes ? [] : view.transcriptGenes.filter((g) => !hiddenGenes.has(g));
+        const key = `${dataset.id}|${genes.join(',')}`;
+        if (this.countsCache?.key !== key) {
+            this.countsCache = { key, counts: this.port.getTranscriptCounts(genes) };
+        }
+        let counts;
+        try {
+            counts = await this.countsCache.counts;
+        }
+        catch {
+            this.countsCache = null;
+            return;
+        }
+        if (stale())
+            return;
+        const inView = visibleDataRect(viewer.camera.center, viewer.camera.zoom, w, h, dataset.imageRef, 0);
+        if (!inView)
+            return;
+        const b = counts.bounds;
+        const share = Math.min(1, visibleArea(inView, b) / Math.max(1, (b[2] - b[0]) * (b[3] - b[1])));
+        const selected = view.transcriptAllGenes
+            ? counts.total
+            : genes.reduce((sum, g) => sum + (counts.counts[g] ?? 0), 0);
+        this.host.estimateChanged?.({ points: Math.round(selected * share), max: view.transcriptBudget });
+    }
+    // ── layer bookkeeping ─────────────────────────────────────────────────────────────
+    /**
+     * Fetch every tile, drawing what arrived. A failure does not fail the view, but it marks the
+     * plan incomplete: the caller must not cache it as done, and `plan()` retries it.
+     */
+    async fetchAll(keys, load) {
+        const settled = await Promise.allSettled(keys.map(load));
+        const out = [];
+        for (const s of settled) {
+            if (s.status === 'fulfilled')
+                out.push(s.value);
+            else
+                console.warn('[napari-js] spatial tile failed', s.reason);
+        }
+        if (out.length < keys.length)
+            this.planIncomplete = true;
+        return out;
+    }
+    /**
+     * Put a shapes layer in place for `group`: a geometry change builds a new layer, a
+     * colour-only change mutates values/colormap on the existing one.
+     */
+    upsertShapes(group, wanted, geometryChanged, rings, opts) {
+        if (!wanted) {
+            this.drop(group);
+            return;
+        }
+        const existing = this.layers.get(group);
+        if (existing && !geometryChanged && this.viewer.layers.items.includes(existing)) {
+            // Flat colour has no values; clearing them is what switches the layer to `color`.
+            existing.values = opts.values ?? null;
+            if (opts.colormap)
+                existing.colormap = opts.colormap;
+            if (opts.contrastLimits)
+                existing.contrastLimits = opts.contrastLimits;
+            if (opts.color)
+                existing.color = opts.color;
+            if (opts.opacity !== undefined)
+                existing.opacity = opts.opacity;
+            this.viewer.requestRender();
+            return;
+        }
+        const layer = this.viewer.addShapes(rings.coords, rings.offsets, opts);
+        this.replace(group, layer);
+    }
+    /**
+     * Install `layer` as `group`'s layer and restore the order of the groups above it.
+     * The layer was just added by the caller (so it is on top); groups that belong above
+     * it are removed and re-added.
+     */
+    replace(group, layer) {
+        const v = this.viewer;
+        const old = this.layers.get(group);
+        if (old && old !== layer && v.layers.items.includes(old))
+            v.layers.remove(old);
+        this.layers.set(group, layer);
+        for (const g of ORDER.slice(ORDER.indexOf(group) + 1)) {
+            const above = this.layers.get(g);
+            if (!above || !v.layers.items.includes(above))
+                continue;
+            v.layers.remove(above);
+            v.layers.add(above);
+        }
+        v.requestRender();
+    }
+    drop(group) {
+        const layer = this.layers.get(group);
+        if (layer && this.viewer?.layers.items.includes(layer))
+            this.viewer.layers.remove(layer);
+        this.layers.delete(group);
+        this.keys.delete(group);
+    }
+    dropCells() {
+        this.drop('cellFill');
+        this.drop('cellOutline');
+        this.drop('nucleusOutline');
+        this.currentNuclei = null;
+        this.cellGeometryKey = null;
+        this.cellStyleKey = null;
+        this.currentRings = null;
+        this.setPolygonsShown(false);
+    }
+    setPolygonsShown(shown) {
+        if (shown === this.polygonsShown)
+            return;
+        this.polygonsShown = shown;
+        this.host.polygonsShownChanged(shown);
+    }
+}
+/** Index of the entry under `(x, y)` — within its own radius or `tolerance` — or -1. */
+export function pickNearest(d, x, y, tolerance) {
+    const t = d.merged;
+    if (!d.grid) {
+        let maxR = 0;
+        for (let i = 0; i < t.count; i++)
+            if (d.radius[i] > maxR)
+                maxR = d.radius[i];
+        const size = Math.max(maxR * 2, tolerance * 2, 1e-6);
+        const buckets = new Map();
+        for (let i = 0; i < t.count; i++) {
+            const k = bucketKey(Math.floor(t.x[i] / size), Math.floor(t.y[i] / size));
+            let b = buckets.get(k);
+            if (!b)
+                buckets.set(k, (b = []));
+            b.push(i);
+        }
+        d.grid = { size, buckets };
+    }
+    const { size, buckets } = d.grid;
+    const gx = Math.floor(x / size);
+    const gy = Math.floor(y / size);
+    let best = -1;
+    let bestD = Infinity;
+    for (let dy = -1; dy <= 1; dy++) {
+        for (let dx = -1; dx <= 1; dx++) {
+            for (const i of buckets.get(bucketKey(gx + dx, gy + dy)) ?? []) {
+                const dist = Math.hypot(t.x[i] - x, t.y[i] - y);
+                if (dist <= Math.max(d.radius[i], tolerance) && dist < bestD) {
+                    bestD = dist;
+                    best = i;
+                }
+            }
+        }
+    }
+    return best;
+}
+function bucketKey(gx, gy) {
+    return (gx + 32768) * 65536 + (gy + 32768);
+}
+/** Rings whose owning cell is in a switched-off group removed. */
+export function filterRings(rings, hidden) {
+    if (!hidden)
+        return rings;
+    const keep = [];
+    let vertices = 0;
+    for (let i = 0; i < rings.count; i++) {
+        const code = hidden.codes[rings.observation[i]];
+        if (code !== NO_CATEGORY && hidden.hidden[code])
+            continue;
+        keep.push(i);
+        vertices += rings.offsets[i + 1] - rings.offsets[i];
+    }
+    if (keep.length === rings.count)
+        return rings;
+    const observation = new Uint32Array(keep.length);
+    const offsets = new Uint32Array(keep.length + 1);
+    const coords = new Float32Array(vertices * 2);
+    let v = 0;
+    keep.forEach((i, r) => {
+        observation[r] = rings.observation[i];
+        offsets[r] = v;
+        const a = rings.offsets[i] * 2;
+        const b = rings.offsets[i + 1] * 2;
+        coords.set(rings.coords.subarray(a, b), v * 2);
+        v += (b - a) / 2;
+    });
+    offsets[keep.length] = v;
+    return { count: keep.length, observation, offsets, coords };
+}
+/** Slots (indices into the selected genes) switched off with their eye toggle. */
+function hiddenGeneSlots(view) {
+    if (!view.transcriptHiddenGenes.length)
+        return null;
+    const off = new Set(view.transcriptHiddenGenes);
+    return Uint8Array.from(view.transcriptGenes, (g) => (off.has(g) ? 1 : 0));
+}
+/** Entries in a hidden group's cell, or of a hidden gene, removed (with their sizes). */
+export function filterTranscripts(t, px, hidden, hiddenGenes) {
+    if (!hidden && !hiddenGenes)
+        return { merged: t, px };
+    const keep = [];
+    for (let i = 0; i < t.count; i++) {
+        if (hiddenGenes && hiddenGenes[t.gene[i]])
+            continue;
+        const o = t.observation[i];
+        if (hidden && o !== NO_OBSERVATION) {
+            const code = hidden.codes[o];
+            if (code !== NO_CATEGORY && hidden.hidden[code])
+                continue;
+        }
+        keep.push(i);
+    }
+    const pick = (a) => {
+        const out = new a.constructor(keep.length);
+        keep.forEach((i, k) => { out[k] = a[i]; });
+        return out;
+    };
+    return {
+        merged: {
+            count: keep.length, aggregated: t.aggregated, x: pick(t.x), y: pick(t.y), z: pick(t.z),
+            weight: pick(t.weight), observation: pick(t.observation), gene: pick(t.gene),
+        },
+        px: pick(px),
+    };
+}
+function median(v) {
+    if (!v.length)
+        return 0;
+    const step = Math.max(1, Math.floor(v.length / 1024));
+    const sample = [];
+    for (let i = 0; i < v.length; i += step)
+        sample.push(v[i]);
+    sample.sort((a, b) => a - b);
+    return sample[sample.length >> 1];
+}
+/** Concatenate tiles' rings into one set, dropping rings already seen (a cell straddling
+ *  two tiles may be listed by both). */
+export function mergePolygonTiles(tiles) {
+    const seen = new Set();
+    let rings = 0;
+    let vertices = 0;
+    for (const t of tiles) {
+        for (let i = 0; i < t.count; i++) {
+            if (seen.has(t.observation[i]))
+                continue;
+            seen.add(t.observation[i]);
+            rings++;
+            vertices += t.offsets[i + 1] - t.offsets[i];
+        }
+    }
+    seen.clear();
+    const observation = new Uint32Array(rings);
+    const offsets = new Uint32Array(rings + 1);
+    const coords = new Float32Array(vertices * 2);
+    let r = 0;
+    let v = 0;
+    for (const t of tiles) {
+        for (let i = 0; i < t.count; i++) {
+            const o = t.observation[i];
+            if (seen.has(o))
+                continue;
+            seen.add(o);
+            observation[r] = o;
+            offsets[r] = v;
+            const a = t.offsets[i] * 2;
+            const b = t.offsets[i + 1] * 2;
+            coords.set(t.coords.subarray(a, b), v * 2);
+            v += (b - a) / 2;
+            r++;
+        }
+    }
+    offsets[rings] = v;
+    return { count: rings, observation, offsets, coords };
+}
+/** Concatenate transcript tiles, stopping at `limit` entries. */
+export function mergeTranscriptTiles(tiles, limit = Infinity) {
+    let n = 0;
+    for (const t of tiles)
+        n += t.count;
+    n = Math.min(n, limit);
+    const out = {
+        count: n,
+        aggregated: tiles.some((t) => t.aggregated),
+        x: new Float32Array(n), y: new Float32Array(n), z: new Float32Array(n),
+        weight: new Uint32Array(n), observation: new Uint32Array(n), gene: new Uint16Array(n),
+    };
+    let o = 0;
+    for (const t of tiles) {
+        const k = Math.min(t.count, n - o);
+        if (k <= 0)
+            break;
+        for (const f of ['x', 'y', 'z', 'weight', 'observation', 'gene']) {
+            out[f].set(t[f].subarray(0, k), o);
+        }
+        o += k;
+    }
+    return out;
+}
+/**
+ * One marker per (cluster, `bin` square) from per-cluster density grids: the counts of the grid
+ * cells inside `area` summed per square, at their count-weighted centre. `slots[c]` is the gene
+ * slot whose icon cluster c's markers take.
+ */
+export function clusterMarkers(rasters, slots, bin, area) {
+    const x = [];
+    const y = [];
+    const w = [];
+    const gene = [];
+    const group = [];
+    rasters.forEach((r, c) => {
+        const [cw, ch] = r.meta.gridSize;
+        const [ox, oy] = r.meta.origin;
+        const { rows, cols } = r.meta;
+        const c0 = Math.max(0, Math.floor((area.x0 - ox) / cw));
+        const c1 = Math.min(cols - 1, Math.floor((area.x1 - ox) / cw));
+        const r0 = Math.max(0, Math.floor((area.y0 - oy) / ch));
+        const r1 = Math.min(rows - 1, Math.floor((area.y1 - oy) / ch));
+        const squares = new Map();
+        for (let row = r0; row <= r1; row++) {
+            for (let col = c0; col <= c1; col++) {
+                const v = r.values[row * cols + col];
+                if (!(v > 0))
+                    continue;
+                const cx = ox + (col + 0.5) * cw;
+                const cy = oy + (row + 0.5) * ch;
+                const key = Math.floor((cy - oy) / bin) * 1e6 + Math.floor((cx - ox) / bin);
+                const s = squares.get(key) ?? { n: 0, sx: 0, sy: 0 };
+                s.n += v;
+                s.sx += v * cx;
+                s.sy += v * cy;
+                squares.set(key, s);
+            }
+        }
+        for (const s of squares.values()) {
+            x.push(s.sx / s.n);
+            y.push(s.sy / s.n);
+            w.push(Math.round(s.n));
+            gene.push(slots[c]);
+            group.push(c);
+        }
+    });
+    const n = w.length;
+    return {
+        tile: {
+            count: n, aggregated: true,
+            x: Float32Array.from(x), y: Float32Array.from(y), z: new Float32Array(n),
+            weight: Uint32Array.from(w), observation: new Uint32Array(n).fill(NO_OBSERVATION),
+            gene: Uint16Array.from(gene),
+        },
+        group: Int32Array.from(group),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-spatial-tiles.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-spatial-tiles.ts"],"names":[],"mappings":"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","sourcesContent":["import { Colormap, colormapFromLut } from 'napari-js';\nimport type { ImageLayer, Layer, RGBA, ShapesLayer, Viewer } from 'napari-js';\n\nimport type { Rgb } from '../../contracts/colormap-lut';\nimport { ALL_GENES, type SpatialDataPort } from '../../contracts/ports/spatial-data.port';\nimport type { SpatialViewState } from '../../contracts/display-types';\nimport {\n  NO_CATEGORY, NO_OBSERVATION, SpatialBounds, SpatialColumn, SpatialDataset, SpatialDensityRaster, SpatialImageRef,\n  SpatialPolygonTile,\n  SpatialPolygons, SpatialTranscriptCounts, SpatialTranscriptSummary, SpatialTranscriptTile,\n  isCategoricalColumn,\n} from '../../contracts/spatial-dataset.contract';\nimport {\n  DEFAULT_CATEGORICAL_PALETTE, MISSING_COLOR, contrastWindow, lutFor, parseHex, resolveCategoryColors,\n} from '../../spatial/spatial-encoding';\nimport { SpatialSelectionMask } from '../../spatial/spatial-selection';\nimport {\n  DataRect, INFERNO_SCALE, POLYGON_LEVEL_MIN_CELL_PX, TranscriptGlyph, allGenesPlan, cellTypeColumnFor,\n  cellsShown, colorDensityWindow, densityAutoRange, groupedMarkerPx, quantileOf, tilesInRectFrom,\n  defaultGlyphFor, discreteColormapStops, glyphOutline, glyphRings, pixelsPerDataUnit,\n  polygonLevelFor, tileId, tilesInRect, transcriptLevelFor, transcriptMarkerPx,\n  typicalCellDiameter, visibleArea, visibleDataRect, geneBinSize, groupTranscripts, clipTranscripts,\n  clusterColorMap,\n} from '../../spatial/spatial-tiles';\n\n/** The all-gene pyramid's finest bin (250 µm source tiles / 128) and default level count, used\n *  to group a gene selection on the same ladder when a dataset has no pyramid. */\nconst PYRAMID_BASE_BIN_UM = 250 / 128;\nconst PYRAMID_LEVELS = 7;\n/** Icons get a dark rim only while there are at most this many, at least this big (px). */\nconst GLYPH_OUTLINE_MAX = 20_000;\nconst GLYPH_OUTLINE_MIN_PX = 8;\n\n/**\n * Level-of-detail cell outlines, transcripts and transcript density for the 2D spatial view.\n *\n * WHY A SEPARATE CLASS\n * --------------------\n * Everything else the spatial view draws is built once per (dataset, view) and only\n * restyled afterwards. These layers also depend on the CAMERA: which tiles are on screen\n * and which level of detail the zoom calls for. Keeping that loop — plan on camera idle,\n * fetch tiles, merge, draw — out of the visualizer service keeps both readable.\n *\n * LAYER ORDER\n * -----------\n * napari-js's layer list is append-only (add / remove / clear), so order is kept by\n * re-adding: cell fill, cell outline, the transcript density, then transcripts on top.\n * The service's observation markers sit under all of them; while outlines are drawn the\n * markers are hidden (a cell is its outline then, not a dot), so the cells never have to\n * be ordered against them. The density goes OVER the markers on purpose: under 10^5\n * dots it would only show in the gaps between cells. {@link afterObservations} restores\n * the order after the service re-adds its markers.\n *\n * ONE LAYER PER GROUP\n * -------------------\n * Each group is one merged layer over every visible tile, rebuilt when the tile set or\n * level changes. Recolouring (a new cell-type column, a selection) only rewrites the\n * per-shape values — the geometry is not re-expanded.\n */\nexport interface SpatialTileHost {\n  /** Latest dataset/view/selection, as the spatial subscription saw them. */\n  latest(): [SpatialDataset | null, SpatialViewState, SpatialSelectionMask] | null;\n  /** Canvas size in CSS pixels. */\n  canvasSize(): [number, number];\n  /** The continuous LUT the view is using (so cells coloured by a gene match the markers). */\n  continuousLut(view: SpatialViewState): Rgb[];\n  /** Outlines appeared or disappeared: the markers' visibility follows. */\n  polygonsShownChanged(shown: boolean): void;\n  /** The density window changed (auto-derived or set). */\n  densityChanged?(stats: { lo: number; hi: number; max: number }): void;\n  /** Estimated transcripts in view for the current selection, against the budget. */\n  estimateChanged?(estimate: TranscriptEstimate | null): void;\n  /** Transcripts of each selected gene inside the view, or null when not known. */\n  geneCountsChanged?(counts: Record<string, number> | null): void;\n  /** The layers whose data is in flight now (\"Transcripts\", \"Cells\"…); empty when none. */\n  loadingChanged?(layers: string[]): void;\n}\n\n/** Xenium Explorer's \"Estimated Transcript Points\". */\nexport interface TranscriptEstimate {\n  /** Transcripts of the visible genes estimated to be in view. */\n  points: number;\n  /** The marker budget. */\n  max: number;\n}\n\ntype Group = 'density' | 'cellFill' | 'cellOutline' | 'nucleusOutline' | 'transcripts' | 'transcriptOutline';\nconst ORDER: Group[] = [\n  'cellFill', 'cellOutline', 'nucleusOutline', 'density', 'transcripts', 'transcriptOutline',\n];\n\n/** Transcripts drawn at once. Past this a screen is solid colour anyway; the level\n *  policy keeps a normal view far below it. */\nconst MAX_TRANSCRIPTS = 400_000;\nconst MAX_CELL_TILES = 48;\nconst MAX_TRANSCRIPT_TILES = 36;\nconst MAX_BIN_TILES = 64;\n\n/** A transcript fetch the planner can key before running. */\ninterface TranscriptJob {\n  /** What one entry is — decides what hovering it says. */\n  kind: 'genes' | 'individual' | 'bins';\n  /** For bins: their size and grid origin, so a hovered bin's square can be recovered. */\n  bin?: { size: number; origin: [number, number] };\n  /** Identifies what will be drawn, so an unchanged plan is a no-op. */\n  key: string;\n  /** Fetch and merge; `px` is each entry's marker diameter in screen pixels. A job may\n   *  switch to another kind once it sees the data (individual → bins); it then says so. */\n  load(): Promise<TranscriptLoad>;\n}\n\ninterface TranscriptLoad {\n  merged: SpatialTranscriptTile;\n  px: Float32Array;\n  /** For a gene selection: group it on this bin ladder once hidden genes are dropped. */\n  ladder?: { baseBin: number; levels: number; start: number | null };\n  /** Already one marker per cluster per bin (zoomed out, from the density grids): no cells. */\n  clustered?: { group: Int32Array; names: string[]; genes: string[][]; bin: number; origin: [number, number] };\n  kind?: TranscriptJob['kind'];\n  bin?: TranscriptJob['bin'];\n}\n\n/** Where a layer sits in world space: the dataset's affine onto its tissue image. */\ninterface Placement { scale: [number, number]; translate: [number, number] }\n\n/** Transcript colours: per-entry RGBA for points, values + colormap for shapes. */\ninterface TranscriptFaces { rgba: RGBA[]; values: Float32Array; colormap: Colormap }\nconst CAMERA_IDLE_MS = 120;\n/** First retry of a view with a failed tile; doubles each time, up to MAX_TILE_RETRIES. */\nconst TILE_RETRY_MS = 1000;\nconst MAX_TILE_RETRIES = 3;\n\nconst UNASSIGNED_RGBA: RGBA = [0.62, 0.62, 0.62, 0.55];\n\nexport class NapariSpatialTileLayers {\n  private viewer: Viewer | null = null;\n  private cameraOff: (() => void) | null = null;\n  private timer: ReturnType<typeof setTimeout> | null = null;\n  /** Set when a tile of the current plan failed to load (see fetchAll). */\n  private planIncomplete = false;\n  /** Consecutive retries of an incomplete view. */\n  private tileRetries = 0;\n  private token = 0;\n  private readonly layers = new Map<Group, Layer>();\n  /** What each group currently shows, so an unchanged plan is a no-op. */\n  private readonly keys = new Map<Group, string>();\n  private polygonsShown = false;\n  /** Rings currently drawn and the (dataset, set, tiles) they came from. */\n  private currentRings: SpatialPolygonTile | null = null;\n  private cellGeometryKey: string | null = null;\n  private currentNuclei: SpatialPolygonTile | null = null;\n  private cellStyleKey: string | null = null;\n  /** Selection identity → revision, so a change key can name a selection cheaply. */\n  private lastSelection: SpatialSelectionMask | null = null;\n  private selectionRevision = 0;\n\n  constructor(private readonly port: SpatialDataPort, private readonly host: SpatialTileHost) {}\n\n  // ── lifecycle ─────────────────────────────────────────────────────────────────────\n\n  attach(viewer: Viewer): void {\n    if (this.viewer === viewer) return;\n    this.detach();\n    this.viewer = viewer;\n    this.cameraOff = viewer.camera.changed.connect(() => this.schedule());\n  }\n\n  /**\n   * Group a gene selection for the zoom: one marker per gene-tree cluster (a gene in no\n   * cluster is its own) per bin of the pyramid ladder, starting at the finest bin whose\n   * markers are 14 px apart and stepping up while the markers would exceed the budget.\n   * Null to draw every transcript: zoomed in, with the selection within the budget.\n   */\n  private groupSelection(\n    t: SpatialTranscriptTile, view: SpatialViewState, ladder: NonNullable<TranscriptLoad['ladder']>,\n    pxPerUnit: number,\n  ): { merged: SpatialTranscriptTile; px: Float32Array; bin: number; group: Int32Array; names: string[] } | null {\n    const budget = Math.max(1, view.transcriptBudget);\n    const genes = view.transcriptGenes;\n    const groups = view.transcriptGeneGroups;\n    const names = [...groups.map((g) => g.name), ...genes];\n    const clusterOf = genes.map((gene, slot) => {\n      const g = groups.findIndex((x) => x.genes.includes(gene));\n      return g >= 0 ? g : groups.length + slot;\n    });\n    const keyOf = (slot: number) => clusterOf[slot] ?? groups.length + slot;\n    let bin = ladder.start;\n    if (bin === null) {\n      // Every transcript, if they fit the max and none was cut off at the cap.\n      if (t.count <= budget && t.count < MAX_TRANSCRIPTS) return null;\n      bin = ladder.baseBin;\n    }\n    const top = ladder.baseBin * 2 ** (ladder.levels - 1);\n    let grouped = groupTranscripts(t, bin, keyOf);\n    // Over the max: combine into larger markers, a level at a time.\n    while (grouped.tile.count > budget && bin < top) {\n      bin *= 2;\n      grouped = groupTranscripts(t, bin, keyOf);\n    }\n    const refCount = quantileOf(grouped.tile.weight, 0.95);\n    const binPx = bin * pxPerUnit;\n    const px = new Float32Array(grouped.tile.count);\n    for (let i = 0; i < grouped.tile.count; i++) {\n      px[i] = groupedMarkerPx(grouped.tile.weight[i], refCount, binPx, view.transcriptScale);\n    }\n    return { merged: grouped.tile, px, bin, group: grouped.group, names };\n  }\n\n  /** µm per observation unit of the drawn dataset, for describing a grouped marker's area. */\n  private micronsPerUnit: number | null = null;\n\n  /** Loads in flight, per layer label, for the loading badge. */\n  private readonly loading = new Map<string, number>();\n\n  /** Report `label` loading while `work` is in flight. */\n  private async track<T>(label: string, work: Promise<T>): Promise<T> {\n    this.loading.set(label, (this.loading.get(label) ?? 0) + 1);\n    this.host.loadingChanged?.([...this.loading.keys()]);\n    try {\n      return await work;\n    } finally {\n      const n = (this.loading.get(label) ?? 1) - 1;\n      if (n > 0) this.loading.set(label, n);\n      else this.loading.delete(label);\n      this.host.loadingChanged?.([...this.loading.keys()]);\n    }\n  }\n\n  /** The loaded per-gene transcripts the in-view counts are taken from. */\n  private countSource: { merged: SpatialTranscriptTile; genes: string[] } | null = null;\n\n  /**\n   * Transcripts of each selected gene inside `rect`: each entry counts for the transcripts it\n   * stands for (an aggregate at a coarse level holds several). Null without per-gene data.\n   */\n  geneCountsIn(rect: DataRect): Record<string, number> | null {\n    const src = this.countSource;\n    if (!src) return null;\n    const out: Record<string, number> = {};\n    for (const g of src.genes) out[g] = 0;\n    const { x, y, weight, gene } = src.merged;\n    for (let i = 0; i < src.merged.count; i++) {\n      if (x[i] < rect.x0 || x[i] > rect.x1 || y[i] < rect.y0 || y[i] > rect.y1) continue;\n      const name = src.genes[gene[i]];\n      if (name !== undefined) out[name] += weight[i];\n    }\n    return out;\n  }\n\n  /** Whether `layer` is one of the overlays drawn here (density, cells, transcripts). */\n  owns(layer: Layer): boolean {\n    for (const l of this.layers.values()) if (l === layer) return true;\n    return false;\n  }\n\n  detach(): void {\n    if (this.hoverTimer) clearTimeout(this.hoverTimer);\n    this.hoverTimer = null;\n    this.drawn = null;\n    this.cameraOff?.();\n    this.cameraOff = null;\n    if (this.timer) clearTimeout(this.timer);\n    this.timer = null;\n    this.token++;\n    this.tileRetries = 0;\n    this.countSource = null;\n    this.loading.clear();\n    this.host.loadingChanged?.([]);\n    if (this.viewer) {\n      for (const layer of this.layers.values()) {\n        if (this.viewer.layers.items.includes(layer)) this.viewer.layers.remove(layer);\n      }\n    }\n    this.layers.clear();\n    this.keys.clear();\n    this.setPolygonsShown(false);\n    this.viewer = null;\n  }\n\n  /** True while outlines are on screen — the service hides its dots then. */\n  get outlinesShown(): boolean {\n    return this.polygonsShown;\n  }\n\n  /** Dataset, view or selection changed: re-plan now rather than on camera idle. */\n  refresh(): void {\n    this.schedule(0);\n  }\n\n  /** Called right after the service adds its marker layer: everything goes back on top. */\n  afterObservations(): void {\n    const v = this.viewer;\n    if (!v) return;\n    for (const g of ORDER) {\n      const layer = this.layers.get(g);\n      if (!layer) continue;\n      if (v.layers.items.includes(layer)) v.layers.remove(layer);\n      v.layers.add(layer);\n    }\n  }\n\n  // ── planning ──────────────────────────────────────────────────────────────────────\n\n  private schedule(delay = CAMERA_IDLE_MS): void {\n    if (this.timer) clearTimeout(this.timer);\n    this.timer = setTimeout(() => {\n      this.timer = null;\n      void this.plan();\n    }, delay);\n  }\n\n  private async plan(): Promise<void> {\n    const viewer = this.viewer;\n    const latest = this.host.latest();\n    if (!viewer || !latest) return;\n    const [dataset, view, selection] = latest;\n    const token = ++this.token;\n    const stale = () => token !== this.token || this.viewer !== viewer;\n    this.planIncomplete = false;\n\n    if (!dataset) {\n      for (const g of ORDER) this.drop(g);\n      this.dropCells();\n      return;\n    }\n    const [w, h] = this.host.canvasSize();\n    const ref = dataset.imageRef;\n    const rect = visibleDataRect(viewer.camera.center, viewer.camera.zoom, w, h, ref);\n    const pxPerUnit = pixelsPerDataUnit(viewer.camera.zoom, ref);\n    if (!rect) return;\n\n    void this.planEstimate(dataset, view, viewer, w, h, stale);\n    await Promise.all([\n      this.planDensity(dataset, view, stale),\n      this.planCells(dataset, view, selection, rect, pxPerUnit, stale),\n      this.planTranscripts(dataset, view, rect, pxPerUnit, stale),\n    ]);\n    if (stale()) return;\n    this.host.geneCountsChanged?.(this.geneCountsIn(rect));\n    // A tile that failed left a hole the cache keys do not record, so try the same view\n    // again, backing off, a bounded number of times.\n    if (!this.planIncomplete) {\n      this.tileRetries = 0;\n    } else if (this.tileRetries < MAX_TILE_RETRIES) {\n      this.schedule(TILE_RETRY_MS * 2 ** this.tileRetries++);\n    }\n  }\n\n  // ── cells ─────────────────────────────────────────────────────────────────────────\n\n  private async planCells(\n    dataset: SpatialDataset, view: SpatialViewState, selection: SpatialSelectionMask,\n    rect: DataRect, pxPerUnit: number, stale: () => boolean,\n  ): Promise<void> {\n    const tiled = dataset.polygonTiles;\n    const whole = !tiled && dataset.polygons && this.port.getPolygons;\n    if (!cellsShown(dataset, view) || (!tiled && !whole)) {\n      this.dropCells();\n      return;\n    }\n    const diameter = typicalCellDiameter(dataset.observations.radius);\n    // Whole-dataset rings have one level and no coarser fallback, so they are drawn as\n    // soon as a cell is big enough to read as a shape rather than a dot.\n    const level = tiled\n      ? polygonLevelFor(pxPerUnit, diameter, tiled.levels.length)\n      : (pxPerUnit * diameter >= POLYGON_LEVEL_MIN_CELL_PX[2] ? 0 : -1);\n    if (level < 0) {\n      this.dropCells();\n      return;\n    }\n\n    // Groups switched off in the list: their cells are left out of the geometry.\n    const hidden = await this.hiddenCodes(dataset, view);\n    if (stale()) return;\n    const label = view.cellSet === 'both' ? 'Cells and nuclei'\n      : view.cellSet === 'nucleus' ? 'Nuclei' : 'Cells';\n    const geometry = await this.track(label, this.cellGeometry(dataset, view, rect, level, hidden, stale));\n    if (!geometry) return;\n    const { rings, nuclei, geometryKey } = geometry;\n\n    const geometryChanged = geometryKey !== this.cellGeometryKey;\n    const styleKey = [\n      geometryKey, view.cellColorMode, view.cellColorGene, view.cellSingleColor,\n      this.cellTypeColumnName(dataset, view),\n      this.selectionRev(selection), view.logScale, view.percentileClip.join(),\n      JSON.stringify(view.continuousColormap), view.cellDraw, view.cellOpacity,\n    ].join('|');\n    const present = ['cellFill', 'cellOutline', 'nucleusOutline'].some((g) => {\n      const l = this.layers.get(g as Group);\n      return l && this.viewer!.layers.items.includes(l);\n    });\n    if (!geometryChanged && styleKey === this.cellStyleKey && present) {\n      this.setPolygonsShown(true);\n      return;\n    }\n    const colors = await this.cellColors(dataset, view, selection, rings.observation);\n    if (stale()) return;\n\n    this.currentRings = rings;\n    this.currentNuclei = nuclei;\n    // A geometry missing a failed tile is drawn but not remembered, so the retry refetches it.\n    this.cellGeometryKey = this.planIncomplete ? null : geometryKey;\n    this.cellStyleKey = styleKey;\n    const ref = dataset.imageRef;\n    const common = { scale: ref?.scale ?? [1, 1], translate: ref?.translate ?? [0, 0] } as const;\n    const fill = view.cellDraw !== 'outline';\n    const outline = view.cellDraw !== 'fill';\n\n    this.upsertShapes('cellFill', fill, geometryChanged, rings, {\n      name: 'cells', draw: 'fill', opacity: view.cellOpacity, ...colors, ...common,\n    });\n    this.upsertShapes('cellOutline', outline, geometryChanged, rings, fill\n      // Over a fill, a dark outline separates neighbours of the same type.\n      ? { name: 'cell outlines', draw: 'outline', color: [0.08, 0.08, 0.1, 1], opacity: 0.7, ...common }\n      : { name: 'cell outlines', draw: 'outline', opacity: 1, ...colors, ...common });\n    // \"Both\": nuclei outlined over the cells, light so they read against any fill.\n    if (nuclei) {\n      this.upsertShapes('nucleusOutline', true, geometryChanged, nuclei, {\n        name: 'nucleus outlines', draw: 'outline', color: [0.95, 0.95, 0.98, 1], opacity: 0.8, ...common,\n      });\n    } else {\n      this.drop('nucleusOutline');\n    }\n    this.setPolygonsShown(true);\n  }\n\n  private selectionRev(selection: SpatialSelectionMask): number {\n    if (selection !== this.lastSelection) {\n      this.lastSelection = selection;\n      this.selectionRevision++;\n    }\n    return this.selectionRevision;\n  }\n\n  /** Per-shape values + colormap for the rings' owners. */\n  /**\n   * Per-shape values + colormap for the rings' owners, by the view's cell-colour mode\n   * (Xenium Explorer's \"Cell Color\"). A selection mutes what it leaves out.\n   */\n  private async cellColors(\n    dataset: SpatialDataset, view: SpatialViewState, selection: SpatialSelectionMask,\n    owners: Uint32Array,\n  ): Promise<{ values?: Float32Array; colormap?: Colormap; contrastLimits?: [number, number]; color?: RGBA }> {\n    const muted = selection.count > 0 ? selection.mask : null;\n    const mode = view.cellColorMode;\n\n    if (mode === 'single') {\n      const [r, g, b] = parseHex(view.cellSingleColor);\n      return { color: [r / 255, g / 255, b / 255, 1] };\n    }\n\n    const continuous = async (raw: Float32Array, log: boolean) => {\n      const values = new Float32Array(owners.length);\n      for (let i = 0; i < owners.length; i++) {\n        const v = raw[owners[i]] ?? NaN;\n        values[i] = log ? Math.log1p(Math.max(0, v)) : v;\n      }\n      const [lo, hi] = contrastWindow(\n        log ? raw.map((v) => Math.log1p(Math.max(0, v))) : raw,\n        view.percentileClip[0], view.percentileClip[1],\n      );\n      return {\n        values,\n        colormap: colormapFromLut('spatial-continuous', this.host.continuousLut(view)),\n        contrastLimits: [lo, hi] as [number, number],\n      };\n    };\n    if (mode === 'gene' && view.cellColorGene) {\n      return continuous(await this.port.getFeatureVector(view.cellColorGene), true);\n    }\n    if (mode === 'transcriptDensity' && dataset.columns.some((c) => c.name === 'transcript_density')) {\n      const column = await this.port.getColumn('transcript_density');\n      if (!isCategoricalColumn(column)) return continuous(column.values, false);\n    }\n\n    const name = mode === 'segmentation' && dataset.columns.some((c) => c.name === 'segmentation_method')\n      ? 'segmentation_method'\n      : this.cellTypeColumnName(dataset, view);\n    const codes = name ? await this.categoricalCodes(name) : null;\n    const { colormap, valueOf } = this.categoricalColormap(codes?.meta ?? null);\n    const values = new Float32Array(owners.length);\n    for (let i = 0; i < owners.length; i++) {\n      const o = owners[i];\n      const code = !codes || (muted && !muted[o]) ? -1 : codes.codes[o];\n      values[i] = valueOf(code === NO_CATEGORY ? -1 : code);\n    }\n    return { values, colormap, contrastLimits: [0, 1] };\n  }\n\n  /** Codes of the group column that are switched off, or null when none are. */\n  private async hiddenCodes(\n    dataset: SpatialDataset, view: SpatialViewState,\n  ): Promise<{ codes: Uint16Array; hidden: Uint8Array } | null> {\n    if (!view.hiddenGroups.length) return null;\n    const name = this.cellTypeColumnName(dataset, view);\n    const col = name ? await this.categoricalCodes(name) : null;\n    if (!col || col.meta.kind !== 'categorical') return null;\n    const off = new Set(view.hiddenGroups);\n    const hidden = Uint8Array.from(col.meta.categories, (c) => (off.has(c) ? 1 : 0));\n    return { codes: col.codes, hidden };\n  }\n\n  private cellTypeColumnName(dataset: SpatialDataset, view: SpatialViewState): string | null {\n    return cellTypeColumnFor(dataset, view);\n  }\n\n  private async categoricalCodes(name: string):\n    Promise<{ codes: Uint16Array; meta: SpatialColumn['meta'] } | null> {\n    const column = await this.port.getColumn(name);\n    return isCategoricalColumn(column) ? { codes: column.codes, meta: column.meta } : null;\n  }\n\n  private categoricalColormap(meta: SpatialColumn['meta'] | null):\n    { colormap: Colormap; valueOf: (code: number) => number; rgb: Rgb[] } {\n    const hex = meta && meta.kind === 'categorical'\n      ? resolveCategoryColors(meta)\n      : [DEFAULT_CATEGORICAL_PALETTE[0]];\n    const rgb = hex.map(parseHex);\n    const { stops, valueOf } = discreteColormapStops(rgb, MISSING_COLOR);\n    return { colormap: new Colormap('spatial-categories', stops), valueOf, rgb };\n  }\n\n  /**\n   * The cell rings (and, for \"both\", the nucleus rings) covering `rect` at `level`, minus\n   * the hidden groups — reused when nothing that decides them changed. Null when the\n   * view went stale or the dataset has no set to draw.\n   */\n  private async cellGeometry(\n    dataset: SpatialDataset, view: SpatialViewState, rect: DataRect, level: number,\n    hidden: { codes: Uint16Array; hidden: Uint8Array } | null, stale: () => boolean,\n  ): Promise<{ rings: SpatialPolygonTile; nuclei: SpatialPolygonTile | null; geometryKey: string } | null> {\n    const tiled = dataset.polygonTiles;\n    const hiddenKey = view.hiddenGroups.join('\\u0001');\n    let rings: SpatialPolygonTile;\n    let nuclei: SpatialPolygonTile | null = null;\n    let geometryKey: string;\n    if (tiled) {\n      const both = view.cellSet === 'both';\n      const set = !both && view.cellSet && tiled.sets.some((s) => s.name === view.cellSet)\n        ? view.cellSet : (tiled.defaultSet ?? tiled.sets[0]?.name);\n      if (!set) return null;\n      const nucleusSet = both ? tiled.sets.find((s) => s.name !== set)?.name : undefined;\n      const keys = tilesInRect(rect, level, tiled.levels, tiled.bounds, MAX_CELL_TILES);\n      geometryKey = `${dataset.id}|${set}|${nucleusSet ?? ''}|${hiddenKey}|${keys.map(tileId).join(',')}`;\n      if (geometryKey === this.cellGeometryKey && this.currentRings) {\n        rings = this.currentRings;\n        nuclei = this.currentNuclei;\n      } else {\n        const [tiles, nucleusTiles] = await Promise.all([\n          this.fetchAll(keys, (k) => this.port.getPolygonTile!(set, k.level, k.gx, k.gy)),\n          nucleusSet\n            ? this.fetchAll(keys, (k) => this.port.getPolygonTile!(nucleusSet, k.level, k.gx, k.gy))\n            : Promise.resolve(null),\n        ]);\n        if (stale()) return null;\n        rings = filterRings(mergePolygonTiles(tiles), hidden);\n        nuclei = nucleusTiles ? filterRings(mergePolygonTiles(nucleusTiles), hidden) : null;\n      }\n    } else {\n      geometryKey = `${dataset.id}|whole|${hiddenKey}`;\n      if (geometryKey === this.cellGeometryKey && this.currentRings) {\n        rings = this.currentRings;\n      } else {\n        const polys: SpatialPolygons = await this.port.getPolygons!();\n        if (stale()) return null;\n        // Whole-dataset rings are index-aligned with the observations.\n        rings = filterRings(\n          { ...polys, observation: Uint32Array.from({ length: polys.count }, (_v, i) => i) }, hidden,\n        );\n      }\n    }\n    return { rings, nuclei, geometryKey };\n  }\n\n  // ── transcripts ───────────────────────────────────────────────────────────────────\n\n  private async planTranscripts(\n    dataset: SpatialDataset, view: SpatialViewState, rect: DataRect, pxPerUnit: number,\n    stale: () => boolean,\n  ): Promise<void> {\n    const mode = view.transcriptMode;\n    const job = (mode === 'circles' || mode === 'glyphs')\n      && (this.port.getTranscriptTile || (this.port.getTranscriptGeneBins && dataset.transcriptGeneBins))\n      ? (view.transcriptAllGenes\n        ? this.allGenesJob(dataset, view, rect, pxPerUnit)\n        : this.geneJob(dataset, view, rect, pxPerUnit))\n      : null;\n    if (!job) {\n      this.drop('transcripts');\n      this.drop('transcriptOutline');\n      this.drawn = null;\n      this.countSource = null;\n      return;\n    }\n    // Marker sizes follow the zoom, so the zoom is part of the key; a pan that keeps\n    // the same tiles on screen changes nothing.\n    const planKey = [\n      dataset.id, mode, job.key, view.transcriptColorBy, this.cellTypeColumnName(dataset, view),\n      view.transcriptScale, view.transcriptOpacity, JSON.stringify(view.transcriptGlyphs),\n      pxPerUnit.toPrecision(4), view.hiddenGroups.join('\\u0001'), view.transcriptHiddenGenes.join(','),\n      JSON.stringify(view.transcriptGeneColors), JSON.stringify(view.transcriptGeneGroups),\n    ].join('|');\n    const current = this.layers.get('transcripts');\n    if (planKey === this.keys.get('transcripts') && current && this.viewer!.layers.items.includes(current)) {\n      return;\n    }\n    const loaded = await this.track('Transcripts', job.load());\n    if (stale()) return;\n    // Per-gene counts in view come from what was loaded, before hidden genes are dropped:\n    // a hidden gene still has transcripts there. Summed density grids (no per-gene levels,\n    // zoomed out) hold clusters, not genes: no per-gene counts there, rather than a guess.\n    this.countSource = (loaded.kind ?? job.kind) === 'genes' && !loaded.clustered\n      ? { merged: loaded.merged, genes: [...view.transcriptGenes] } : null;\n    const hidden = await this.hiddenCodes(dataset, view);\n    if (stale()) return;\n    // Density-grid markers carry no cells and were built from the visible genes only.\n    const filtered = loaded.clustered ? { merged: loaded.merged, px: loaded.px }\n      : filterTranscripts(loaded.merged, loaded.px, hidden,\n        (loaded.kind ?? job.kind) === 'genes' ? hiddenGeneSlots(view) : null);\n    let { merged, px } = filtered;\n    let selectionBin: number | null = loaded.clustered?.bin ?? null;\n    let entryGroup: Int32Array | null = loaded.clustered?.group ?? null;\n    let groupNames: string[] | null = loaded.clustered?.names ?? null;\n    if (loaded.ladder) {\n      const g = this.groupSelection(merged, view, loaded.ladder, pxPerUnit);\n      if (g) ({ merged, px, bin: selectionBin, group: entryGroup, names: groupNames } = g);\n    }\n    // A bin of the all-gene pyramid mixes genes and carries none, so it cannot be coloured\n    // by gene: colour it by its dominant cell's type until individual transcripts show.\n    const kind = loaded.kind ?? job.kind;\n    const colorView = kind === 'bins' && view.transcriptColorBy !== 'cellType'\n      ? { ...view, transcriptColorBy: 'cellType' as const }\n      // Density-grid markers have no cell to take a type from: they take their cluster's colour.\n      : loaded.clustered && view.transcriptColorBy === 'cellType'\n        ? { ...view, transcriptColorBy: 'cluster' as const } : view;\n    // Each entry's cluster: its marker's group, or the gene-tree group its gene is in.\n    const geneCluster = view.transcriptGenes.map((g) =>\n      view.transcriptGeneGroups.find((x) => x.genes.includes(g))?.name ?? g);\n    const clusterOf = (i: number): string | null => (entryGroup && groupNames\n      ? groupNames[entryGroup[i]] ?? null\n      : geneCluster[merged.gene[i]] ?? null);\n    const faces = await this.transcriptColors(dataset, colorView, merged, kind === 'genes' ? clusterOf : undefined);\n    if (stale()) return;\n\n    if (this.planIncomplete) this.keys.delete('transcripts');\n    else this.keys.set('transcripts', planKey);\n    const diam = px.map((d) => d / pxPerUnit);\n    this.drawn = {\n      kind: loaded.kind ?? job.kind,\n      bin: selectionBin ? { size: selectionBin, origin: loaded.clustered?.origin ?? [0, 0] }\n        : (loaded.kind ? loaded.bin : job.bin),\n      merged, radius: diam.map((d) => d / 2),\n      genes: [...view.transcriptGenes], ref: dataset.imageRef ?? null, grid: null,\n      ...(entryGroup && groupNames ? { entryGroup, groupNames } : {}),\n      ...(loaded.clustered ? { groupGenes: loaded.clustered.genes } : {}),\n    };\n    this.hoverCache.clear();\n    this.micronsPerUnit = dataset.micronsPerUnit ?? null;\n    const typeColumn = this.cellTypeColumnName(dataset, view);\n    this.hoverTypes = typeColumn ? await this.categoricalCodes(typeColumn).catch(() => null) : null;\n    if (stale()) return;\n    const ref = dataset.imageRef;\n    const place: Placement = { scale: ref?.scale ?? [1, 1], translate: ref?.translate ?? [0, 0] };\n    if (mode === 'circles') {\n      this.drop('transcriptOutline');\n      this.drawTranscriptCircles(merged, diam, faces.rgba, view, place);\n    } else {\n      this.drawTranscriptGlyphs(merged, diam, faces, view, place, pxPerUnit);\n    }\n  }\n\n  /** One sized circle per entry, the size saying how many transcripts it stands for. */\n  private drawTranscriptCircles(\n    merged: SpatialTranscriptTile, diam: Float32Array, rgba: RGBA[], view: SpatialViewState,\n    { scale, translate }: Placement,\n  ): void {\n    const positions = new Float32Array(merged.count * 2);\n    for (let i = 0; i < merged.count; i++) {\n      positions[2 * i] = merged.x[i];\n      positions[2 * i + 1] = merged.y[i];\n    }\n    const layer = this.viewer!.addPoints(positions, {\n      name: 'transcripts',\n      size: diam,\n      faceColor: rgba,\n      // A dark rim: a transcript coloured by its cell's type is otherwise the same\n      // colour as the cell fill it sits on, and vanishes into it.\n      borderColor: [0.04, 0.04, 0.05, 0.9],\n      borderWidth: 0.18 * median(diam),\n      opacity: view.transcriptOpacity,\n      scale,\n      translate,\n    });\n    this.replace('transcripts', layer);\n  }\n\n  private drawTranscriptGlyphs(\n    merged: SpatialTranscriptTile, diam: Float32Array, faces: TranscriptFaces, view: SpatialViewState,\n    { scale, translate }: Placement, pxPerUnit: number,\n  ): void {\n    // Glyphs: each entry becomes its gene's icon polygon, filled through a discrete\n    // colormap and outlined dark so small icons stay readable over the tissue. With every\n    // gene drawn there is one icon for all of them — 18,000 shapes would say nothing.\n    const genes = view.transcriptGenes;\n    const glyphFor = (slot: number): TranscriptGlyph =>\n      (view.transcriptGlyphs[genes[slot]] as TranscriptGlyph | undefined) ?? defaultGlyphFor(slot);\n    const single = view.transcriptAllGenes\n      ? glyphOutline((view.transcriptGlyphs[ALL_GENES] as TranscriptGlyph | undefined) ?? 'circle')\n      : null;\n    const outlines = single ? [] : genes.map((_g, slot) => glyphOutline(glyphFor(slot)));\n    const radius = diam.map((d) => d / 2);\n    const { coords, offsets } = glyphRings(\n      merged.x, merged.y, radius, (i) => single ?? outlines[merged.gene[i]],\n    );\n    const fill = this.viewer!.addShapes(coords, offsets, {\n      name: 'transcripts',\n      draw: 'fill',\n      values: faces.values,\n      colormap: faces.colormap,\n      contrastLimits: [0, 1],\n      opacity: view.transcriptOpacity,\n      scale,\n      translate,\n    });\n    this.replace('transcripts', fill);\n    // A dark rim keeps a few large icons readable over the tissue; on many small ones the\n    // rims merge into a solid dark sheet that hides every colour, so they are left off.\n    const medianPx = median(diam) * pxPerUnit;\n    if (merged.count > GLYPH_OUTLINE_MAX || medianPx < GLYPH_OUTLINE_MIN_PX) {\n      this.drop('transcriptOutline');\n      return;\n    }\n    const edge = this.viewer!.addShapes(coords, offsets, {\n      name: 'transcript outlines',\n      draw: 'outline',\n      color: [0.05, 0.05, 0.05, 1],\n      opacity: Math.min(1, view.transcriptOpacity + 0.1),\n      scale,\n      translate,\n    });\n    this.replace('transcriptOutline', edge);\n  }\n\n  // ── hover ─────────────────────────────────────────────────────────────────────────\n\n  private drawn: DrawnTranscripts | null = null;\n  private hoverTypes: { codes: Uint16Array; meta: SpatialColumn['meta'] } | null = null;\n  /** Details already fetched, by hovered entry. */\n  private readonly hoverCache = new Map<string, string[]>();\n  private hoverKey: string | null = null;\n  private hoverTimer: ReturnType<typeof setTimeout> | null = null;\n\n  /**\n   * Tooltip lines for the transcript marker under world point `(wx, wy)`, or null.\n   *\n   * Returns what is known at once (gene, count, cell type); anything that needs the\n   * server — distinct genes in a group, its top genes and cells, the cell's display id —\n   * arrives through `onDetails` once the pointer has rested on the marker briefly.\n   */\n  hoverAt(\n    wx: number, wy: number, radiusWorld: number, onDetails: (lines: string[]) => void,\n  ): string[] | null {\n    const d = this.drawn;\n    const layer = this.layers.get('transcripts');\n    if (!d || !layer || !this.viewer?.layers.items.includes(layer) || !d.merged.count) {\n      this.hoverKey = null;\n      return null;\n    }\n    const sx = d.ref?.scale?.[0] ?? 1;\n    const sy = d.ref?.scale?.[1] ?? 1;\n    const x = (wx - (d.ref?.translate?.[0] ?? 0)) / sx;\n    const y = (wy - (d.ref?.translate?.[1] ?? 0)) / sy;\n    const i = pickNearest(d, x, y, radiusWorld / Math.abs(sx));\n    if (i < 0) {\n      this.hoverKey = null;\n      return null;\n    }\n    const key = `${d.kind}|${d.merged.x[i]}|${d.merged.y[i]}|${d.merged.gene[i]}`;\n    const cached = this.hoverCache.get(key);\n    if (cached) return cached;\n    if (key !== this.hoverKey) {\n      this.hoverKey = key;\n      if (this.hoverTimer) clearTimeout(this.hoverTimer);\n      this.hoverTimer = setTimeout(() => void this.fetchDetails(d, i, key, onDetails), 150);\n    }\n    return this.describe(d, i, null);\n  }\n\n  private async fetchDetails(\n    d: DrawnTranscripts, i: number, key: string, onDetails: (lines: string[]) => void,\n  ): Promise<void> {\n    if (!this.port.getTranscriptSummary || this.hoverKey !== key) return;\n    const obs = d.merged.observation[i];\n    const cells = obs === NO_OBSERVATION ? [] : [obs];\n    let box: [number, number, number, number] | undefined;\n    if ((d.kind === 'bins' || d.kind === 'genes') && d.bin) {\n      const { size, origin } = d.bin;\n      const bx = Math.floor((d.merged.x[i] - origin[0]) / size);\n      const by = Math.floor((d.merged.y[i] - origin[1]) / size);\n      const x0 = origin[0] + bx * size;\n      const y0 = origin[1] + by * size;\n      box = [x0, y0, x0 + size, y0 + size];\n    } else if (d.kind === 'individual') {\n      const e = 0.02;\n      box = [d.merged.x[i] - e, d.merged.y[i] - e, d.merged.x[i] + e, d.merged.y[i] + e];\n    }\n    const genes = d.groupGenes && d.entryGroup ? d.groupGenes[d.entryGroup[i]] : undefined;\n    try {\n      const summary = await this.port.getTranscriptSummary({ box, cells, ...(genes ? { genes } : {}) });\n      const lines = this.describe(d, i, summary);\n      this.hoverCache.set(key, lines);\n      if (this.hoverKey === key) onDetails(lines);\n    } catch (err) {\n      console.warn('[napari-js] transcript details unavailable', err);\n    }\n  }\n\n  /** The tooltip text for entry `i`, with the server's details when they have arrived. */\n  private describe(d: DrawnTranscripts, i: number, s: SpatialTranscriptSummary | null): string[] {\n    const t = d.merged;\n    const n = t.weight[i];\n    const obs = t.observation[i];\n    const fmt = (v: number) => v.toLocaleString();\n    const typeOf = (o: number) => {\n      const types = this.hoverTypes;\n      if (!types || o === NO_OBSERVATION || types.meta.kind !== 'categorical') return null;\n      const c = types.codes[o];\n      return c === NO_CATEGORY ? null : types.meta.categories[c] ?? null;\n    };\n    const cellLine = (o: number, prefix: string) => {\n      if (o === NO_OBSERVATION) return 'outside any cell';\n      const id = s?.cellIds?.[o] ?? `#${o}`;\n      const type = typeOf(o);\n      return `${prefix} ${id}${type ? ` · ${type}` : ''}`;\n    };\n\n    if (d.kind === 'bins') {\n      const lines = [`${fmt(n)} transcripts · all genes`];\n      if (d.bin) lines.push(`${d.bin.size.toFixed(1)} × ${d.bin.size.toFixed(1)} µm area`);\n      if (s?.transcripts !== undefined) {\n        lines.push(`${fmt(s.genes ?? 0)} distinct genes · ${fmt(s.cells ?? 0)} cell${s.cells === 1 ? '' : 's'}`\n          + (s.unassigned ? ` · ${fmt(s.unassigned)} outside cells` : ''));\n        if (s.topGenes?.length) {\n          lines.push(`top genes: ${s.topGenes.slice(0, 5).map((g) => `${g.name} ${fmt(g.count)}`).join(', ')}`);\n        }\n      }\n      lines.push(cellLine(obs, 'mostly cell'));\n      if (!s && this.port.getTranscriptSummary) lines.push('loading details…');\n      return lines;\n    }\n    if (d.kind === 'individual') {\n      const gene = s?.topGenes?.[0]?.name;\n      return [\n        gene ? `${gene} transcript` : 'Transcript',\n        cellLine(obs, 'in cell'),\n        ...(!s && this.port.getTranscriptSummary ? ['loading details…'] : []),\n      ];\n    }\n    const gene = d.genes[t.gene[i]] ?? 'transcript';\n    if (d.bin) {\n      const um = d.bin.size * (this.micronsPerUnit ?? 1);\n      const group = d.entryGroup && d.groupNames ? d.groupNames[d.entryGroup[i]] : gene;\n      const top = s?.topGenes?.length\n        ? [s.topGenes.slice(0, 6).map((g) => `${g.name} ${fmt(g.count)}`).join(', ')] : [];\n      return [\n        `${group} · ${fmt(n)} transcript${n === 1 ? '' : 's'}`,\n        ...(d.groupGenes ? top : group !== gene ? [`mostly ${gene}`] : []),\n        `${um.toFixed(1)} × ${um.toFixed(1)} µm area · zoom in to split`,\n        ...(obs === NO_OBSERVATION && d.groupGenes ? [] : [cellLine(obs, 'mostly cell')]),\n        ...(!s && d.groupGenes && this.port.getTranscriptSummary ? ['loading details…'] : []),\n      ];\n    }\n    return n > 1\n      ? [`${gene} · ${fmt(n)} transcripts`, 'grouped: zoom in to split', cellLine(obs, 'near cell')]\n      : [`${gene} transcript`, cellLine(obs, 'in cell')];\n  }\n\n  /** Physical marker size needs µm; null when the dataset's unit is unknown. */\n  private pxPerMicron(dataset: SpatialDataset, pxPerUnit: number): number | undefined {\n    return dataset.micronsPerUnit ? pxPerUnit / dataset.micronsPerUnit : undefined;\n  }\n\n  /**\n   * The chosen genes, at the level the zoom calls for — or coarser, while the markers in\n   * view would exceed the budget.\n   */\n  private geneJob(\n    dataset: SpatialDataset, view: SpatialViewState, rect: DataRect, pxPerUnit: number,\n  ): TranscriptJob | null {\n    const meta = dataset.transcriptTiles;\n    const genes = view.transcriptGenes;\n    if (!meta || !genes.length) return null;\n    const first = transcriptLevelFor(pxPerUnit, meta.levels);\n    const keysAt = (l: number) => tilesInRect(rect, l, meta.levels, meta.bounds, MAX_TRANSCRIPT_TILES);\n    const query = { genes, quality: view.transcriptQuality };\n    const pxPerMicron = this.pxPerMicron(dataset, pxPerUnit);\n    const mx = (rect.x1 - rect.x0) * 0.25;\n    const my = (rect.y1 - rect.y0) * 0.25;\n    const around: DataRect = { x0: rect.x0 - mx, y0: rect.y0 - my, x1: rect.x1 + mx, y1: rect.y1 + my };\n    // Zoomed out, each gene's transcripts are grouped on the all-gene pyramid's bin ladder,\n    // so a gene selection reads like \"all genes\" does: one marker per gene per area, sized\n    // by how many it holds; zoomed in far enough, every transcript is its own marker.\n    const ladder = dataset.transcriptBins?.levels;\n    const baseBin = ladder?.[0]?.binSize\n      ?? (dataset.micronsPerUnit ? PYRAMID_BASE_BIN_UM / dataset.micronsPerUnit : 0);\n    const bin = geneBinSize(pxPerUnit, baseBin, ladder?.length ?? PYRAMID_LEVELS);\n    // Zoomed out to bins as wide as the density grid, a selection is drawn from the per-gene\n    // density grids — one cached request per cluster — rather than 10x's coarse per-gene\n    // tiles, which take minutes for a few hundred genes.\n    // With the pyramid's per-gene levels, every zoom of a selection reads them: the level the\n    // zoom calls for, coarser while the markers would exceed the max.\n    // Both are built from high-quality calls only: with low-quality calls included, the\n    // quality-aware tiles below serve every zoom (as long as there are tiles to serve).\n    const highOnly = view.transcriptQuality !== 'all' || !this.port.getTranscriptTile;\n    const geneBins = dataset.transcriptGeneBins;\n    const fromGeneBins = highOnly && geneBins && this.port.getTranscriptGeneBins;\n    if (fromGeneBins && (bin !== null || !this.port.getTranscriptTile)) {\n      return this.geneBinsJob(dataset, view, around, geneBins, bin ?? geneBins.levels[0].binSize, mx, my, rect);\n    }\n    const grid = dataset.density?.gridSize[0] ?? 0;\n    if (highOnly && bin !== null && grid > 0 && this.port.getDensity && bin >= grid * 0.75) {\n      return this.clusterDensityJob(dataset, view, around, pxPerUnit, Math.max(bin, grid), mx, my, rect);\n    }\n    return {\n      kind: 'genes',\n      // The clip window, in quarter-view steps: a pan past the margin re-clips.\n      key: `genes|${genes.join(',')}|${view.transcriptQuality}|${view.transcriptBudget}|${bin ?? 'each'}|`\n        + `${Math.floor(rect.x0 / (mx || 1))},${Math.floor(rect.y0 / (my || 1))}|${keysAt(first).map(tileId)}`,\n      load: async () => {\n        // The zoom's own level only: over the budget, the transcripts are combined into\n        // larger markers (groupSelection), never fetched from slower coarse levels.\n        const tiles = await this.fetchAll(keysAt(first),\n          (k) => this.port.getTranscriptTile!(k.level, k.gx, k.gy, query));\n        // Only what is on screen (and a margin, so a small pan needs nothing new) counts\n        // against the budget and the cap; a tile reaches far past the view.\n        const merged = mergeTranscriptTiles(tiles.map((t) => clipTranscripts(t, around)), MAX_TRANSCRIPTS);\n        const px = new Float32Array(merged.count);\n        for (let i = 0; i < merged.count; i++) {\n          px[i] = transcriptMarkerPx(merged.weight[i], view.transcriptScale, pxPerMicron);\n        }\n        return baseBin > 0\n          ? { merged, px, ladder: { baseBin, levels: ladder?.length ?? PYRAMID_LEVELS, start: bin } }\n          : { merged, px };\n      },\n    };\n  }\n\n  /**\n   * A gene selection from the pyramid's per-gene levels: starting at the level whose bins are\n   * `startBin`, fetch the view's tiles for the selected genes and step to a coarser level while\n   * one marker per cluster per bin would exceed the max. Hidden genes are fetched too (their\n   * counts in view still show) and dropped before drawing; grouping by cluster happens there.\n   */\n  private geneBinsJob(\n    dataset: SpatialDataset, view: SpatialViewState, around: DataRect,\n    meta: NonNullable<SpatialDataset['transcriptGeneBins']>, startBin: number, mx: number, my: number, rect: DataRect,\n  ): TranscriptJob {\n    const genes = view.transcriptGenes;\n    const levels = meta.levels;\n    let first = levels.findIndex((l) => l.binSize >= startBin * 0.999);\n    if (first < 0) first = levels.length - 1;\n    const budget = Math.max(1, view.transcriptBudget);\n    const hidden = new Set(view.transcriptHiddenGenes);\n    const clusters = this.selectionClusters(view);\n    const clusterOf = new Map<number, number>();\n    clusters.forEach((c, ci) => c.genes.forEach((g) => clusterOf.set(genes.indexOf(g), ci)));\n    const keysAt = (m: number) => tilesInRectFrom(meta.origin, around, m,\n      levels.map((l) => ({ tileSize: l.tileSize })), null, MAX_BIN_TILES);\n    return {\n      kind: 'genes',\n      key: `gene-bins|${genes.join(',')}|${budget}|${first}|${JSON.stringify(view.transcriptGeneGroups)}|`\n        + `${Math.floor(rect.x0 / (mx || 1))},${Math.floor(rect.y0 / (my || 1))}`,\n      load: async () => {\n        let m = first;\n        for (;;) {\n          const tiles = await this.fetchAll(keysAt(m),\n            (k) => this.port.getTranscriptGeneBins!(k.level, k.gx, k.gy, genes));\n          const clipped = tiles.map((t) => clipTranscripts(t, around));\n          // Past the cap a merge would drop whole genes (the tail of every tile): go coarser.\n          if (clipped.reduce((n, t) => n + t.count, 0) > MAX_TRANSCRIPTS && m < levels.length - 1) {\n            m++;\n            continue;\n          }\n          const merged = mergeTranscriptTiles(clipped, MAX_TRANSCRIPTS);\n          // Markers this level would draw: one per (visible cluster, bin).\n          const seen = new Set<string>();\n          const bin = levels[m].binSize;\n          for (let i = 0; i < merged.count; i++) {\n            if (hidden.has(genes[merged.gene[i]])) continue;\n            const c = clusterOf.get(merged.gene[i]);\n            if (c === undefined) continue;\n            seen.add(`${c}|${Math.floor(merged.x[i] / bin)}|${Math.floor(merged.y[i] / bin)}`);\n          }\n          if (seen.size <= budget || m >= levels.length - 1) {\n            return { merged, px: new Float32Array(merged.count), ladder: { baseBin: bin, levels: 1, start: bin } };\n          }\n          m++;\n        }\n      },\n    };\n  }\n\n  /** The selection's clusters: each gene-tree group's visible genes, then each ungrouped gene. */\n  private selectionClusters(view: SpatialViewState): { name: string; genes: string[]; slot: number }[] {\n    const hidden = new Set(view.transcriptHiddenGenes);\n    const slots = new Map(view.transcriptGenes.map((g, i) => [g, i]));\n    const taken = new Set<string>();\n    const out: { name: string; genes: string[]; slot: number }[] = [];\n    for (const g of view.transcriptGeneGroups) {\n      const genes = g.genes.filter((x) => slots.has(x) && !hidden.has(x) && !taken.has(x));\n      genes.forEach((x) => taken.add(x));\n      if (genes.length) out.push({ name: g.name, genes, slot: slots.get(genes[0])! });\n    }\n    for (const gene of view.transcriptGenes) {\n      if (!taken.has(gene) && !hidden.has(gene)) out.push({ name: gene, genes: [gene], slot: slots.get(gene)! });\n    }\n    return out;\n  }\n\n  /**\n   * Per-gene density grids summed for `genes`, cached (a cluster is asked for once per bin).\n   * Keyed by dataset too: this manager outlives a dataset, and another may share gene names.\n   */\n  private densityFor(dataset: string, genes: string[], bin: number): Promise<SpatialDensityRaster> {\n    const key = `${dataset}|${bin}|${genes.join(',')}`;\n    let p = this.densityCache.get(key);\n    if (!p) {\n      p = this.port.getDensity!(genes, bin);\n      p.catch(() => this.densityCache.delete(key));\n      this.densityCache.set(key, p);\n      if (this.densityCache.size > 256) this.densityCache.delete(this.densityCache.keys().next().value!);\n    }\n    return p;\n  }\n\n  private readonly densityCache = new Map<string, Promise<SpatialDensityRaster>>();\n\n  /**\n   * A gene selection zoomed out: one marker per cluster per bin, from the per-gene density\n   * grids. The bin starts where markers are 14 px apart and doubles until the markers fit the\n   * max; each marker sits at the count-weighted centre of the finer grid inside it, so markers\n   * follow the tissue rather than a lattice.\n   */\n  private clusterDensityJob(\n    dataset: SpatialDataset, view: SpatialViewState, around: DataRect, pxPerUnit: number, startBin: number,\n    mx: number, my: number, rect: DataRect,\n  ): TranscriptJob {\n    const grid = dataset.density!.gridSize[0];\n    const clusters = this.selectionClusters(view);\n    let first = grid;\n    while (first < startBin * 0.999) first *= 2;\n    const budget = Math.max(1, view.transcriptBudget);\n    return {\n      kind: 'genes',\n      key: `clusters|${clusters.map((c) => `${c.name}:${c.genes.join('+')}`).join(';')}|${budget}|${first}|`\n        + `${Math.floor(rect.x0 / (mx || 1))},${Math.floor(rect.y0 / (my || 1))}`,\n      load: async () => {\n        let bin = first;\n        for (;;) {\n          // The finer grid gives each marker its centre; the server bins 1, 2, 4 or 8 cells.\n          const fine = Math.min(bin >= grid * 2 ? bin / 2 : bin, grid * 8);\n          const rasters = await Promise.all(clusters.map((c) => this.densityFor(dataset.id, c.genes, fine)));\n          const out = clusterMarkers(rasters, clusters.map((c) => c.slot), bin, around);\n          if (out.tile.count <= budget || bin >= grid * 2 ** 12) {\n            const refCount = quantileOf(out.tile.weight, 0.95);\n            const binPx = bin * pxPerUnit;\n            const px = new Float32Array(out.tile.count);\n            for (let i = 0; i < out.tile.count; i++) {\n              px[i] = groupedMarkerPx(out.tile.weight[i], refCount, binPx, view.transcriptScale);\n            }\n            return {\n              merged: out.tile, px, kind: 'genes',\n              clustered: {\n                group: out.group, names: clusters.map((c) => c.name), genes: clusters.map((c) => c.genes), bin,\n                origin: rasters[0]?.meta.origin ?? [0, 0],\n              },\n            };\n          }\n          bin *= 2;\n        }\n      },\n    };\n  }\n\n  /**\n   * Every gene: the transcripts themselves once they fit the budget, else bins of the\n   * all-gene pyramid sized by how many transcripts each holds.\n   */\n  private allGenesJob(\n    dataset: SpatialDataset, view: SpatialViewState, rect: DataRect, pxPerUnit: number,\n  ): TranscriptJob | null {\n    const bins = dataset.transcriptBins;\n    const tiles = dataset.transcriptTiles;\n    const bounds = bins?.bounds ?? tiles?.bounds;\n    if (!bounds) return null;\n    const plan = allGenesPlan({\n      rect, bounds, pxPerUnit, budget: view.transcriptBudget,\n      total: bins?.count ?? tiles?.count ?? 0,\n      levels: bins && this.port.getTranscriptBins ? bins.levels : [],\n      canIndividual: !!tiles,\n    });\n\n    if (plan.kind === 'individual' && tiles) {\n      const keys = tilesInRect(rect, 0, tiles.levels, tiles.bounds, MAX_TRANSCRIPT_TILES);\n      // Each tile clipped to the view, rounded outward to 10 units so small pans hit cache.\n      const r10 = (v: number, up: boolean) => (up ? Math.ceil(v / 10) : Math.floor(v / 10)) * 10;\n      const size = tiles.levels[0].tileSize;\n      const boxes = keys.map((k): [number, number, number, number] => [\n        Math.max(k.gx * size, r10(rect.x0, false)), Math.max(k.gy * size, r10(rect.y0, false)),\n        Math.min((k.gx + 1) * size, r10(rect.x1, true)), Math.min((k.gy + 1) * size, r10(rect.y1, true)),\n      ]);\n      const pxPerMicron = this.pxPerMicron(dataset, pxPerUnit);\n      return {\n        kind: 'individual',\n        key: `all|individual|${view.transcriptBudget}|${boxes.map((b) => b.join(',')).join(';')}`,\n        load: async () => {\n          const got = await this.fetchAll(keys.map((k, i) => ({ ...k, box: boxes[i] })),\n            (k) => this.port.getTranscriptTile!(0, k.gx, k.gy, { genes: [ALL_GENES], box: k.box }));\n          // The plan estimated the view from the dataset's average density; expression is\n          // uneven, so a dense view can hold far more. Rather than cut the excess off, show\n          // it grouped — the bin level the planner would pick if it had known.\n          const cap = Math.max(view.transcriptBudget * 1.5, 1);\n          const loaded = got.reduce((n, t) => n + t.count, 0);\n          if (loaded > cap && bins && this.port.getTranscriptBins) {\n            const fallback = allGenesPlan({\n              rect, bounds, pxPerUnit, budget: view.transcriptBudget, total: bins.count,\n              levels: bins.levels, canIndividual: false,\n            });\n            if (fallback.kind === 'bins') {\n              const job = this.binsJob(view, rect, pxPerUnit, bounds, bins, fallback.level);\n              return { ...(await job.load()), kind: job.kind, bin: job.bin };\n            }\n          }\n          const merged = mergeTranscriptTiles(got, cap);\n          const px = new Float32Array(merged.count);\n          for (let i = 0; i < merged.count; i++) px[i] = transcriptMarkerPx(1, view.transcriptScale, pxPerMicron);\n          return { merged, px };\n        },\n      };\n    }\n\n    if (plan.kind === 'bins' && bins && this.port.getTranscriptBins) {\n      return this.binsJob(view, rect, pxPerUnit, bounds, bins, plan.level);\n    }\n    return null;\n  }\n\n  /** Bins of the all-gene pyramid at `level`, sized by how many transcripts each holds. */\n  private binsJob(\n    view: SpatialViewState, rect: DataRect, pxPerUnit: number, bounds: SpatialBounds,\n    bins: NonNullable<SpatialDataset['transcriptBins']>, level: number,\n  ): TranscriptJob {\n    const lv = bins.levels[level];\n    const keys = tilesInRectFrom(bins.origin, rect, level,\n      bins.levels.map((l) => ({ tileSize: l.tileSize })), bounds, MAX_BIN_TILES);\n    return {\n      kind: 'bins',\n      bin: { size: lv.binSize, origin: bins.origin },\n      key: `all|bins|${level}|${view.transcriptBudget}|${keys.map(tileId)}`,\n      load: async () => {\n        const got = await this.fetchAll(keys, (k) => this.port.getTranscriptBins!(k.level, k.gx, k.gy));\n        const merged = mergeTranscriptTiles(got, Math.max(view.transcriptBudget * 1.5, 1));\n        const refCount = quantileOf(merged.weight, 0.95);\n        const binPx = lv.binSize * pxPerUnit;\n        const px = new Float32Array(merged.count);\n        for (let i = 0; i < merged.count; i++) {\n          px[i] = groupedMarkerPx(merged.weight[i], refCount, binPx, view.transcriptScale);\n        }\n        return { merged, px };\n      },\n    };\n  }\n\n  /** Per-entry colours both as RGBA (points) and as colormap values (glyph shapes). */\n  private async transcriptColors(\n    dataset: SpatialDataset, view: SpatialViewState, t: SpatialTranscriptTile,\n    clusterOf?: (i: number) => string | null,\n  ): Promise<TranscriptFaces> {\n    let rgb: Rgb[];\n    let codeOf: (i: number) => number;\n    if (view.transcriptColorBy === 'cluster' && clusterOf) {\n      // A cluster named like a group of the cells' grouping takes that group's colour, so a\n      // cluster's transcripts and its cells agree; any other cluster takes a palette colour.\n      const name = this.cellTypeColumnName(dataset, view);\n      const codes = name ? await this.categoricalCodes(name).catch(() => null) : null;\n      const cellColor = new Map<string, string>();\n      if (codes?.meta.kind === 'categorical') {\n        const colors = resolveCategoryColors(codes.meta);\n        codes.meta.categories.forEach((c, k) => cellColor.set(c, colors[k]));\n      }\n      const colors = clusterColorMap(view.transcriptGenes, view.transcriptGeneGroups, cellColor,\n        DEFAULT_CATEGORICAL_PALETTE);\n      const index = new Map<string, number>();\n      const hex: string[] = [];\n      const codeFor = (cluster: string) => {\n        let k = index.get(cluster);\n        if (k === undefined) {\n          k = hex.length;\n          index.set(cluster, k);\n          hex.push(colors.get(cluster) ?? cellColor.get(cluster) ?? DEFAULT_CATEGORICAL_PALETTE[0]);\n        }\n        return k;\n      };\n      const code = new Int32Array(t.count);\n      for (let i = 0; i < t.count; i++) {\n        const c = clusterOf(i);\n        code[i] = c === null ? -1 : codeFor(c);\n      }\n      rgb = hex.map(parseHex);\n      codeOf = (i) => code[i];\n    } else if (view.transcriptColorBy === 'gene' || view.transcriptColorBy === 'cluster') {\n      // All genes: codes are the dataset's gene indices, folded onto the palette.\n      const n = view.transcriptAllGenes ? DEFAULT_CATEGORICAL_PALETTE.length : view.transcriptGenes.length;\n      rgb = Array.from({ length: n }, (_g, i) => parseHex(\n        (!view.transcriptAllGenes && view.transcriptGeneColors[view.transcriptGenes[i]])\n        || DEFAULT_CATEGORICAL_PALETTE[i % DEFAULT_CATEGORICAL_PALETTE.length]));\n      codeOf = view.transcriptAllGenes ? (i) => t.gene[i] % n : (i) => t.gene[i];\n    } else {\n      const name = this.cellTypeColumnName(dataset, view);\n      const codes = name ? await this.categoricalCodes(name) : null;\n      rgb = codes?.meta.kind === 'categorical' ? resolveCategoryColors(codes.meta).map(parseHex) : [];\n      codeOf = (i) => {\n        const o = t.observation[i];\n        if (!codes || o === NO_OBSERVATION) return -1;\n        const c = codes.codes[o];\n        return c === NO_CATEGORY ? -1 : c;\n      };\n    }\n    const { stops, valueOf } = discreteColormapStops(rgb, MISSING_COLOR);\n    const rgba: RGBA[] = new Array(t.count);\n    const values = new Float32Array(t.count);\n    const tuples: RGBA[] = rgb.map(([r, g, b]) => [r / 255, g / 255, b / 255, 1]);\n    for (let i = 0; i < t.count; i++) {\n      const c = codeOf(i);\n      rgba[i] = c < 0 ? UNASSIGNED_RGBA : tuples[c];\n      values[i] = valueOf(c);\n    }\n    return { rgba, values, colormap: new Colormap('transcript-categories', stops) };\n  }\n\n  // ── density ───────────────────────────────────────────────────────────────────────\n\n  private async planDensity(\n    dataset: SpatialDataset, view: SpatialViewState, stale: () => boolean,\n  ): Promise<void> {\n    const hiddenGenes = new Set(view.transcriptHiddenGenes);\n    const genes = view.transcriptAllGenes\n      ? [ALL_GENES]\n      : view.transcriptGenes.filter((g) => !hiddenGenes.has(g));\n    if (!dataset.density || !this.port.getDensity || view.transcriptMode !== 'density' || !genes.length) {\n      this.drop('density');\n      this.densityStats = null;\n      return;\n    }\n    const lut = lutFor(view.densityColormap ?? INFERNO_SCALE);\n    const key = [dataset.id, genes.join(','), view.densityBin, view.densityOpacity,\n      JSON.stringify(view.densityRange), JSON.stringify(view.densityColormap)].join('|');\n    if (key === this.keys.get('density') && this.layers.has('density')) return;\n    const raster = await this.track('Transcript density', this.port.getDensity(genes, view.densityBin));\n    if (stale()) return;\n\n    // Bins drawn as squares, as Xenium Explorer does; the window is in transcripts/µm².\n    const meta = raster.meta;\n    const area = meta.gridSize[0] * meta.gridSize[1];\n    const perArea = raster.values.map((v) => v / area);\n    const [lo, hi] = view.densityRange ?? densityAutoRange(perArea);\n    this.densityStats = { lo, hi, max: perArea.reduce((m, v) => (v > m ? v : m), 0) };\n    const rgba = colorDensityWindow(perArea, lut, view.densityOpacity, lo, hi);\n    const ref = dataset.imageRef;\n    const sx = ref?.scale?.[0] ?? 1;\n    const sy = ref?.scale?.[1] ?? 1;\n    const layer: ImageLayer = this.viewer!.addImage(\n      { kind: 'typed', width: meta.cols, height: meta.rows, channels: 4, dtype: 'uint8', data: rgba },\n      {\n        name: `density · ${view.transcriptAllGenes ? 'all genes' : genes.join(', ')}`,\n        scale: [meta.gridSize[0] * sx, meta.gridSize[1] * sy],\n        translate: [\n          meta.origin[0] * sx + (ref?.translate?.[0] ?? 0),\n          meta.origin[1] * sy + (ref?.translate?.[1] ?? 0),\n        ],\n        blending: 'translucent',\n        interpolation: 'nearest',\n      },\n    );\n    this.keys.set('density', key);\n    this.replace('density', layer);\n    this.host.densityChanged?.(this.densityStats);\n  }\n\n  private countsCache: { key: string; counts: Promise<SpatialTranscriptCounts> } | null = null;\n\n  /**\n   * Transcripts in view for the visible genes: each gene's dataset total times the share\n   * of the tissue on screen. An estimate — expression is not uniform — which is also what\n   * Xenium Explorer shows; it tells the user whether the budget will force grouping.\n   */\n  private async planEstimate(\n    dataset: SpatialDataset, view: SpatialViewState, viewer: Viewer, w: number, h: number,\n    stale: () => boolean,\n  ): Promise<void> {\n    const tiles = dataset.transcriptTiles;\n    if (!tiles || !this.port.getTranscriptCounts || view.transcriptMode === 'off') {\n      this.host.estimateChanged?.(null);\n      return;\n    }\n    const hiddenGenes = new Set(view.transcriptHiddenGenes);\n    const genes = view.transcriptAllGenes ? [] : view.transcriptGenes.filter((g) => !hiddenGenes.has(g));\n    const key = `${dataset.id}|${genes.join(',')}`;\n    if (this.countsCache?.key !== key) {\n      this.countsCache = { key, counts: this.port.getTranscriptCounts(genes) };\n    }\n    let counts: SpatialTranscriptCounts;\n    try {\n      counts = await this.countsCache.counts;\n    } catch {\n      this.countsCache = null;\n      return;\n    }\n    if (stale()) return;\n    const inView = visibleDataRect(viewer.camera.center, viewer.camera.zoom, w, h, dataset.imageRef, 0);\n    if (!inView) return;\n    const b = counts.bounds;\n    const share = Math.min(1, visibleArea(inView, b) / Math.max(1, (b[2] - b[0]) * (b[3] - b[1])));\n    const selected = view.transcriptAllGenes\n      ? counts.total\n      : genes.reduce((sum, g) => sum + (counts.counts[g] ?? 0), 0);\n    this.host.estimateChanged?.({ points: Math.round(selected * share), max: view.transcriptBudget });\n  }\n\n  /** The density window in use and the densest bin, for the panel's threshold control. */\n  densityStats: { lo: number; hi: number; max: number } | null = null;\n\n  // ── layer bookkeeping ─────────────────────────────────────────────────────────────\n\n  /**\n   * Fetch every tile, drawing what arrived. A failure does not fail the view, but it marks the\n   * plan incomplete: the caller must not cache it as done, and `plan()` retries it.\n   */\n  private async fetchAll<K, T>(keys: K[], load: (k: K) => Promise<T>): Promise<T[]> {\n    const settled = await Promise.allSettled(keys.map(load));\n    const out: T[] = [];\n    for (const s of settled) {\n      if (s.status === 'fulfilled') out.push(s.value);\n      else console.warn('[napari-js] spatial tile failed', s.reason);\n    }\n    if (out.length < keys.length) this.planIncomplete = true;\n    return out;\n  }\n\n  /**\n   * Put a shapes layer in place for `group`: a geometry change builds a new layer, a\n   * colour-only change mutates values/colormap on the existing one.\n   */\n  private upsertShapes(\n    group: Group, wanted: boolean, geometryChanged: boolean, rings: SpatialPolygons,\n    opts: Parameters<Viewer['addShapes']>[2] & object,\n  ): void {\n    if (!wanted) {\n      this.drop(group);\n      return;\n    }\n    const existing = this.layers.get(group) as ShapesLayer | undefined;\n    if (existing && !geometryChanged && this.viewer!.layers.items.includes(existing)) {\n      // Flat colour has no values; clearing them is what switches the layer to `color`.\n      existing.values = opts.values ?? null;\n      if (opts.colormap) existing.colormap = opts.colormap;\n      if (opts.contrastLimits) existing.contrastLimits = opts.contrastLimits;\n      if (opts.color) existing.color = opts.color;\n      if (opts.opacity !== undefined) existing.opacity = opts.opacity;\n      this.viewer!.requestRender();\n      return;\n    }\n    const layer = this.viewer!.addShapes(rings.coords, rings.offsets, opts);\n    this.replace(group, layer);\n  }\n\n  /**\n   * Install `layer` as `group`'s layer and restore the order of the groups above it.\n   * The layer was just added by the caller (so it is on top); groups that belong above\n   * it are removed and re-added.\n   */\n  private replace(group: Group, layer: Layer): void {\n    const v = this.viewer!;\n    const old = this.layers.get(group);\n    if (old && old !== layer && v.layers.items.includes(old)) v.layers.remove(old);\n    this.layers.set(group, layer);\n    for (const g of ORDER.slice(ORDER.indexOf(group) + 1)) {\n      const above = this.layers.get(g);\n      if (!above || !v.layers.items.includes(above)) continue;\n      v.layers.remove(above);\n      v.layers.add(above);\n    }\n    v.requestRender();\n  }\n\n  private drop(group: Group): void {\n    const layer = this.layers.get(group);\n    if (layer && this.viewer?.layers.items.includes(layer)) this.viewer.layers.remove(layer);\n    this.layers.delete(group);\n    this.keys.delete(group);\n  }\n\n  private dropCells(): void {\n    this.drop('cellFill');\n    this.drop('cellOutline');\n    this.drop('nucleusOutline');\n    this.currentNuclei = null;\n    this.cellGeometryKey = null;\n    this.cellStyleKey = null;\n    this.currentRings = null;\n    this.setPolygonsShown(false);\n  }\n\n  private setPolygonsShown(shown: boolean): void {\n    if (shown === this.polygonsShown) return;\n    this.polygonsShown = shown;\n    this.host.polygonsShownChanged(shown);\n  }\n}\n\n/** What the transcript layer currently shows — what hovering needs to name a marker. */\ninterface DrawnTranscripts {\n  kind: TranscriptJob['kind'];\n  bin?: TranscriptJob['bin'];\n  merged: SpatialTranscriptTile;\n  /** Marker radius per entry, in observation units. */\n  radius: Float32Array;\n  genes: string[];\n  ref: SpatialImageRef | null;\n  /** For a grouped gene selection: each entry's group, and the groups' names. */\n  entryGroup?: Int32Array;\n  groupNames?: string[];\n  /** Each group's genes, when the markers came from the density grids (for the hover). */\n  groupGenes?: string[][];\n  /** Lazily built spatial index: bucket → entry indices. */\n  grid: { size: number; buckets: Map<number, number[]> } | null;\n}\n\n/** Index of the entry under `(x, y)` — within its own radius or `tolerance` — or -1. */\nexport function pickNearest(\n  d: Pick<DrawnTranscripts, 'merged' | 'radius' | 'grid'>, x: number, y: number, tolerance: number,\n): number {\n  const t = d.merged;\n  if (!d.grid) {\n    let maxR = 0;\n    for (let i = 0; i < t.count; i++) if (d.radius[i] > maxR) maxR = d.radius[i];\n    const size = Math.max(maxR * 2, tolerance * 2, 1e-6);\n    const buckets = new Map<number, number[]>();\n    for (let i = 0; i < t.count; i++) {\n      const k = bucketKey(Math.floor(t.x[i] / size), Math.floor(t.y[i] / size));\n      let b = buckets.get(k);\n      if (!b) buckets.set(k, (b = []));\n      b.push(i);\n    }\n    d.grid = { size, buckets };\n  }\n  const { size, buckets } = d.grid;\n  const gx = Math.floor(x / size);\n  const gy = Math.floor(y / size);\n  let best = -1;\n  let bestD = Infinity;\n  for (let dy = -1; dy <= 1; dy++) {\n    for (let dx = -1; dx <= 1; dx++) {\n      for (const i of buckets.get(bucketKey(gx + dx, gy + dy)) ?? []) {\n        const dist = Math.hypot(t.x[i] - x, t.y[i] - y);\n        if (dist <= Math.max(d.radius[i], tolerance) && dist < bestD) {\n          bestD = dist;\n          best = i;\n        }\n      }\n    }\n  }\n  return best;\n}\n\nfunction bucketKey(gx: number, gy: number): number {\n  return (gx + 32768) * 65536 + (gy + 32768);\n}\n\n/** Rings whose owning cell is in a switched-off group removed. */\nexport function filterRings(\n  rings: SpatialPolygonTile, hidden: { codes: Uint16Array; hidden: Uint8Array } | null,\n): SpatialPolygonTile {\n  if (!hidden) return rings;\n  const keep: number[] = [];\n  let vertices = 0;\n  for (let i = 0; i < rings.count; i++) {\n    const code = hidden.codes[rings.observation[i]];\n    if (code !== NO_CATEGORY && hidden.hidden[code]) continue;\n    keep.push(i);\n    vertices += rings.offsets[i + 1] - rings.offsets[i];\n  }\n  if (keep.length === rings.count) return rings;\n  const observation = new Uint32Array(keep.length);\n  const offsets = new Uint32Array(keep.length + 1);\n  const coords = new Float32Array(vertices * 2);\n  let v = 0;\n  keep.forEach((i, r) => {\n    observation[r] = rings.observation[i];\n    offsets[r] = v;\n    const a = rings.offsets[i] * 2;\n    const b = rings.offsets[i + 1] * 2;\n    coords.set(rings.coords.subarray(a, b), v * 2);\n    v += (b - a) / 2;\n  });\n  offsets[keep.length] = v;\n  return { count: keep.length, observation, offsets, coords };\n}\n\n/** Slots (indices into the selected genes) switched off with their eye toggle. */\nfunction hiddenGeneSlots(view: SpatialViewState): Uint8Array | null {\n  if (!view.transcriptHiddenGenes.length) return null;\n  const off = new Set(view.transcriptHiddenGenes);\n  return Uint8Array.from(view.transcriptGenes, (g) => (off.has(g) ? 1 : 0));\n}\n\n/** Entries in a hidden group's cell, or of a hidden gene, removed (with their sizes). */\nexport function filterTranscripts(\n  t: SpatialTranscriptTile, px: Float32Array,\n  hidden: { codes: Uint16Array; hidden: Uint8Array } | null, hiddenGenes: Uint8Array | null,\n): { merged: SpatialTranscriptTile; px: Float32Array } {\n  if (!hidden && !hiddenGenes) return { merged: t, px };\n  const keep: number[] = [];\n  for (let i = 0; i < t.count; i++) {\n    if (hiddenGenes && hiddenGenes[t.gene[i]]) continue;\n    const o = t.observation[i];\n    if (hidden && o !== NO_OBSERVATION) {\n      const code = hidden.codes[o];\n      if (code !== NO_CATEGORY && hidden.hidden[code]) continue;\n    }\n    keep.push(i);\n  }\n  const pick = <T extends Float32Array | Uint32Array | Uint16Array>(a: T): T => {\n    const out = new (a.constructor as new (n: number) => T)(keep.length);\n    keep.forEach((i, k) => { out[k] = a[i]; });\n    return out;\n  };\n  return {\n    merged: {\n      count: keep.length, aggregated: t.aggregated, x: pick(t.x), y: pick(t.y), z: pick(t.z),\n      weight: pick(t.weight), observation: pick(t.observation), gene: pick(t.gene),\n    },\n    px: pick(px),\n  };\n}\n\nfunction median(v: Float32Array): number {\n  if (!v.length) return 0;\n  const step = Math.max(1, Math.floor(v.length / 1024));\n  const sample: number[] = [];\n  for (let i = 0; i < v.length; i += step) sample.push(v[i]);\n  sample.sort((a, b) => a - b);\n  return sample[sample.length >> 1];\n}\n\n/** Concatenate tiles' rings into one set, dropping rings already seen (a cell straddling\n *  two tiles may be listed by both). */\nexport function mergePolygonTiles(tiles: SpatialPolygonTile[]): SpatialPolygonTile {\n  const seen = new Set<number>();\n  let rings = 0;\n  let vertices = 0;\n  for (const t of tiles) {\n    for (let i = 0; i < t.count; i++) {\n      if (seen.has(t.observation[i])) continue;\n      seen.add(t.observation[i]);\n      rings++;\n      vertices += t.offsets[i + 1] - t.offsets[i];\n    }\n  }\n  seen.clear();\n  const observation = new Uint32Array(rings);\n  const offsets = new Uint32Array(rings + 1);\n  const coords = new Float32Array(vertices * 2);\n  let r = 0;\n  let v = 0;\n  for (const t of tiles) {\n    for (let i = 0; i < t.count; i++) {\n      const o = t.observation[i];\n      if (seen.has(o)) continue;\n      seen.add(o);\n      observation[r] = o;\n      offsets[r] = v;\n      const a = t.offsets[i] * 2;\n      const b = t.offsets[i + 1] * 2;\n      coords.set(t.coords.subarray(a, b), v * 2);\n      v += (b - a) / 2;\n      r++;\n    }\n  }\n  offsets[rings] = v;\n  return { count: rings, observation, offsets, coords };\n}\n\n/** Concatenate transcript tiles, stopping at `limit` entries. */\nexport function mergeTranscriptTiles(tiles: SpatialTranscriptTile[], limit = Infinity): SpatialTranscriptTile {\n  let n = 0;\n  for (const t of tiles) n += t.count;\n  n = Math.min(n, limit);\n  const out: SpatialTranscriptTile = {\n    count: n,\n    aggregated: tiles.some((t) => t.aggregated),\n    x: new Float32Array(n), y: new Float32Array(n), z: new Float32Array(n),\n    weight: new Uint32Array(n), observation: new Uint32Array(n), gene: new Uint16Array(n),\n  };\n  let o = 0;\n  for (const t of tiles) {\n    const k = Math.min(t.count, n - o);\n    if (k <= 0) break;\n    for (const f of ['x', 'y', 'z', 'weight', 'observation', 'gene'] as const) {\n      (out[f] as Float32Array).set((t[f] as Float32Array).subarray(0, k), o);\n    }\n    o += k;\n  }\n  return out;\n}\n\n/**\n * One marker per (cluster, `bin` square) from per-cluster density grids: the counts of the grid\n * cells inside `area` summed per square, at their count-weighted centre. `slots[c]` is the gene\n * slot whose icon cluster c's markers take.\n */\nexport function clusterMarkers(\n  rasters: SpatialDensityRaster[], slots: number[], bin: number, area: DataRect,\n): { tile: SpatialTranscriptTile; group: Int32Array } {\n  const x: number[] = [];\n  const y: number[] = [];\n  const w: number[] = [];\n  const gene: number[] = [];\n  const group: number[] = [];\n  rasters.forEach((r, c) => {\n    const [cw, ch] = r.meta.gridSize;\n    const [ox, oy] = r.meta.origin;\n    const { rows, cols } = r.meta;\n    const c0 = Math.max(0, Math.floor((area.x0 - ox) / cw));\n    const c1 = Math.min(cols - 1, Math.floor((area.x1 - ox) / cw));\n    const r0 = Math.max(0, Math.floor((area.y0 - oy) / ch));\n    const r1 = Math.min(rows - 1, Math.floor((area.y1 - oy) / ch));\n    const squares = new Map<number, { n: number; sx: number; sy: number }>();\n    for (let row = r0; row <= r1; row++) {\n      for (let col = c0; col <= c1; col++) {\n        const v = r.values[row * cols + col];\n        if (!(v > 0)) continue;\n        const cx = ox + (col + 0.5) * cw;\n        const cy = oy + (row + 0.5) * ch;\n        const key = Math.floor((cy - oy) / bin) * 1e6 + Math.floor((cx - ox) / bin);\n        const s = squares.get(key) ?? { n: 0, sx: 0, sy: 0 };\n        s.n += v;\n        s.sx += v * cx;\n        s.sy += v * cy;\n        squares.set(key, s);\n      }\n    }\n    for (const s of squares.values()) {\n      x.push(s.sx / s.n);\n      y.push(s.sy / s.n);\n      w.push(Math.round(s.n));\n      gene.push(slots[c]);\n      group.push(c);\n    }\n  });\n  const n = w.length;\n  return {\n    tile: {\n      count: n, aggregated: true,\n      x: Float32Array.from(x), y: Float32Array.from(y), z: new Float32Array(n),\n      weight: Uint32Array.from(w), observation: new Uint32Array(n).fill(NO_OBSERVATION),\n      gene: Uint16Array.from(gene),\n    },\n    group: Int32Array.from(group),\n  };\n}\n"]}