@jax-data-science/sci-image-visualizer 0.8.3 → 0.9.0

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

@@ -0,0 +1,369 @@
+import { LruCache } from 'napari-js';
+import { ALL_GENES } from '../../../contracts/ports/spatial-data.port';
+import { tileId, tilesInRect, tilesInRectFrom, transcriptLevelFor } from '../../../spatial/lod';
+import { allGenesPlan, clipTranscripts, geneBinSize, groupTranscripts, groupedMarkerPx, quantileOf, transcriptMarkerPx, } from '../../../spatial/transcript-grouping';
+import { clusterMarkers, mergeTranscriptTiles } from '../../../spatial/spatial-tile-merge';
+/** The all-gene pyramid's finest bin (250 µm source tiles / 128) and default level count, used
+ *  to group a gene selection on the same ladder when a dataset has no pyramid. */
+const PYRAMID_BASE_BIN_UM = 250 / 128;
+const PYRAMID_LEVELS = 7;
+/** 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_TRANSCRIPT_TILES = 36;
+const MAX_BIN_TILES = 64;
+/** Summed per-cluster density grids kept (one per cluster × bin × dataset). */
+const DENSITY_CACHE_SIZE = 256;
+/**
+ * Decides which transcripts the 2D spatial view fetches, at which level, for the current
+ * camera and selection: a {@link TranscriptJob} that can be keyed before it runs (so an
+ * unchanged plan is a no-op) and that fetches and merges when run.
+ *
+ * Pure apart from the port, so the level policy is testable without a viewer. Owns the
+ * cache of summed per-cluster density grids a zoomed-out gene selection is drawn from.
+ */
+export class TranscriptJobPlanner {
+    constructor(port) {
+        this.port = port;
+        /** Summed per-cluster density grids (see densityFor). */
+        this.densityCache = new LruCache(DENSITY_CACHE_SIZE);
+    }
+    /**
+     * The job that draws the view's transcripts as markers (circles or icons), or null when the
+     * view draws none or the port cannot serve them.
+     */
+    jobFor(dataset, view, rect, pxPerUnit) {
+        const mode = view.transcriptMode;
+        if (mode !== 'circles' && mode !== 'glyphs')
+            return null;
+        const geneBins = this.port.getTranscriptGeneBins && dataset.transcriptGeneBins;
+        if (!this.port.getTranscriptTile && !geneBins)
+            return null;
+        return view.transcriptAllGenes
+            ? this.allGenesJob(dataset, view, rect, pxPerUnit)
+            : this.geneJob(dataset, view, rect, pxPerUnit);
+    }
+    /**
+     * 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 = pxPerMicronOf(dataset, pxPerUnit);
+        const clip = clipWindow(rect);
+        // Zoomed out, each gene's transcripts are grouped on the all-gene pyramid's bin ladder,
+        // so a gene selection reads like "all genes" does: one marker per gene per area, sized
+        // by how many it holds; zoomed in far enough, every transcript is its own marker.
+        const ladder = dataset.transcriptBins?.levels;
+        const baseBin = ladder?.[0]?.binSize ?? (dataset.micronsPerUnit ? PYRAMID_BASE_BIN_UM / dataset.micronsPerUnit : 0);
+        const bin = geneBinSize(pxPerUnit, baseBin, ladder?.length ?? PYRAMID_LEVELS);
+        // Zoomed out to bins as wide as the density grid, a selection is drawn from the per-gene
+        // density grids — one cached request per cluster — rather than 10x's coarse per-gene
+        // tiles, which take minutes for a few hundred genes.
+        // With the pyramid's per-gene levels, every zoom of a selection reads them: the level the
+        // zoom calls for, coarser while the markers would exceed the max.
+        // Both are built from high-quality calls only: with low-quality calls included, the
+        // quality-aware tiles below serve every zoom (as long as there are tiles to serve).
+        const highOnly = view.transcriptQuality !== 'all' || !this.port.getTranscriptTile;
+        const geneBins = dataset.transcriptGeneBins;
+        const fromGeneBins = highOnly && geneBins && this.port.getTranscriptGeneBins;
+        if (fromGeneBins && (bin !== null || !this.port.getTranscriptTile)) {
+            return this.geneBinsJob(dataset, view, clip, geneBins, bin ?? geneBins.levels[0].binSize);
+        }
+        const grid = dataset.density?.gridSize[0] ?? 0;
+        if (highOnly && bin !== null && grid > 0 && this.port.getDensity && bin >= grid * 0.75) {
+            return this.clusterDensityJob(dataset, view, clip, pxPerUnit, Math.max(bin, grid));
+        }
+        return {
+            kind: 'genes',
+            // The clip window, in quarter-view steps: a pan past the margin re-clips.
+            key: `genes|${genes.join(',')}|${view.transcriptQuality}|${view.transcriptBudget}|${bin ?? 'each'}|` +
+                `${clip.key}|${keysAt(first).map(tileId)}`,
+            load: async (ctx) => {
+                // The zoom's own level only: over the budget, the transcripts are combined into
+                // larger markers (groupSelection), never fetched from slower coarse levels.
+                const tiles = await ctx.fetchAll(keysAt(first), (k) => this.port.getTranscriptTile(k.level, k.gx, k.gy, query));
+                // Only what is on screen (and a margin, so a small pan needs nothing new) counts
+                // against the budget and the cap; a tile reaches far past the view.
+                const merged = mergeTranscriptTiles(tiles.map((t) => clipTranscripts(t, clip.around)), MAX_TRANSCRIPTS);
+                const px = Float32Array.from(merged.weight, (w) => transcriptMarkerPx(w, view.transcriptScale, pxPerMicron));
+                return baseBin > 0
+                    ? { merged, px, ladder: { baseBin, levels: ladder?.length ?? PYRAMID_LEVELS, start: bin } }
+                    : { merged, px };
+            },
+        };
+    }
+    /**
+     * A gene selection from the pyramid's per-gene levels: starting at the level whose bins are
+     * `startBin`, fetch the view's tiles for the selected genes and step to a coarser level while
+     * one marker per cluster per bin would exceed the max. Hidden genes are fetched too (their
+     * counts in view still show) and dropped before drawing; grouping by cluster happens there.
+     */
+    geneBinsJob(dataset, view, clip, meta, startBin) {
+        const genes = view.transcriptGenes;
+        const levels = meta.levels;
+        let first = levels.findIndex((l) => l.binSize >= startBin * 0.999);
+        if (first < 0)
+            first = levels.length - 1;
+        const budget = Math.max(1, view.transcriptBudget);
+        const hidden = new Set(view.transcriptHiddenGenes);
+        const clusters = this.selectionClusters(view);
+        const clusterOf = new Map();
+        clusters.forEach((c, ci) => c.genes.forEach((g) => clusterOf.set(genes.indexOf(g), ci)));
+        const keysAt = (m) => tilesInRectFrom(meta.origin, clip.around, m, levels.map((l) => ({ tileSize: l.tileSize })), null, MAX_BIN_TILES);
+        return {
+            kind: 'genes',
+            key: `gene-bins|${genes.join(',')}|${budget}|${first}|${JSON.stringify(view.transcriptGeneGroups)}|` + clip.key,
+            load: async (ctx) => {
+                let m = first;
+                for (;;) {
+                    const tiles = await ctx.fetchAll(keysAt(m), (k) => this.port.getTranscriptGeneBins(k.level, k.gx, k.gy, genes));
+                    const clipped = tiles.map((t) => clipTranscripts(t, clip.around));
+                    // Past the cap a merge would drop whole genes (the tail of every tile): go coarser.
+                    if (clipped.reduce((n, t) => n + t.count, 0) > MAX_TRANSCRIPTS && m < levels.length - 1) {
+                        m++;
+                        continue;
+                    }
+                    const merged = mergeTranscriptTiles(clipped, MAX_TRANSCRIPTS);
+                    // Markers this level would draw: one per (visible cluster, bin).
+                    const seen = new Set();
+                    const bin = levels[m].binSize;
+                    for (let i = 0; i < merged.count; i++) {
+                        if (hidden.has(genes[merged.gene[i]]))
+                            continue;
+                        const c = clusterOf.get(merged.gene[i]);
+                        if (c === undefined)
+                            continue;
+                        seen.add(`${c}|${Math.floor(merged.x[i] / bin)}|${Math.floor(merged.y[i] / bin)}`);
+                    }
+                    if (seen.size <= budget || m >= levels.length - 1) {
+                        return { merged, px: new Float32Array(merged.count), ladder: { baseBin: bin, levels: 1, start: bin } };
+                    }
+                    m++;
+                }
+            },
+        };
+    }
+    /** The selection's clusters: each gene-tree group's visible genes, then each ungrouped gene. */
+    selectionClusters(view) {
+        const hidden = new Set(view.transcriptHiddenGenes);
+        const slots = new Map(view.transcriptGenes.map((g, i) => [g, i]));
+        const taken = new Set();
+        const out = [];
+        for (const g of view.transcriptGeneGroups) {
+            const genes = g.genes.filter((x) => slots.has(x) && !hidden.has(x) && !taken.has(x));
+            genes.forEach((x) => taken.add(x));
+            if (genes.length)
+                out.push({ name: g.name, genes, slot: slots.get(genes[0]) });
+        }
+        for (const gene of view.transcriptGenes) {
+            if (!taken.has(gene) && !hidden.has(gene))
+                out.push({ name: gene, genes: [gene], slot: slots.get(gene) });
+        }
+        return out;
+    }
+    /**
+     * Per-gene density grids summed for `genes`, cached (a cluster is asked for once per bin).
+     * Keyed by dataset too: this manager outlives a dataset, and another may share gene names.
+     * Least-recently-USED eviction, so the clusters in view stay cached; a failed request is
+     * dropped so the next plan asks again.
+     */
+    densityFor(dataset, genes, bin) {
+        const key = `${dataset}|${bin}|${genes.join(',')}`;
+        let p = this.densityCache.get(key);
+        if (!p) {
+            const request = this.port.getDensity(genes, bin);
+            request.catch(() => {
+                if (this.densityCache.get(key) === request)
+                    this.densityCache.delete(key);
+            });
+            this.densityCache.set(key, request);
+            p = request;
+        }
+        return p;
+    }
+    /**
+     * A gene selection zoomed out: one marker per cluster per bin, from the per-gene density
+     * grids. The bin starts where markers are 14 px apart and doubles until the markers fit the
+     * max; each marker sits at the count-weighted centre of the finer grid inside it, so markers
+     * follow the tissue rather than a lattice.
+     */
+    clusterDensityJob(dataset, view, clip, pxPerUnit, startBin) {
+        const grid = dataset.density.gridSize[0];
+        const clusters = this.selectionClusters(view);
+        let first = grid;
+        while (first < startBin * 0.999)
+            first *= 2;
+        const budget = Math.max(1, view.transcriptBudget);
+        return {
+            kind: 'genes',
+            key: `clusters|${clusters.map((c) => `${c.name}:${c.genes.join('+')}`).join(';')}|${budget}|${first}|` +
+                clip.key,
+            load: async () => {
+                let bin = first;
+                for (;;) {
+                    // The finer grid gives each marker its centre; the server bins 1, 2, 4 or 8 cells.
+                    const fine = Math.min(bin >= grid * 2 ? bin / 2 : bin, grid * 8);
+                    const rasters = await Promise.all(clusters.map((c) => this.densityFor(dataset.id, c.genes, fine)));
+                    const out = clusterMarkers(rasters, clusters.map((c) => c.slot), bin, clip.around);
+                    if (out.tile.count <= budget || bin >= grid * 2 ** 12) {
+                        const px = groupedSizes(out.tile.weight, bin * pxPerUnit, view.transcriptScale);
+                        return {
+                            merged: out.tile,
+                            px,
+                            kind: 'genes',
+                            clustered: {
+                                group: out.group,
+                                names: clusters.map((c) => c.name),
+                                genes: clusters.map((c) => c.genes),
+                                bin,
+                                origin: rasters[0]?.meta.origin ?? [0, 0],
+                            },
+                        };
+                    }
+                    bin *= 2;
+                }
+            },
+        };
+    }
+    /**
+     * Every gene: the transcripts themselves once they fit the budget, else bins of the
+     * all-gene pyramid sized by how many transcripts each holds.
+     */
+    allGenesJob(dataset, view, rect, pxPerUnit) {
+        const bins = dataset.transcriptBins;
+        const tiles = dataset.transcriptTiles;
+        const bounds = bins?.bounds ?? tiles?.bounds;
+        if (!bounds)
+            return null;
+        const plan = allGenesPlan({
+            rect,
+            bounds,
+            pxPerUnit,
+            budget: view.transcriptBudget,
+            total: bins?.count ?? tiles?.count ?? 0,
+            levels: bins && this.port.getTranscriptBins ? bins.levels : [],
+            canIndividual: !!tiles,
+        });
+        if (plan.kind === 'individual' && tiles) {
+            const keys = tilesInRect(rect, 0, tiles.levels, tiles.bounds, MAX_TRANSCRIPT_TILES);
+            // Each tile clipped to the view, rounded outward to 10 units so small pans hit cache.
+            const r10 = (v, up) => (up ? Math.ceil(v / 10) : Math.floor(v / 10)) * 10;
+            const size = tiles.levels[0].tileSize;
+            const boxes = keys.map((k) => [
+                Math.max(k.gx * size, r10(rect.x0, false)),
+                Math.max(k.gy * size, r10(rect.y0, false)),
+                Math.min((k.gx + 1) * size, r10(rect.x1, true)),
+                Math.min((k.gy + 1) * size, r10(rect.y1, true)),
+            ]);
+            const pxPerMicron = pxPerMicronOf(dataset, pxPerUnit);
+            return {
+                kind: 'individual',
+                key: `all|individual|${view.transcriptBudget}|${boxes.map((b) => b.join(',')).join(';')}`,
+                load: async (ctx) => {
+                    const got = await ctx.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(ctx)), kind: job.kind, bin: job.bin };
+                        }
+                    }
+                    const merged = mergeTranscriptTiles(got, cap);
+                    // One transcript per entry: every marker is the same size.
+                    const px = new Float32Array(merged.count).fill(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 (ctx) => {
+                const got = await ctx.fetchAll(keys, (k) => this.port.getTranscriptBins(k.level, k.gx, k.gy));
+                const merged = mergeTranscriptTiles(got, Math.max(view.transcriptBudget * 1.5, 1));
+                return { merged, px: groupedSizes(merged.weight, lv.binSize * pxPerUnit, view.transcriptScale) };
+            },
+        };
+    }
+}
+/**
+ * Group a gene selection for the zoom: one marker per gene-tree cluster (a gene in no
+ * cluster is its own) per bin of the pyramid ladder, starting at the finest bin whose
+ * markers are 14 px apart and stepping up while the markers would exceed the budget.
+ * Null to draw every transcript: zoomed in, with the selection within the budget.
+ */
+export function groupSelection(t, view, ladder, pxPerUnit) {
+    const budget = Math.max(1, view.transcriptBudget);
+    const genes = view.transcriptGenes;
+    const groups = view.transcriptGeneGroups;
+    const names = [...groups.map((g) => g.name), ...genes];
+    const clusterOf = genes.map((gene, slot) => {
+        const g = groups.findIndex((x) => x.genes.includes(gene));
+        return g >= 0 ? g : groups.length + slot;
+    });
+    const keyOf = (slot) => clusterOf[slot] ?? groups.length + slot;
+    let bin = ladder.start;
+    if (bin === null) {
+        // Every transcript, if they fit the max and none was cut off at the cap.
+        if (t.count <= budget && t.count < MAX_TRANSCRIPTS)
+            return null;
+        bin = ladder.baseBin;
+    }
+    const top = ladder.baseBin * 2 ** (ladder.levels - 1);
+    let grouped = groupTranscripts(t, bin, keyOf);
+    // Over the max: combine into larger markers, a level at a time.
+    while (grouped.tile.count > budget && bin < top) {
+        bin *= 2;
+        grouped = groupTranscripts(t, bin, keyOf);
+    }
+    const px = groupedSizes(grouped.tile.weight, bin * pxPerUnit, view.transcriptScale);
+    return { merged: grouped.tile, px, bin, group: grouped.group, names };
+}
+/** Screen sizes of grouped markers: by weight against the 95th-percentile weight, over `binPx`. */
+function groupedSizes(weight, binPx, scale) {
+    const refCount = quantileOf(weight, 0.95);
+    return Float32Array.from(weight, (w) => groupedMarkerPx(w, refCount, binPx, scale));
+}
+function clipWindow(rect) {
+    const mx = (rect.x1 - rect.x0) * 0.25;
+    const my = (rect.y1 - rect.y0) * 0.25;
+    return {
+        around: { x0: rect.x0 - mx, y0: rect.y0 - my, x1: rect.x1 + mx, y1: rect.y1 + my },
+        key: `${Math.floor(rect.x0 / (mx || 1))},${Math.floor(rect.y0 / (my || 1))}`,
+    };
+}
+/** Physical marker size needs µm; undefined when the dataset's unit is unknown. */
+function pxPerMicronOf(dataset, pxPerUnit) {
+    return dataset.micronsPerUnit ? pxPerUnit / dataset.micronsPerUnit : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transcript-jobs.js","sourceRoot":"","sources":["../../../../../../src/lib/implementations/napari-js/spatial-tiles/transcript-jobs.ts"],"names":[],"mappings":"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","sourcesContent":["import { LruCache } from 'napari-js';\n\nimport { ALL_GENES, type SpatialDataPort } from '../../../contracts/ports/spatial-data.port';\nimport type { SpatialViewState } from '../../../contracts/display-types';\nimport {\n  SpatialBounds,\n  SpatialDataset,\n  SpatialDensityRaster,\n  SpatialTranscriptTile,\n} from '../../../contracts/spatial-dataset.contract';\nimport { DataRect, tileId, tilesInRect, tilesInRectFrom, transcriptLevelFor } from '../../../spatial/lod';\nimport {\n  allGenesPlan,\n  clipTranscripts,\n  geneBinSize,\n  groupTranscripts,\n  groupedMarkerPx,\n  quantileOf,\n  transcriptMarkerPx,\n} from '../../../spatial/transcript-grouping';\nimport { clusterMarkers, mergeTranscriptTiles } from '../../../spatial/spatial-tile-merge';\nimport type { PlanContext } from './plan-context';\nimport type { TranscriptBin, TranscriptKind } from './transcript-hover';\n\n/** The all-gene pyramid's finest bin (250 µm source tiles / 128) and default level count, used\n *  to group a gene selection on the same ladder when a dataset has no pyramid. */\nconst PYRAMID_BASE_BIN_UM = 250 / 128;\nconst PYRAMID_LEVELS = 7;\n/** 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_TRANSCRIPT_TILES = 36;\nconst MAX_BIN_TILES = 64;\n/** Summed per-cluster density grids kept (one per cluster × bin × dataset). */\nconst DENSITY_CACHE_SIZE = 256;\n\n/** A transcript fetch the planner can key before running. */\nexport interface TranscriptJob {\n  /** What one entry is — decides what hovering it says. */\n  kind: TranscriptKind;\n  /** For bins: their size and grid origin, so a hovered bin's square can be recovered. */\n  bin?: TranscriptBin;\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(ctx: PlanContext): Promise<TranscriptLoad>;\n}\n\nexport interface TranscriptLoad {\n  merged: SpatialTranscriptTile;\n  px: Float32Array;\n  /** For a gene selection: group it on this bin ladder once hidden genes are dropped. */\n  ladder?: { baseBin: number; levels: number; start: number | null };\n  /** Already one marker per cluster per bin (zoomed out, from the density grids): no cells. */\n  clustered?: { group: Int32Array; names: string[]; genes: string[][]; bin: number; origin: [number, number] };\n  kind?: TranscriptJob['kind'];\n  bin?: TranscriptJob['bin'];\n}\n\n/**\n * Decides which transcripts the 2D spatial view fetches, at which level, for the current\n * camera and selection: a {@link TranscriptJob} that can be keyed before it runs (so an\n * unchanged plan is a no-op) and that fetches and merges when run.\n *\n * Pure apart from the port, so the level policy is testable without a viewer. Owns the\n * cache of summed per-cluster density grids a zoomed-out gene selection is drawn from.\n */\nexport class TranscriptJobPlanner {\n  /** Summed per-cluster density grids (see densityFor). */\n  private readonly densityCache = new LruCache<Promise<SpatialDensityRaster>>(DENSITY_CACHE_SIZE);\n\n  constructor(private readonly port: SpatialDataPort) {}\n\n  /**\n   * The job that draws the view's transcripts as markers (circles or icons), or null when the\n   * view draws none or the port cannot serve them.\n   */\n  jobFor(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    rect: DataRect,\n    pxPerUnit: number,\n  ): TranscriptJob | null {\n    const mode = view.transcriptMode;\n    if (mode !== 'circles' && mode !== 'glyphs') return null;\n    const geneBins = this.port.getTranscriptGeneBins && dataset.transcriptGeneBins;\n    if (!this.port.getTranscriptTile && !geneBins) return null;\n    return view.transcriptAllGenes\n      ? this.allGenesJob(dataset, view, rect, pxPerUnit)\n      : this.geneJob(dataset, view, rect, pxPerUnit);\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,\n    view: SpatialViewState,\n    rect: DataRect,\n    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 = pxPerMicronOf(dataset, pxPerUnit);\n    const clip = clipWindow(rect);\n    // Zoomed out, each gene's transcripts are grouped on the all-gene pyramid's bin ladder,\n    // so a gene selection reads like \"all genes\" does: one marker per gene per area, sized\n    // by how many it holds; zoomed in far enough, every transcript is its own marker.\n    const ladder = dataset.transcriptBins?.levels;\n    const baseBin =\n      ladder?.[0]?.binSize ?? (dataset.micronsPerUnit ? PYRAMID_BASE_BIN_UM / dataset.micronsPerUnit : 0);\n    const bin = geneBinSize(pxPerUnit, baseBin, ladder?.length ?? PYRAMID_LEVELS);\n    // Zoomed out to bins as wide as the density grid, a selection is drawn from the per-gene\n    // density grids — one cached request per cluster — rather than 10x's coarse per-gene\n    // tiles, which take minutes for a few hundred genes.\n    // With the pyramid's per-gene levels, every zoom of a selection reads them: the level the\n    // zoom calls for, coarser while the markers would exceed the max.\n    // Both are built from high-quality calls only: with low-quality calls included, the\n    // quality-aware tiles below serve every zoom (as long as there are tiles to serve).\n    const highOnly = view.transcriptQuality !== 'all' || !this.port.getTranscriptTile;\n    const geneBins = dataset.transcriptGeneBins;\n    const fromGeneBins = highOnly && geneBins && this.port.getTranscriptGeneBins;\n    if (fromGeneBins && (bin !== null || !this.port.getTranscriptTile)) {\n      return this.geneBinsJob(dataset, view, clip, geneBins, bin ?? geneBins.levels[0].binSize);\n    }\n    const grid = dataset.density?.gridSize[0] ?? 0;\n    if (highOnly && bin !== null && grid > 0 && this.port.getDensity && bin >= grid * 0.75) {\n      return this.clusterDensityJob(dataset, view, clip, pxPerUnit, Math.max(bin, grid));\n    }\n    return {\n      kind: 'genes',\n      // The clip window, in quarter-view steps: a pan past the margin re-clips.\n      key:\n        `genes|${genes.join(',')}|${view.transcriptQuality}|${view.transcriptBudget}|${bin ?? 'each'}|` +\n        `${clip.key}|${keysAt(first).map(tileId)}`,\n      load: async (ctx) => {\n        // The zoom's own level only: over the budget, the transcripts are combined into\n        // larger markers (groupSelection), never fetched from slower coarse levels.\n        const tiles = await ctx.fetchAll(keysAt(first), (k) =>\n          this.port.getTranscriptTile!(k.level, k.gx, k.gy, query),\n        );\n        // Only what is on screen (and a margin, so a small pan needs nothing new) counts\n        // against the budget and the cap; a tile reaches far past the view.\n        const merged = mergeTranscriptTiles(\n          tiles.map((t) => clipTranscripts(t, clip.around)),\n          MAX_TRANSCRIPTS,\n        );\n        const px = Float32Array.from(merged.weight, (w) =>\n          transcriptMarkerPx(w, view.transcriptScale, pxPerMicron),\n        );\n        return baseBin > 0\n          ? { merged, px, ladder: { baseBin, levels: ladder?.length ?? PYRAMID_LEVELS, start: bin } }\n          : { merged, px };\n      },\n    };\n  }\n\n  /**\n   * A gene selection from the pyramid's per-gene levels: starting at the level whose bins are\n   * `startBin`, fetch the view's tiles for the selected genes and step to a coarser level while\n   * one marker per cluster per bin would exceed the max. Hidden genes are fetched too (their\n   * counts in view still show) and dropped before drawing; grouping by cluster happens there.\n   */\n  private geneBinsJob(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    clip: ClipWindow,\n    meta: NonNullable<SpatialDataset['transcriptGeneBins']>,\n    startBin: number,\n  ): TranscriptJob {\n    const genes = view.transcriptGenes;\n    const levels = meta.levels;\n    let first = levels.findIndex((l) => l.binSize >= startBin * 0.999);\n    if (first < 0) first = levels.length - 1;\n    const budget = Math.max(1, view.transcriptBudget);\n    const hidden = new Set(view.transcriptHiddenGenes);\n    const clusters = this.selectionClusters(view);\n    const clusterOf = new Map<number, number>();\n    clusters.forEach((c, ci) => c.genes.forEach((g) => clusterOf.set(genes.indexOf(g), ci)));\n    const keysAt = (m: number) =>\n      tilesInRectFrom(\n        meta.origin,\n        clip.around,\n        m,\n        levels.map((l) => ({ tileSize: l.tileSize })),\n        null,\n        MAX_BIN_TILES,\n      );\n    return {\n      kind: 'genes',\n      key:\n        `gene-bins|${genes.join(',')}|${budget}|${first}|${JSON.stringify(view.transcriptGeneGroups)}|` + clip.key,\n      load: async (ctx) => {\n        let m = first;\n        for (;;) {\n          const tiles = await ctx.fetchAll(keysAt(m), (k) =>\n            this.port.getTranscriptGeneBins!(k.level, k.gx, k.gy, genes),\n          );\n          const clipped = tiles.map((t) => clipTranscripts(t, clip.around));\n          // Past the cap a merge would drop whole genes (the tail of every tile): go coarser.\n          if (clipped.reduce((n, t) => n + t.count, 0) > MAX_TRANSCRIPTS && m < levels.length - 1) {\n            m++;\n            continue;\n          }\n          const merged = mergeTranscriptTiles(clipped, MAX_TRANSCRIPTS);\n          // Markers this level would draw: one per (visible cluster, bin).\n          const seen = new Set<string>();\n          const bin = levels[m].binSize;\n          for (let i = 0; i < merged.count; i++) {\n            if (hidden.has(genes[merged.gene[i]])) continue;\n            const c = clusterOf.get(merged.gene[i]);\n            if (c === undefined) continue;\n            seen.add(`${c}|${Math.floor(merged.x[i] / bin)}|${Math.floor(merged.y[i] / bin)}`);\n          }\n          if (seen.size <= budget || m >= levels.length - 1) {\n            return { merged, px: new Float32Array(merged.count), ladder: { baseBin: bin, levels: 1, start: bin } };\n          }\n          m++;\n        }\n      },\n    };\n  }\n\n  /** The selection's clusters: each gene-tree group's visible genes, then each ungrouped gene. */\n  private selectionClusters(view: SpatialViewState): { name: string; genes: string[]; slot: number }[] {\n    const hidden = new Set(view.transcriptHiddenGenes);\n    const slots = new Map(view.transcriptGenes.map((g, i) => [g, i]));\n    const taken = new Set<string>();\n    const out: { name: string; genes: string[]; slot: number }[] = [];\n    for (const g of view.transcriptGeneGroups) {\n      const genes = g.genes.filter((x) => slots.has(x) && !hidden.has(x) && !taken.has(x));\n      genes.forEach((x) => taken.add(x));\n      if (genes.length) out.push({ name: g.name, genes, slot: slots.get(genes[0])! });\n    }\n    for (const gene of view.transcriptGenes) {\n      if (!taken.has(gene) && !hidden.has(gene)) out.push({ name: gene, genes: [gene], slot: slots.get(gene)! });\n    }\n    return out;\n  }\n\n  /**\n   * Per-gene density grids summed for `genes`, cached (a cluster is asked for once per bin).\n   * Keyed by dataset too: this manager outlives a dataset, and another may share gene names.\n   * Least-recently-USED eviction, so the clusters in view stay cached; a failed request is\n   * dropped so the next plan asks again.\n   */\n  private densityFor(dataset: string, genes: string[], bin: number): Promise<SpatialDensityRaster> {\n    const key = `${dataset}|${bin}|${genes.join(',')}`;\n    let p = this.densityCache.get(key);\n    if (!p) {\n      const request = this.port.getDensity!(genes, bin);\n      request.catch(() => {\n        if (this.densityCache.get(key) === request) this.densityCache.delete(key);\n      });\n      this.densityCache.set(key, request);\n      p = request;\n    }\n    return p;\n  }\n\n  /**\n   * A gene selection zoomed out: one marker per cluster per bin, from the per-gene density\n   * grids. The bin starts where markers are 14 px apart and doubles until the markers fit the\n   * max; each marker sits at the count-weighted centre of the finer grid inside it, so markers\n   * follow the tissue rather than a lattice.\n   */\n  private clusterDensityJob(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    clip: ClipWindow,\n    pxPerUnit: number,\n    startBin: number,\n  ): TranscriptJob {\n    const grid = dataset.density!.gridSize[0];\n    const clusters = this.selectionClusters(view);\n    let first = grid;\n    while (first < startBin * 0.999) first *= 2;\n    const budget = Math.max(1, view.transcriptBudget);\n    return {\n      kind: 'genes',\n      key:\n        `clusters|${clusters.map((c) => `${c.name}:${c.genes.join('+')}`).join(';')}|${budget}|${first}|` +\n        clip.key,\n      load: async () => {\n        let bin = first;\n        for (;;) {\n          // The finer grid gives each marker its centre; the server bins 1, 2, 4 or 8 cells.\n          const fine = Math.min(bin >= grid * 2 ? bin / 2 : bin, grid * 8);\n          const rasters = await Promise.all(clusters.map((c) => this.densityFor(dataset.id, c.genes, fine)));\n          const out = clusterMarkers(\n            rasters,\n            clusters.map((c) => c.slot),\n            bin,\n            clip.around,\n          );\n          if (out.tile.count <= budget || bin >= grid * 2 ** 12) {\n            const px = groupedSizes(out.tile.weight, bin * pxPerUnit, view.transcriptScale);\n            return {\n              merged: out.tile,\n              px,\n              kind: 'genes',\n              clustered: {\n                group: out.group,\n                names: clusters.map((c) => c.name),\n                genes: clusters.map((c) => c.genes),\n                bin,\n                origin: rasters[0]?.meta.origin ?? [0, 0],\n              },\n            };\n          }\n          bin *= 2;\n        }\n      },\n    };\n  }\n\n  /**\n   * Every gene: the transcripts themselves once they fit the budget, else bins of the\n   * all-gene pyramid sized by how many transcripts each holds.\n   */\n  private allGenesJob(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    rect: DataRect,\n    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,\n      bounds,\n      pxPerUnit,\n      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)),\n        Math.max(k.gy * size, r10(rect.y0, false)),\n        Math.min((k.gx + 1) * size, r10(rect.x1, true)),\n        Math.min((k.gy + 1) * size, r10(rect.y1, true)),\n      ]);\n      const pxPerMicron = pxPerMicronOf(dataset, pxPerUnit);\n      return {\n        kind: 'individual',\n        key: `all|individual|${view.transcriptBudget}|${boxes.map((b) => b.join(',')).join(';')}`,\n        load: async (ctx) => {\n          const got = await ctx.fetchAll(\n            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          );\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,\n              bounds,\n              pxPerUnit,\n              budget: view.transcriptBudget,\n              total: bins.count,\n              levels: bins.levels,\n              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(ctx)), kind: job.kind, bin: job.bin };\n            }\n          }\n          const merged = mergeTranscriptTiles(got, cap);\n          // One transcript per entry: every marker is the same size.\n          const px = new Float32Array(merged.count).fill(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,\n    rect: DataRect,\n    pxPerUnit: number,\n    bounds: SpatialBounds,\n    bins: NonNullable<SpatialDataset['transcriptBins']>,\n    level: number,\n  ): TranscriptJob {\n    const lv = bins.levels[level];\n    const keys = tilesInRectFrom(\n      bins.origin,\n      rect,\n      level,\n      bins.levels.map((l) => ({ tileSize: l.tileSize })),\n      bounds,\n      MAX_BIN_TILES,\n    );\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 (ctx) => {\n        const got = await ctx.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        return { merged, px: groupedSizes(merged.weight, lv.binSize * pxPerUnit, view.transcriptScale) };\n      },\n    };\n  }\n}\n\n/**\n * Group a gene selection for the zoom: one marker per gene-tree cluster (a gene in no\n * cluster is its own) per bin of the pyramid ladder, starting at the finest bin whose\n * markers are 14 px apart and stepping up while the markers would exceed the budget.\n * Null to draw every transcript: zoomed in, with the selection within the budget.\n */\nexport function groupSelection(\n  t: SpatialTranscriptTile,\n  view: SpatialViewState,\n  ladder: NonNullable<TranscriptLoad['ladder']>,\n  pxPerUnit: number,\n): { merged: SpatialTranscriptTile; px: Float32Array; bin: number; group: Int32Array; names: string[] } | null {\n  const budget = Math.max(1, view.transcriptBudget);\n  const genes = view.transcriptGenes;\n  const groups = view.transcriptGeneGroups;\n  const names = [...groups.map((g) => g.name), ...genes];\n  const clusterOf = genes.map((gene, slot) => {\n    const g = groups.findIndex((x) => x.genes.includes(gene));\n    return g >= 0 ? g : groups.length + slot;\n  });\n  const keyOf = (slot: number) => clusterOf[slot] ?? groups.length + slot;\n  let bin = ladder.start;\n  if (bin === null) {\n    // Every transcript, if they fit the max and none was cut off at the cap.\n    if (t.count <= budget && t.count < MAX_TRANSCRIPTS) return null;\n    bin = ladder.baseBin;\n  }\n  const top = ladder.baseBin * 2 ** (ladder.levels - 1);\n  let grouped = groupTranscripts(t, bin, keyOf);\n  // Over the max: combine into larger markers, a level at a time.\n  while (grouped.tile.count > budget && bin < top) {\n    bin *= 2;\n    grouped = groupTranscripts(t, bin, keyOf);\n  }\n  const px = groupedSizes(grouped.tile.weight, bin * pxPerUnit, view.transcriptScale);\n  return { merged: grouped.tile, px, bin, group: grouped.group, names };\n}\n\n/** Screen sizes of grouped markers: by weight against the 95th-percentile weight, over `binPx`. */\nfunction groupedSizes(weight: Uint32Array, binPx: number, scale: number): Float32Array {\n  const refCount = quantileOf(weight, 0.95);\n  return Float32Array.from(weight, (w) => groupedMarkerPx(w, refCount, binPx, scale));\n}\n\n/** What a gene selection's job fetches and clips to: the view and a quarter-view margin each side,\n *  so a small pan needs nothing new. */\ninterface ClipWindow {\n  around: DataRect;\n  /** The window in quarter-view steps, for a job key: a pan past the margin re-clips. */\n  key: string;\n}\n\nfunction clipWindow(rect: DataRect): ClipWindow {\n  const mx = (rect.x1 - rect.x0) * 0.25;\n  const my = (rect.y1 - rect.y0) * 0.25;\n  return {\n    around: { x0: rect.x0 - mx, y0: rect.y0 - my, x1: rect.x1 + mx, y1: rect.y1 + my },\n    key: `${Math.floor(rect.x0 / (mx || 1))},${Math.floor(rect.y0 / (my || 1))}`,\n  };\n}\n\n/** Physical marker size needs µm; undefined when the dataset's unit is unknown. */\nfunction pxPerMicronOf(dataset: SpatialDataset, pxPerUnit: number): number | undefined {\n  return dataset.micronsPerUnit ? pxPerUnit / dataset.micronsPerUnit : undefined;\n}\n"]}