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

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

@@ -0,0 +1,1098 @@
+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, } from '../../spatial/spatial-tiles';
+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;
+        // ── hover ─────────────────────────────────────────────────────────────────────────
+        this.drawn = null;
+        this.hoverTypes = null;
+        /** Details already fetched, by hovered entry. */
+        this.hoverCache = new Map();
+        this.hoverKey = null;
+        this.hoverTimer = null;
+        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());
+    }
+    /** 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;
+        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;
+        // 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 geometry = await 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
+            ? (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;
+            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),
+        ].join('|');
+        const current = this.layers.get('transcripts');
+        if (planKey === this.keys.get('transcripts') && current && this.viewer.layers.items.includes(current)) {
+            return;
+        }
+        const loaded = await job.load();
+        if (stale())
+            return;
+        const hidden = await this.hiddenCodes(dataset, view);
+        if (stale())
+            return;
+        const { merged, px } = filterTranscripts(loaded.merged, loaded.px, hidden, (loaded.kind ?? job.kind) === 'genes' ? hiddenGeneSlots(view) : null);
+        // 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 === 'gene'
+            ? { ...view, transcriptColorBy: 'cellType' } : view;
+        const faces = await this.transcriptColors(dataset, colorView, merged);
+        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: loaded.kind ? loaded.bin : job.bin,
+            merged, radius: diam.map((d) => d / 2),
+            genes: [...view.transcriptGenes], ref: dataset.imageRef ?? null, grid: null,
+        };
+        this.hoverCache.clear();
+        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);
+        }
+    }
+    /** 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 }) {
+        // 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);
+        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.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];
+        }
+        try {
+            const summary = await this.port.getTranscriptSummary({ box, cells });
+            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';
+        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);
+        return {
+            kind: 'genes',
+            key: `genes|${genes.join(',')}|${view.transcriptQuality}|${view.transcriptBudget}|${keysAt(first).map(tileId)}`,
+            load: async () => {
+                let level = first;
+                let merged;
+                for (;;) {
+                    const tiles = await this.fetchAll(keysAt(level), (k) => this.port.getTranscriptTile(k.level, k.gx, k.gy, query));
+                    merged = mergeTranscriptTiles(tiles, MAX_TRANSCRIPTS);
+                    if (merged.count <= view.transcriptBudget || level >= meta.levels.length - 1)
+                        break;
+                    level++;
+                }
+                const px = new Float32Array(merged.count);
+                for (let i = 0; i < merged.count; i++) {
+                    px[i] = transcriptMarkerPx(merged.weight[i], view.transcriptScale, pxPerMicron);
+                }
+                return { merged, px };
+            },
+        };
+    }
+    /**
+     * 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) {
+        let rgb;
+        let codeOf;
+        if (view.transcriptColorBy === 'gene') {
+            // 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.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;
+}
+//# 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, SpatialImageRef, 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,\n} from '../../spatial/spatial-tiles';\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}\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  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  /** 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    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    // 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 geometry = await 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') && this.port.getTranscriptTile\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      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),\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 job.load();\n    if (stale()) return;\n    const hidden = await this.hiddenCodes(dataset, view);\n    if (stale()) return;\n    const { merged, px } = filterTranscripts(loaded.merged, loaded.px, hidden,\n      (loaded.kind ?? job.kind) === 'genes' ? hiddenGeneSlots(view) : null);\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 === 'gene'\n      ? { ...view, transcriptColorBy: 'cellType' as const } : view;\n    const faces = await this.transcriptColors(dataset, colorView, merged);\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, bin: 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    };\n    this.hoverCache.clear();\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);\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,\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    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.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    try {\n      const summary = await this.port.getTranscriptSummary({ box, cells });\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    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    return {\n      kind: 'genes',\n      key: `genes|${genes.join(',')}|${view.transcriptQuality}|${view.transcriptBudget}|${keysAt(first).map(tileId)}`,\n      load: async () => {\n        let level = first;\n        let merged: SpatialTranscriptTile;\n        for (;;) {\n          const tiles = await this.fetchAll(keysAt(level),\n            (k) => this.port.getTranscriptTile!(k.level, k.gx, k.gy, query));\n          merged = mergeTranscriptTiles(tiles, MAX_TRANSCRIPTS);\n          if (merged.count <= view.transcriptBudget || level >= meta.levels.length - 1) break;\n          level++;\n        }\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 { merged, px };\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  ): Promise<TranscriptFaces> {\n    let rgb: Rgb[];\n    let codeOf: (i: number) => number;\n    if (view.transcriptColorBy === 'gene') {\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.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  /** 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"]}