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

package/esm2022/lib/implementations/napari-js/napari-visualizer.service.mjs

@@ -1,9 +1,24 @@
 import { Inject, Injectable, Optional } from '@angular/core';
-import { BehaviorSubject, Subject, combineLatest, from, of } from 'rxjs';
+import { BehaviorSubject, Subject, combineLatest, from, of, } from 'rxjs';
 import { saveAs } from 'file-saver';
-import { Viewer, histogramScalar, colormapFromLut, tintColormap, reverseColormap, heightField, MultiChannelImageView, MultiChannelVolumeView, } from 'napari-js';
+import { Viewer, histogramScalar, colormapFromLut, tintColormap, reverseColormap, heightField, LUT_SIZE, MultiChannelImageView, MultiChannelVolumeView, } from 'napari-js';
+import { nearestProjectedIndex, ScreenIndex, SCREEN_INDEX_MIN_POINTS } from 'napari-js';
 import { buildColormapLut } from '../../contracts/colormap-lut';
-import { PlotType, PLOT_TYPE_DESCRIPTORS, isNapari3d, isNapariIsosurface, isNapariSurface, isNapariScatter, isNapariScatter3d, NAPARI_DEFAULT_DECIMATE, } from '../../contracts/plot-type';
+import { SPATIAL_DATA_PORT } from '../../contracts/ports/spatial-data.port';
+import { findColumnMeta, isCategoricalColumn, } from '../../contracts/spatial-dataset.contract';
+import { contrastWindow, encodeCategorical, encodeContinuous, markerDiameters, resolveCategoryColors, toRgbaTuples, parseHex, MISSING_COLOR, DEFAULT_MUTED_OPACITY, SPATIAL_3D_MAX_CATEGORIES, spatialContinuousLut, } from '../../spatial/spatial-encoding';
+import { NO_CATEGORY } from '../../contracts/spatial-dataset.contract';
+import { emptySelection, maskToIndices, mutedFromSelection, sameSelection, selectByCategory, } from '../../spatial/spatial-selection';
+import { framePositions } from '../../spatial/spatial-framing';
+import { PIXEL_WORLD_QUANTUM, worldQuantumForExtent } from '../../spatial/world-grid';
+import { observationsInSlice, volumeImageRef } from '../../spatial/spatial-volume-image';
+import { defaultSigma, densityGrid, rasterizeDensity } from '../../spatial/spatial-density';
+import { observationsInSection, sectionsOf } from '../../spatial/spatial-sections';
+import { hoverText, nearestObservation } from '../../spatial/spatial-hover';
+import { NapariSpatialTooltip } from './napari-spatial-tooltip';
+import { NAPARI_WHEEL_ZOOM_SPEED } from './napari-zoom';
+import { colorExpressionField, encodeExpressionVolume, expressionField, expressionVolume, } from '../../spatial/spatial-expression';
+import { PlotType, PLOT_TYPE_DESCRIPTORS, isNapari3d, isNapariIsosurface, isNapariSurface, isNapariScatter, isNapariScatter3d, isSpatialOmics, isSpatialOmics3d, NAPARI_DEFAULT_DECIMATE, } from '../../contracts/plot-type';
 import { ViewerFeature, capabilitiesOf, } from '../../contracts/capabilities.contract';
 import { VIZ_CONFIG } from '../../contracts/viz-config';
 import { TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';
@@ -34,6 +49,39 @@ import * as i7 from "../../toolbar/segmentation/sam-tool.service";
 import * as i8 from "../../toolbar/segmentation/sam-point-tool.service";
 import * as i9 from "../../toolbar/segmentation/cell-segment-tool.service";
 import * as i10 from "../simple-slice-access.service";
+import * as i11 from "../../store/spatial-selection.service";
+/**
+ * A short, stable id for a colormap value, for cache keys.
+ *
+ * Half the library's colormaps are NAMES and half are inline `[stop, colour]`
+ * arrays of 256 entries. Stringifying the array kind would put 6 KB in a key that
+ * is rebuilt and compared on every view change; hashing it keeps the key small,
+ * and it only has to distinguish one colormap from another.
+ */
+function colormapId(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return '?';
+    // FNV-1a over the stops. A collision would leave a stale colouring on screen,
+    // not corrupt anything, and 32 bits over a few hundred colormaps will not.
+    let hash = 0x811c9dc5;
+    const text = value.map((stop) => String(stop)).join(',');
+    for (let i = 0; i < text.length; i++) {
+        hash ^= text.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return `#${(hash >>> 0).toString(36)}`;
+}
+/**
+ * In-plane coarsening of the 3D gene map's lattice, relative to the reference
+ * volume. The field is smooth, so its detail is set by the kernel rather than the
+ * raster — and the estimate is a pair of separable blurs on the main thread, which
+ * at the template's full resolution means seconds of frozen UI per toggle.
+ */
+const GENE_MAP_VOLUME_STRIDE = 2;
 /** ICoordinateTransform over the napari camera: pointer client coords ↔ image/world coords. */
 class NapariCoordinateTransform {
     constructor(viewer, ready) {
@@ -108,22 +156,11 @@ const DEFAULT_TINTS = ['#ff0000', '#00ff00', '#0000ff', '#ffff00', '#ff00ff', '#
 function tintFor(channel) {
     return DEFAULT_TINTS[channel % DEFAULT_TINTS.length];
 }
-/**
- * A WebGPU image backend built on the published `napari-js` library — the POC engine for
- * jit-ui#102 (a browser-based napari shipped as a JS library, swapping image plotting with
- * OpenSeadragon and 3D slicing/isosurfaces with Plotly).
- *
- * Render strategy: rather than re-implement the server's tile/pyramid protocol (which OSD
- * already handles), this backend renders the **complete per-slice image URLs the app already
- * produces** (`IImageInfo.urls`) — `urls[z]` for the 2D image, and the full `urls` stack
- * assembled into a downsampled volume for the 3D types. Region state and display options
- * delegate to the shared {@link RegionStore} / {@link VisualizerStore}, exactly as OSD does.
- *
- * Follow-ups (jit-ui#102): native-resolution pyramidal tiling, on-canvas tools, region
- * overlay rendering, per-channel histograms, TIFF export.
- */
 export class NapariVisualizerService extends BaseStoreVisualizer {
-    constructor(tiles, store, regionStore, wandTool, brushTool, eraserTool, zoomToBoxTool, samTool, samPointTool, cellSegmentTool, cellSegmenter, simpleStack, config) {
+    constructor(tiles, store, regionStore, wandTool, brushTool, eraserTool, zoomToBoxTool, samTool, samPointTool, cellSegmentTool, cellSegmenter, simpleStack, config, 
+    // Optional: only a host that serves spatial-omics data provides it, and
+    // without it the SPATIAL_OMICS plot type is never offered anyway.
+    spatialData = null, selectionStore = null) {
         super(regionStore, store);
         this.tiles = tiles;
         this.wandTool = wandTool;
@@ -135,6 +172,8 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
         this.cellSegmentTool = cellSegmentTool;
         this.cellSegmenter = cellSegmenter;
         this.simpleStack = simpleStack;
+        this.spatialData = spatialData;
+        this.selectionStore = selectionStore;
         this.capabilities = capabilitiesOf([
             ViewerFeature.ImageDisplay,
             ViewerFeature.StackSlider,
@@ -175,6 +214,97 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
         this.scatterRegionSub = null;
         /** napari-js 3D scatter (voxel point cloud). */
         this.scatter3dLayer = null;
+        /** Spatial-omics observation markers + the dataset/view subscription driving them. */
+        this.spatialPoints = null;
+        /** The 3D point cloud. One layer: selection is a per-point alpha on it, not a second. */
+        this.spatialPoints3d = null;
+        this.spatialLayerKey3d = null;
+        /** Interleaved x,y,z, cached so a colour change does not re-walk 3.7M observations. */
+        this.spatialPositions3d = null;
+        /** Identity of the scalars currently uploaded — see {@link rebuildSpatialPoints3d}. */
+        this.spatialScalarKey3d = null;
+        /** The anatomical volume the cloud sits inside, when the dataset has one. */
+        this.spatialVolume = null;
+        this.spatialVolumeKey = null;
+        /** Per-cluster density volumes drawn alongside the cloud, and what they were
+         *  built from — rasterising is seconds of work, so it must not repeat for a
+         *  change that cannot affect the field. */
+        this.densityLayers = [];
+        this.densityKey = null;
+        /** Selection identity, as a number the density key can carry. */
+        this.lastSelectionSeen = null;
+        this.selectionRevision = 0;
+        /** The gene map: its layer, the field it was estimated from, and the inputs each
+         *  was built for — the field is the expensive half and survives a recolour. */
+        this.geneMapLayer = null;
+        this.geneMapKey = null;
+        this.geneMapField = null;
+        this.geneMapFieldKey = null;
+        /** The 3D gene map: its volume layer, the field behind it, and the inputs each
+         *  was built for — same two clocks as the 2D map. */
+        this.geneMapVolumeLayer = null;
+        this.geneMapVolumeKey = null;
+        this.geneMapVolumeField = null;
+        this.geneMapVolumeFieldKey = null;
+        /** Offset applied to observation coordinates to sit them in the volume's box. */
+        this.spatialOrigin3d = [0, 0, 0];
+        /** Cursor tooltip for the spatial views, and everything it needs: what the
+         *  cloud is coloured by, and where each drawn observation is. */
+        this.spatialTooltip = null;
+        this.hoverSource = null;
+        this.hoverSourceKey = null;
+        /** Sequences the async resolutions. The KEY is only committed once one lands,
+         *  so a superseded fetch cannot leave the cache claiming to hold a source it
+         *  never stored. */
+        this.hoverSourceToken = 0;
+        /** Drawn observations' positions for hit-testing, indexed BY OBSERVATION with
+         *  NaN for anything not drawn. Screen pixels in 3D (the camera moves them, so
+         *  they are rebuilt when it does) and WORLD units in 2D (where the camera only
+         *  scales, so the pointer is converted instead of 374k points). */
+        this.hoverPositions = null;
+        this.hoverPositionsRev = -1;
+        /**
+         * Screen-space bucket index over the 3D projection, built on the first hover after the
+         * scene moved rather than when it moves.
+         *
+         * Lazily, and that is the whole design: an orbit drag changes the camera every frame, so
+         * building eagerly would spend tens of milliseconds a frame indexing for picks nobody is
+         * making. Deferred, it is built once when the drag stops and the pointer next moves —
+         * measured upstream at 3.7M points, that turns a 12.6 ms scan per pointermove into
+         * 0.066 ms.
+         */
+        this.hoverIndex = null;
+        /** Bumped whenever the cached positions go stale: a marker rebuild, or — in 3D
+         *  only, where the projection depends on it — a camera move. */
+        this.spatialSceneRev = 0;
+        this.hoverPointer = null;
+        this.hoverFrame = 0;
+        this.hoverOff = [];
+        /** Observation indices the cached 3D positions belong to, in the same order;
+         *  null when every observation is drawn. Without it a projection built from the
+         *  positions is indexed by DRAWN order and silently attributes each point to
+         *  the wrong observation as soon as a section is isolated. */
+        this.spatialDrawn3d = null;
+        /** Reused projection buffers — see {@link getSpatialScreenProjection}. */
+        this.spatialProjection3d = undefined;
+        /** Per-observation depth from the last projection, for the depth-aware hover pick. */
+        this.spatialDepths3d = null;
+        /** The (viewer, dataset) whose 3D scene has already had its opening framing. */
+        /** Whose 2D observations the camera has been framed on — see {@link frameSpatialPointsOnce}. */
+        this.spatial2dFramed = null;
+        /** Dataset the 3D scale bar was built for. */
+        this.spatialScaleBarKey = null;
+        this.spatialSub = null;
+        /** Latest (dataset, view, selection) the spatial subscription saw, so a slice
+         *  change can rebuild the markers for the new plane. */
+        this.spatialLatest = null;
+        /** Which dataset the current marker layer was built for, so a display-only
+         *  change (size, colour, opacity, selection) can update it in place. */
+        this.spatialLayerKey = null;
+        /** Monotonic guard for the async colour rebuild: fetching a gene vector is a
+         *  round-trip, so a fast sequence of colour-by changes can resolve out of
+         *  order. Only the newest rebuild is allowed to touch the layer. */
+        this.spatialRebuildToken = 0;
         /** Monotonic load generation. Bumped by {@link reset} and {@link cancelLoading}; the frame-loading
          *  loops (volume assembly, surface preload) capture it and bail when it changes, so a Cancel (or a
          *  new plot) actually stops fetching frames instead of running to completion in the background. */
@@ -499,11 +629,43 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
         const info = imageLoaded?.imageInfo ?? imageInfo;
         const z = imageLoaded?.z ?? 0;
         try {
-            const viewer = new Viewer({ canvas, background: { r: 0.07, g: 0.07, b: 0.09, a: 1 } });
+            const viewer = new Viewer({
+                canvas,
+                background: { r: 0.07, g: 0.07, b: 0.09, a: 1 },
+                // Set here rather than left to napari-js's own default so the gentler
+                // step applies with the version currently installed. Chosen to match the
+                // OSD backend's step (see OSD_ZOOM_PER_SCROLL): the wheel should feel the
+                // same on an image whichever renderer is drawing it. The step applies per
+                // scroll EVENT, and a trackpad sends a burst of them per swipe, so a step
+                // tuned to a mouse notch runs away under a trackpad.
+                wheelZoomSpeed: NAPARI_WHEEL_ZOOM_SPEED,
+                // The FIRST 3D layer of a scene frames the orbit camera; every later one leaves the
+                // pose alone. A spatial scene is built from several layers and rebuilt constantly —
+                // recolouring by a class, picking a gene, stepping a section — and with napari-js's
+                // previous unconditional framing each of those threw away an orbit the user had set.
+                // The pose it snapped back to depended on WHICH layer was rebuilt, so isolating one
+                // section zoomed to that section's bounds. `resetFit3D()` on a dataset change is what
+                // lets the next scene frame itself.
+                fit3d: 'once',
+                // In the spatial modes a plain click SELECTS the class under the cursor,
+                // so napari's OSD-style click-to-zoom is turned off there: otherwise one
+                // click would both select a class and zoom 2x about the cursor, and the
+                // zoom would then halve the pixel radius the next click hit-tests with.
+                // Zooming is still on the wheel, the zoom buttons and the zoom-box tool.
+                ...(isSpatialOmics(plotType) || isSpatialOmics3d(plotType)
+                    ? { clickZoomFactor: 0 }
+                    : {}),
+            });
             this.viewer = viewer;
             await viewer.ready;
-            if (isNapariScatter(plotType)) {
-                await this.mountScatter(viewer, z);
+            if (isSpatialOmics3d(plotType)) {
+                await this.mountSpatialOmics3d(viewer, host);
+            }
+            else if (isSpatialOmics(plotType)) {
+                await this.mountSpatialOmics(viewer, host, z);
+            }
+            else if (isNapariScatter(plotType)) {
+                await this.mountScatter(viewer, host, z);
             }
             else if (isNapariScatter3d(plotType)) {
                 await this.mountScatter3d(viewer, info);
@@ -519,11 +681,7 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
                 this.fitCameraSoon();
                 this.subscribeDisplayState();
                 this.installScaleBar();
-                this.regionOverlay = new NapariRegionOverlay(host, viewer, this.regionStore);
-                this.buildToolHosts();
-                // Keep the pixel-tool readback (lastPixels) current as the view pans/zooms and tiled
-                // levels load, so wand/brush/SAM sample the actually-displayed image (jit-ui#102).
-                this.cameraReadbackOff = viewer.camera.changed.connect(() => this.armReadback());
+                this.install2dInteraction(viewer, host);
             }
             this.scheduleReadback();
             return true;
@@ -960,7 +1118,7 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
         const states = this.store.currentChannelStates();
         this.volumeChannelData.clear();
         this.volumeMultichannel = multichannel;
-        this.imageMode = multichannel ? 'multichannel' : 'grayscale';
+        this.imageMode = this.volumeMultichannel ? 'multichannel' : 'grayscale';
         const view = new MultiChannelVolumeView(viewer);
         this.volumeView = view;
         // Assemble per-channel scalar volumes from the server tiles (jit-specific); the napari-js view
@@ -1021,15 +1179,41 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
         // to shrink at higher resolution. Instead anchor the in-plane long side to a fixed reference and
         // let Z span the full slice count; the box shape is then identical at every decimate factor. The
         // per-axis `voxelSize` (napari `scale`) maps the sampled grid onto that fixed world box.
-        const fullW = this.descriptor?.width ?? dims.width;
-        const fullH = this.descriptor?.height ?? dims.height;
-        const fullD = this.loaded?.imageInfo.imageMeta?.[0]?.z || this.loaded?.imageInfo.urls?.length || dims.depth;
-        const fullLong = Math.max(1, fullW, fullH);
-        const world = {
-            width: (fullW * VOLUME_WORLD_INPLANE_REF) / fullLong,
-            height: (fullH * VOLUME_WORLD_INPLANE_REF) / fullLong,
-            depth: fullD,
-        };
+        // A stack that declares its physical spacing on ALL THREE axes gets its true
+        // extent as the world box — the only way anisotropy survives, and what makes a
+        // resampled 40 x 40 x 200 µm volume read as a brain instead of a cube-aspect
+        // brick. It needs none of the reference-box arithmetic: a physical box is
+        // already independent of the decimate factor.
+        //
+        // Everything else keeps that arithmetic. Sizing the box by the sampled voxel
+        // counts made higher in-plane resolution grow X/Y while the depth stayed the
+        // (constant) slice count — so Z appeared to shrink at higher resolution.
+        // Anchoring the in-plane long side to a fixed reference and letting Z span the
+        // full slice count makes the box shape identical at every decimate factor.
+        const meta = this.loaded?.imageInfo.imageMeta?.[0];
+        const mppXYZ = meta?.mppX && meta?.mppY && meta?.mppZ ? [meta.mppX, meta.mppY, meta.mppZ] : null;
+        // The image's DECLARED pixel dimensions, which is what mpp is per: the sampled
+        // dims are decimated, so sizing a physical box by them would make the world
+        // box depend on the resolution the user happens to be viewing at.
+        const fullW = this.descriptor?.width ?? meta?.x ?? dims.width;
+        const fullH = this.descriptor?.height ?? meta?.y ?? dims.height;
+        const fullD = meta?.z || this.loaded?.imageInfo.urls?.length || dims.depth;
+        let world;
+        if (mppXYZ) {
+            world = {
+                width: fullW * mppXYZ[0],
+                height: fullH * mppXYZ[1],
+                depth: fullD * mppXYZ[2],
+            };
+        }
+        else {
+            const fullLong = Math.max(1, fullW, fullH);
+            world = {
+                width: (fullW * VOLUME_WORLD_INPLANE_REF) / fullLong,
+                height: (fullH * VOLUME_WORLD_INPLANE_REF) / fullLong,
+                depth: fullD,
+            };
+        }
         // Base box (Z-scale = 1) + the sampled depth drive the live Z-height handle below; the persisted
         // `volumeZScale` (user drag) applies on top so changing resolution keeps the chosen height.
         this.volumeWorldBase = world;
@@ -1042,16 +1226,15 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
         ];
         for (const ch of channels)
             ch.voxelSize = voxelSize;
-        view.render(multichannel ? 'multichannel' : 'grayscale', channels, { rendering });
+        view.render(this.volumeMultichannel ? 'multichannel' : 'grayscale', channels, { rendering });
         this.imageW = dims.width;
         this.imageH = dims.height;
         this.volumeDims = dims;
         // 3D coordinate-axes / scale gizmo + labels, sharing the volume's world box so the gizmo tracks
         // the rendered proportions. Physical scale text still comes from the FULL image extent.
-        const mppX = this.descriptor?.mppX || this.loaded?.imageInfo.imageMeta?.[0]?.mppX || 0;
         this.axesLayer = viewer.addAxes(world.width, world.height, worldZ, { visible: this.axesVisible });
         if (this.host) {
-            this.axesLabels = new NapariAxesLabels(this.host, viewer.camera3d, this.buildAxesLabels({ width: world.width, height: world.height, depth: worldZ }, mppX));
+            this.axesLabels = new NapariAxesLabels(this.host, viewer.camera3d, this.buildAxesLabels({ width: world.width, height: world.height, depth: worldZ }));
             this.axesLabels.setVisible(this.axesVisible);
             // In-view drag handle at the TOP END OF THE Z AXIS (the box's min-XY corner, where the blue
             // "Z" axis + label live), so it reads as the Z-height control. Floated a little past the axis
@@ -1087,28 +1270,53 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
         }
         if (this.axesLayer)
             this.axesLayer.depth = worldZ;
-        const mppX = this.descriptor?.mppX || this.loaded?.imageInfo.imageMeta?.[0]?.mppX || 0;
-        this.axesLabels?.updateAnchors(this.buildAxesLabels({ width: base.width, height: base.height, depth: worldZ }, mppX));
+        this.axesLabels?.updateAnchors(this.buildAxesLabels({ width: base.width, height: base.height, depth: worldZ }));
         this.zHandle?.reposition();
         this.viewer?.requestRender();
     }
     /** Build the X/Y/Z axis-end label specs for the 3D gizmo. Anchors are in the volume's centred
      *  world box (matching the AxesLayer geometry); the scale text reflects the FULL image extent —
      *  physical µm when µm/pixel is known, else pixel (X/Y) / slice (Z) counts. */
-    buildAxesLabels(vol, mppX) {
+    buildAxesLabels(vol) {
         const hx = vol.width / 2;
         const hy = vol.height / 2;
         const hz = vol.depth / 2;
-        const descW = this.descriptor?.width ?? vol.width;
-        const descH = this.descriptor?.height ?? vol.height;
-        const slices = this.loaded?.imageInfo.imageMeta?.[0]?.z || this.loaded?.imageInfo.urls?.length || vol.depth;
-        const len = (px) => (mppX > 0 ? formatUm(px * mppX) : `${px} px`);
+        // Measured from the IMAGE's own extent, never from the world box: the box is a
+        // shape (and for a physically sized volume it is already in µm, so reading a
+        // pixel count off it and multiplying by mpp would scale the label twice).
+        const { px, mpp } = this.imageExtent();
+        const len = (n, um) => (um > 0 ? formatUm(n * um) : `${n} px`);
         return [
-            { anchor: [hx, -hy, -hz], text: `X · ${len(descW)}`, color: '#ed4545' },
-            { anchor: [-hx, hy, -hz], text: `Y · ${len(descH)}`, color: '#4dd959' },
-            { anchor: [-hx, -hy, hz], text: `Z · ${slices} px`, color: '#668cff' },
+            { anchor: [hx, -hy, -hz], text: `X · ${len(px[0], mpp[0])}`, color: '#ed4545' },
+            { anchor: [-hx, hy, -hz], text: `Y · ${len(px[1], mpp[1])}`, color: '#4dd959' },
+            // Physical when the stack declares its slice spacing (`mppZ`) — a resampled
+            // volume knows how thick it is; a plain z-stack can only say how many slices.
+            { anchor: [-hx, -hy, hz], text: `Z · ${len(px[2], mpp[2])}`, color: '#668cff' },
         ];
     }
+    /**
+     * The image's declared extent in pixels/slices, and its physical spacing per
+     * axis in µm (0 = undeclared, and then that axis reads in pixels).
+     *
+     * One place, because the volume world box and the axis labels have to agree
+     * about what the image's real dimensions are — the sampled grid is decimated and
+     * says nothing about either.
+     */
+    imageExtent() {
+        const meta = this.loaded?.imageInfo.imageMeta?.[0];
+        const dims = this.volumeDims;
+        const mppX = this.descriptor?.mppX || meta?.mppX || 0;
+        return {
+            px: [
+                this.descriptor?.width ?? meta?.x ?? dims?.width ?? 1,
+                this.descriptor?.height ?? meta?.y ?? dims?.height ?? 1,
+                meta?.z || this.loaded?.imageInfo.urls?.length || dims?.depth || 1,
+            ],
+            // A descriptor that reports only mppX is square-pixel by convention, which is
+            // what the 2D scale bar already assumes of it.
+            mpp: [mppX, this.descriptor?.mppY || meta?.mppY || mppX, meta?.mppZ || 0],
+        };
+    }
     /**
      * Assemble a downsampled uint8 volume (luminance) from the per-slice tile endpoint. Slices are
      * fetched with bounded concurrency (keeps the connection pool full without flooding it on a deep
@@ -1198,11 +1406,14 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
      * centroid (napari-js analog of Plotly's region-centroid scatter). Rebuilds the points live as
      * regions change.
      */
-    async mountScatter(viewer, z) {
+    async mountScatter(viewer, host, z) {
         await this.renderImage(z);
         this.fitCameraSoon();
         this.subscribeDisplayState();
         this.installScaleBar();
+        // This mode plots REGION centroids, so without the region tools there is no
+        // way to produce a point — drawing a region now adds one immediately.
+        this.install2dInteraction(viewer, host);
         this.rebuildScatterPoints();
         this.scatterRegionSub = this.regionStore
             .getRegionUpdateEvent()
@@ -1260,6 +1471,1641 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
         }
         return new Float32Array(out);
     }
+    /**
+     * The interaction stack every 2D mode needs: the region overlay (draw/select/edit), the pixel
+     * tools that read back displayed pixels (wand, brush, vertex eraser, zoom-to-box, SAM/cellpose),
+     * and a camera hook that keeps that readback current as the view pans/zooms and tiled levels
+     * load.
+     *
+     * Extracted because forgetting it is invisible: the toolbar gates its region buttons on 2D-vs-3D
+     * rather than on plot type, so a 2D mode that skips this shows every tool and silently does
+     * nothing. That is exactly what happened to the spatial and region-centroid scatter modes.
+     */
+    install2dInteraction(viewer, host) {
+        this.regionOverlay = new NapariRegionOverlay(host, viewer, this.regionStore);
+        this.buildToolHosts();
+        this.cameraReadbackOff = viewer.camera.changed.connect(() => this.armReadback());
+    }
+    // ── Spatial omics ────────────────────────────────────────────────────────────────────────
+    /** Marker radius (image px) for a dataset that declares none — segmented cells often don't. */
+    static { this.SPATIAL_FALLBACK_RADIUS = 4; }
+    /** Smallest marker DIAMETER, in slice pixels, over a volume-backed dataset. A cell's real
+     *  size is honoured wherever it survives the grid: the ABC atlas serves 5 µm radii on a
+     *  40 µm/px template, so drawing them to scale would put every cell a fifth of a pixel wide
+     *  and the section would come up empty. The point-size control scales up from this floor. */
+    static { this.SPATIAL_SLICE_MIN_DIAMETER_PX = 1.5; }
+    /** Longest side of the gene-map raster, in field pixels. A gene map is a smooth
+     *  field read as territory, so it gains nothing from matching a 2 Gpx slide's
+     *  resolution — and the estimate costs one pass over this many pixels. */
+    static { this.GENE_MAP_MAX_SIDE = 512; }
+    /** Kernel σ in field pixels at smoothing 1: wide enough to read between cells,
+     *  tight enough to keep a nucleus-scale structure distinct. */
+    static { this.GENE_MAP_SIGMA = 2.5; }
+    /** Clusters drawn as density volumes at once. Past a handful, additive translucent
+     *  clouds stop being separable by eye — and each one is a full rasterisation. */
+    static { this.DENSITY_MAX_CLUSTERS = 6; }
+    /** Colour for observations when nothing is selected to colour by: visible, neutral, and
+     *  obviously not encoding anything. */
+    /** How much larger a selected marker is drawn, so a small selection is findable inside a
+     *  3.7M-point cloud rather than merely brighter. */
+    static { this.SPATIAL_SELECTED_SIZE_SCALE = 1.6; }
+    static { this.SPATIAL_NEUTRAL_COLOR = [0.35, 0.72, 0.95, 0.9]; }
+    /**
+     * Mount the SPATIAL_OMICS view: the tissue image with one marker per observation, coloured by
+     * an annotation column or a gene. The markers rebuild whenever the dataset or the view state
+     * changes, so switching the colour-by column does not remount the scene.
+     *
+     * Sets up the full 2D interaction stack — region overlay, pixel-tool hosts, readback currency —
+     * exactly as the plain image view does. That is NOT optional here: this mode's selection is
+     * driven by drawn ROIs, so without the overlay there is no way to make a selection at all.
+     */
+    async mountSpatialOmics(viewer, host, z) {
+        await this.renderImage(z);
+        // Only fit to the image when this dataset actually has one. Otherwise there is
+        // nothing to fit, `imageW`/`imageH` still hold the LAST image's dimensions, and
+        // this fits to those — and because it defers to a frame, it lands AFTER the points
+        // are added and overwrites the framing they set. That is what left an image-less
+        // dataset as a ten-pixel speck off to one side.
+        if (this.spatialLatest?.[0]?.imageRef)
+            this.fitCameraSoon();
+        this.subscribeDisplayState();
+        this.installScaleBar();
+        this.install2dInteraction(viewer, host);
+        this.installSpatialHover(host);
+        this.subscribeSpatial();
+        this.scheduleReadback();
+    }
+    /**
+     * Region drawing for the 3D cloud.
+     *
+     * Reuses {@link NapariRegionOverlay} verbatim by handing it a SCREEN-SPACE viewer: the drawn
+     * shape is a lasso in canvas pixels, so "world" is the canvas and both transforms are identity
+     * (bar the client→canvas offset). Every existing tool — rectangle, polygon, freehand — therefore
+     * works in 3D with no new drawing code.
+     *
+     * A screen-space shape stops meaning anything the moment the camera moves, so an orbit clears
+     * the drawn regions. The SELECTION it produced is kept: that is the durable artefact, and the
+     * highlighted points stay highlighted from every angle.
+     */
+    install3dInteraction(viewer, host) {
+        const canvasRect = () => this.canvas?.getBoundingClientRect();
+        const screenSpace = {
+            canvasToWorld: (clientX, clientY) => {
+                const r = canvasRect();
+                return r ? [clientX - r.left, clientY - r.top] : [clientX, clientY];
+            },
+            // Already canvas pixels.
+            worldToCanvas: (x, y) => [x, y],
+            setControlsEnabled: (enabled) => viewer.setControlsEnabled(enabled),
+            camera: viewer.camera3d,
+        };
+        this.regionOverlay = new NapariRegionOverlay(host, screenSpace, this.regionStore);
+        this.buildToolHosts();
+        this.cameraReadbackOff = viewer.camera3d.changed.connect(() => {
+            // Only while nothing is being drawn — clearing mid-gesture would delete the
+            // shape under the user's cursor.
+            if (this.regionStore.getRegions().length > 0)
+                this.regionStore.setRegions([]);
+        });
+    }
+    /** Movement, in screen pixels, under which a press-release is a CLICK and not a
+     *  drag. An orbit or a pan starts the same way, so the two have to be told
+     *  apart by how far the pointer travelled. */
+    static { this.CLICK_SLOP_PX = 4; }
+    /** Longest press-release still treated as a click. A long press with the mouse
+     *  held still is more likely an interrupted drag than a selection. */
+    static { this.CLICK_MAX_MS = 600; }
+    /** Pointer distance, in screen pixels, that still counts as "on" a marker.
+     *  Generous relative to a 1.5px disc: the cursor is a blunt instrument, and a
+     *  tooltip you have to hunt for is worse than none. */
+    static { this.HOVER_RADIUS_PX = 10; }
+    /**
+     * Cursor tooltip for the spatial views: hover a marker, read its class.
+     *
+     * A 34-entry legend cannot be read back from a dot — several classes get
+     * similar colours, and matching one to a swatch by eye is exactly the task this
+     * removes. It reports whatever the cloud is CURRENTLY coloured by, so it and
+     * the legend can never say different things.
+     *
+     * Listens on the HOST rather than the canvas so it keeps working over the region
+     * overlay (an SVG covering the canvas, which would otherwise swallow every
+     * move), and throttles to one hit-test per animation frame: a pointermove can
+     * fire far more often than that, and each test is a pass over the cloud.
+     */
+    installSpatialHover(host) {
+        this.removeSpatialHover();
+        this.spatialTooltip = new NapariSpatialTooltip(host);
+        const onMove = (e) => {
+            const canvas = this.canvas;
+            if (!canvas)
+                return;
+            const rect = canvas.getBoundingClientRect();
+            this.hoverPointer = {
+                x: e.clientX - rect.left,
+                y: e.clientY - rect.top,
+                clientX: e.clientX,
+                clientY: e.clientY,
+            };
+            if (this.hoverFrame)
+                return;
+            this.hoverFrame = requestAnimationFrame(() => {
+                this.hoverFrame = 0;
+                this.updateHover(host);
+            });
+        };
+        const onLeave = () => {
+            this.hoverPointer = null;
+            this.spatialTooltip?.hide();
+        };
+        // A click on a marker selects its class, exactly as clicking that class in the
+        // panel's legend does — including clicking again to clear, so a click is
+        // always reversible. Tracked as down/up rather than bound to `click` so a DRAG
+        // (an orbit in 3D, a pan in 2D) can be told apart from a click: the gesture
+        // has to move less than a few pixels and be over quickly.
+        let down = null;
+        const onDown = (e) => {
+            down = { x: e.clientX, y: e.clientY, t: Date.now() };
+        };
+        const onUp = (e) => {
+            const start = down;
+            down = null;
+            if (!start)
+                return;
+            const moved = Math.hypot(e.clientX - start.x, e.clientY - start.y);
+            if (moved > NapariVisualizerService.CLICK_SLOP_PX)
+                return;
+            if (Date.now() - start.t > NapariVisualizerService.CLICK_MAX_MS)
+                return;
+            // A region tool owns the pointer while it is active, and placing a polygon
+            // vertex is also a click that does not move.
+            if (this.regionOverlay?.toolActive)
+                return;
+            this.selectClassAt(e.clientX, e.clientY);
+        };
+        host.addEventListener('pointermove', onMove);
+        host.addEventListener('pointerleave', onLeave);
+        host.addEventListener('pointerdown', onDown);
+        host.addEventListener('pointerup', onUp);
+        this.hoverOff.push(() => host.removeEventListener('pointermove', onMove));
+        this.hoverOff.push(() => host.removeEventListener('pointerleave', onLeave));
+        this.hoverOff.push(() => host.removeEventListener('pointerdown', onDown));
+        this.hoverOff.push(() => host.removeEventListener('pointerup', onUp));
+        // In 3D the cached positions are screen pixels, so an orbit invalidates them.
+        const camera = this.viewer?.camera3d;
+        if (camera && isSpatialOmics3d(this.currentPlotType)) {
+            const off = camera.changed.connect(() => {
+                this.spatialSceneRev++;
+            });
+            this.hoverOff.push(off);
+        }
+    }
+    removeSpatialHover() {
+        for (const off of this.hoverOff)
+            off();
+        this.hoverOff = [];
+        if (this.hoverFrame)
+            cancelAnimationFrame(this.hoverFrame);
+        this.hoverFrame = 0;
+        this.hoverPointer = null;
+        this.spatialTooltip?.dispose();
+        this.spatialTooltip = null;
+        this.hoverPositions = null;
+        this.hoverPositionsRev = -1;
+        this.hoverIndex = null;
+    }
+    /** Hit-test the last pointer position and show or hide the tooltip. */
+    updateHover(host) {
+        const tip = this.spatialTooltip;
+        const pointer = this.hoverPointer;
+        const dataset = this.spatialLatest?.[0];
+        if (!tip || !pointer || !dataset)
+            return;
+        const positions = this.hoverPositionsFor(dataset.observations);
+        if (!positions) {
+            tip.hide();
+            return;
+        }
+        const is3d = isSpatialOmics3d(this.currentPlotType);
+        // 3D compares screen pixels directly; 2D holds world positions, so the radius
+        // is converted once instead of projecting the whole cloud.
+        const zoom = is3d ? 1 : (this.viewer?.camera.zoom ?? 1);
+        const radius = NapariVisualizerService.HOVER_RADIUS_PX / (zoom > 0 ? zoom : 1);
+        let x = pointer.x;
+        let y = pointer.y;
+        if (!is3d) {
+            const world = this.viewer?.canvasToWorld(pointer.clientX, pointer.clientY);
+            if (!world) {
+                tip.hide();
+                return;
+            }
+            [x, y] = world;
+        }
+        const hit = this.pickObservation(positions, x, y, radius, is3d);
+        const lines = hoverText(this.hoverSource, hit);
+        if (!lines) {
+            tip.hide();
+            return;
+        }
+        const rect = host.getBoundingClientRect();
+        tip.show(lines, pointer.clientX - rect.left, pointer.clientY - rect.top);
+    }
+    /**
+     * Select the class of the marker at a client position — the canvas equivalent of
+     * clicking that class in the panel's legend, and the same selection object, so
+     * the two controls cannot produce different results.
+     *
+     * Clicking a class that is already the whole selection CLEARS it, which is what
+     * the legend does. Compared against the selection itself rather than against a
+     * remembered click, so selecting from the legend and then clicking the same
+     * class on the canvas still toggles.
+     */
+    selectClassAt(clientX, clientY) {
+        const source = this.hoverSource;
+        const store = this.selectionStore;
+        const dataset = this.spatialLatest?.[0];
+        // Only a categorical source has classes to select. A gene is continuous:
+        // there is no set of cells that "is" a value.
+        if (!store || !dataset || source?.kind !== 'categorical')
+            return;
+        const positions = this.hoverPositionsFor(dataset.observations);
+        if (!positions)
+            return;
+        const canvas = this.canvas;
+        if (!canvas)
+            return;
+        const rect = canvas.getBoundingClientRect();
+        const is3d = isSpatialOmics3d(this.currentPlotType);
+        const zoom = is3d ? 1 : (this.viewer?.camera.zoom ?? 1);
+        const radius = NapariVisualizerService.HOVER_RADIUS_PX / (zoom > 0 ? zoom : 1);
+        let x = clientX - rect.left;
+        let y = clientY - rect.top;
+        if (!is3d) {
+            const world = this.viewer?.canvasToWorld(clientX, clientY);
+            if (!world)
+                return;
+            [x, y] = world;
+        }
+        const hit = nearestObservation(positions, x, y, radius);
+        if (hit < 0)
+            return;
+        const code = source.codes[hit];
+        // A cell the annotation does not cover has no class to select.
+        if (code === undefined || code === NO_CATEGORY)
+            return;
+        const next = selectByCategory(source.codes, code);
+        const current = store.current();
+        if (sameSelection(current, next)) {
+            store.clear();
+            return;
+        }
+        store.set(next);
+    }
+    /**
+     * Which observation is under the cursor.
+     *
+     * In 3D this defers to napari-js's {@link nearestProjectedIndex} WITH the depths the
+     * projection produced, so the front-most candidate wins. That matters more than it
+     * sounds: the renderer depth-tests the billboards, and in a 3.7M-point cloud the cursor
+     * covers many of them — picking the one nearest the cursor's centre regularly names a
+     * cell that something else is drawn over, which reads as a wrong tooltip rather than as
+     * a subtlety of picking.
+     *
+     * In 2D the positions are WORLD coordinates on one plane, so there is no depth to break
+     * ties with and the existing nearest-marker rule is the right one.
+     */
+    pickObservation(positions, x, y, radius, is3d) {
+        if (!is3d)
+            return nearestObservation(positions, x, y, radius);
+        // The cloud draws a selected marker LARGER, so the pick has to use the same radius the
+        // renderer used — otherwise the highlighted cells, the ones a reader is most likely to
+        // be pointing at, are the hardest to hover.
+        const scale = NapariVisualizerService.SPATIAL_SELECTED_SIZE_SCALE;
+        const mask = this.selectionStore?.current()?.mask;
+        const opts = mask?.length
+            ? { radiusAt: (i) => (mask[i] ? radius * scale : radius) }
+            : undefined;
+        // `radius` still bounds which buckets are visited, so it has to be the LARGEST any
+        // point can claim, not the base one.
+        const reach = mask?.length ? radius * scale : radius;
+        if (this.hoverIndex)
+            return this.hoverIndex.pick(x, y, reach, opts);
+        return nearestProjectedIndex(positions, x, y, reach, this.spatialDepths3d, opts);
+    }
+    /**
+     * Positions to hit-test against, rebuilt only when the scene or camera moved.
+     *
+     * A pass over 3.7M observations is not something to do per pointermove, and the
+     * cloud does not move between frames unless something says it did.
+     */
+    hoverPositionsFor(obs) {
+        if (this.hoverPositions && this.hoverPositionsRev === this.spatialSceneRev) {
+            return this.hoverPositions;
+        }
+        const is3d = isSpatialOmics3d(this.currentPlotType);
+        const built = is3d
+            ? this.getSpatialScreenProjection(obs)
+            : this.hoverWorldPositions(obs);
+        this.hoverPositions = built;
+        this.hoverPositionsRev = this.spatialSceneRev;
+        // Built here, in the same lazy slot, so it is paid for on the first hover after the
+        // scene moved and not on every frame of an orbit. Only worth it past the point where
+        // the linear scan stops being free; below that the build costs more than it saves.
+        this.hoverIndex = null;
+        if (is3d && built && this.canvas && built.length / 2 >= SCREEN_INDEX_MIN_POINTS) {
+            const w = this.canvas.clientWidth || this.canvas.width;
+            const h = this.canvas.clientHeight || this.canvas.height;
+            if (w && h) {
+                this.hoverIndex = new ScreenIndex({ screen: built, depth: this.spatialDepths3d ?? new Float32Array(built.length / 2) }, w, h, 
+                // The largest radius any pick here can claim: the base hover radius, times the
+                // scale a SELECTED marker is drawn at. Stated rather than left to the default,
+                // because it is what decides whether a marker straddling the canvas edge is
+                // found — its centre is off screen while part of it is not.
+                {
+                    maxReach: NapariVisualizerService.HOVER_RADIUS_PX
+                        * NapariVisualizerService.SPATIAL_SELECTED_SIZE_SCALE,
+                });
+            }
+        }
+        return built;
+    }
+    /**
+     * The 2D markers' WORLD positions, indexed by observation, NaN for any not on
+     * the displayed plane — the same affine and the same subset the marker layer was
+     * built from, so the tooltip cannot point at a cell that is not drawn.
+     */
+    hoverWorldPositions(obs) {
+        const dataset = this.spatialLatest?.[0];
+        if (!dataset || obs.count === 0)
+            return null;
+        const slab = this.spatialSlab(dataset);
+        const ref = slab?.ref ?? dataset.imageRef;
+        const [sx, sy] = ref?.scale ?? [1, 1];
+        const [tx, ty] = ref?.translate ?? [0, 0];
+        const drawn = slab?.indices ?? null;
+        const out = new Float32Array(obs.count * 2).fill(NaN);
+        const n = drawn ? drawn.length : obs.count;
+        for (let k = 0; k < n; k++) {
+            const i = drawn ? drawn[k] : k;
+            out[i * 2] = obs.x[i] * sx + tx;
+            out[i * 2 + 1] = obs.y[i] * sy + ty;
+        }
+        return out;
+    }
+    /**
+     * What the tooltip says, resolved once per colour source rather than per hover.
+     *
+     * Fetched separately from the colouring on purpose: the reference port caches
+     * columns, but a host's need not, and re-fetching a 3.7M-element vector because
+     * the pointer moved would be indefensible either way.
+     */
+    async resolveHoverSource(dataset, view) {
+        const port = this.spatialData;
+        const colorBy = view.colorBy;
+        const key = dataset && colorBy
+            ? `${dataset.id}|${colorBy.kind}:${colorBy.name}`
+            : null;
+        if (key === this.hoverSourceKey)
+            return;
+        // The key is committed only where a value is actually stored. Setting it up
+        // front would mean a resolution that loses the race leaves the key claiming a
+        // source that was never stored — and since every later emission carries the
+        // same key, it would short-circuit here forever and the tooltip would stay
+        // silent for the rest of the session.
+        const token = ++this.hoverSourceToken;
+        // No colour source means nothing is being said about the cells, so there is no
+        // cluster to name and the tooltip stays silent.
+        if (!key || !dataset || !colorBy || !port) {
+            this.hoverSource = null;
+            this.hoverSourceKey = key;
+            return;
+        }
+        try {
+            if (colorBy.kind === 'column') {
+                const column = await port.getColumn(colorBy.name);
+                if (token !== this.hoverSourceToken)
+                    return;
+                this.hoverSource = isCategoricalColumn(column)
+                    ? {
+                        kind: 'categorical',
+                        name: colorBy.name,
+                        categories: column.meta.categories,
+                        codes: column.codes,
+                    }
+                    : {
+                        kind: 'continuous',
+                        name: colorBy.name,
+                        values: column.values,
+                        ...(column.meta.unit ? { unit: column.meta.unit } : {}),
+                    };
+                this.hoverSourceKey = key;
+                return;
+            }
+            const values = await port.getFeatureVector(colorBy.name);
+            if (token !== this.hoverSourceToken)
+                return;
+            this.hoverSource = {
+                kind: 'continuous',
+                name: colorBy.name,
+                values,
+                ...(dataset.features?.unit ? { unit: dataset.features.unit } : {}),
+            };
+            this.hoverSourceKey = key;
+        }
+        catch {
+            if (token !== this.hoverSourceToken)
+                return;
+            // The tooltip is an extra; a failed fetch must not disturb the render. The
+            // key is left unset so a later emission retries rather than inheriting a
+            // permanent silence.
+            this.hoverSource = null;
+            this.hoverSourceKey = null;
+        }
+    }
+    /**
+     * Project every observation to canvas pixels under the current 3D camera.
+     *
+     * The projection itself is the renderer's: `viewer.projectPoints` owns the camera, the
+     * viewport in CSS pixels, the perspective divide and the y-flip. This used to be fifteen
+     * lines of column-major matrix arithmetic here, duplicating a second copy in
+     * `napari-axes-labels` — and the two had drifted on what to do with a NaN w.
+     *
+     * What is left is the part that is genuinely this adapter's: SCATTERING the drawn subset
+     * back into observation order. The cloud holds only the points of the displayed section,
+     * in its own packing; every consumer indexes by observation. NaN stands for "not on
+     * screen", which is also the right answer for an observation whose section is hidden.
+     *
+     * Null when the 3D cloud is not mounted, so the caller falls back to the 2D affine path.
+     */
+    getSpatialScreenProjection(obs) {
+        const viewer = this.viewer;
+        if (!viewer || !this.spatialPositions3d)
+            return null;
+        const projected = viewer.projectPoints(this.spatialPositions3d, this.spatialProjection3d);
+        if (!projected)
+            return null;
+        // Reused across camera changes: at 3.7M observations this is a 30 MB allocation that
+        // would otherwise happen on every orbit.
+        this.spatialProjection3d = projected;
+        const drawn = this.spatialDrawn3d;
+        const { screen, depth } = projected;
+        const count = screen.length >> 1;
+        const out = new Float32Array(obs.count * 2).fill(NaN);
+        const depths = new Float32Array(obs.count).fill(NaN);
+        for (let k = 0; k < count; k++) {
+            const i = drawn ? drawn[k] : k;
+            if (i >= obs.count)
+                continue;
+            out[i * 2] = screen[k * 2];
+            out[i * 2 + 1] = screen[k * 2 + 1];
+            depths[i] = depth[k];
+        }
+        // Kept beside the screen positions so the hover pick can prefer the FRONT-most point
+        // under the cursor rather than the one nearest its centre — which in a dense cloud is
+        // regularly something the renderer drew another point over.
+        this.spatialDepths3d = depths;
+        return out;
+    }
+    /** Rebuild the markers on any dataset or view-state change. */
+    subscribeSpatial() {
+        this.spatialSub?.unsubscribe();
+        const port = this.spatialData;
+        if (!port)
+            return;
+        const selection$ = this.selectionStore?.getSelection$() ?? of(emptySelection());
+        // The display colormap is an input here, not just something read at build
+        // time: `continuousColormap: null` means "follow the image's colormap", and a
+        // setting that only takes effect at the next unrelated rebuild is not one.
+        this.spatialSub = combineLatest([
+            port.getDataset$(), this.store.getSpatialView$(), selection$,
+            this.store.getColormap(), this.store.getReverseScale(),
+        ]).subscribe(([dataset, view, selection, colormap, reverse]) => {
+            this.currentColormap = colormap ?? null;
+            this.currentReverse = !!reverse;
+            // Kept so a slice change can redraw the markers for the new plane, which
+            // arrives through setZIndex rather than through any of these streams.
+            this.spatialLatest = [dataset, view, selection];
+            // The markers are about to move or change meaning, so both halves of the
+            // tooltip — where the points are, and what they are — are stale.
+            this.spatialSceneRev++;
+            void this.resolveHoverSource(dataset, view);
+            void (isSpatialOmics3d(this.currentPlotType)
+                ? this.rebuildSpatialPoints3d(dataset, view, selection)
+                : this.rebuildSpatialPoints(dataset, view, selection));
+        });
+    }
+    /** (Re)build the observation marker layer for the current dataset + view state. */
+    async rebuildSpatialPoints(dataset, view, selection = emptySelection()) {
+        const viewer = this.viewer;
+        if (!viewer)
+            return;
+        const token = ++this.spatialRebuildToken;
+        // Resolve colours BEFORE touching the scene: a gene fetch can fail or be
+        // superseded, and dropping the existing layer first would blank the view.
+        let faceColor;
+        try {
+            faceColor = dataset
+                ? await this.spatialFaceColors(dataset, view, selection)
+                : NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;
+        }
+        catch (err) {
+            console.warn('[napari-js] spatial colouring failed — falling back to a flat colour', err);
+            faceColor = NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;
+        }
+        // A newer rebuild (or a teardown) started while the vector was in flight.
+        if (token !== this.spatialRebuildToken || this.viewer !== viewer)
+            return;
+        if (!dataset || dataset.observations.count === 0) {
+            if (this.spatialPoints) {
+                viewer.layers.remove(this.spatialPoints);
+                this.spatialPoints = null;
+                this.spatialLayerKey = null;
+            }
+            if (this.geneMapLayer) {
+                viewer.layers.remove(this.geneMapLayer);
+                this.geneMapLayer = null;
+                this.geneMapKey = null;
+            }
+            return;
+        }
+        const obs = dataset.observations;
+        // A dataset whose image IS its volume shows ONE PLANE at a time, so the
+        // markers are the observations in the displayed plane, drawn in that plane's
+        // pixel grid. Without the filter the specimen's whole depth piles onto one
+        // section and reads as a smear; without the affine the coordinates are read
+        // as pixels and land off the slice entirely.
+        const slab = this.spatialSlab(dataset);
+        // The gene map goes UNDER the cells, so it is settled before they are added.
+        await this.ensureGeneMap(viewer, dataset, view, selection, slab);
+        if (token !== this.spatialRebuildToken || this.viewer !== viewer)
+            return;
+        const ref = slab?.ref ?? dataset.imageRef;
+        const base = markerDiameters(obs, NapariVisualizerService.SPATIAL_FALLBACK_RADIUS);
+        const scale = view.pointScale > 0 ? view.pointScale : 1;
+        const floor = slab?.minDiameter ?? 0;
+        const sizeOf = (i) => Math.max(typeof base === 'number' ? base : base[i], floor) * scale;
+        const size = typeof base === 'number' && !slab
+            ? Math.max(base, floor) * scale
+            : Float32Array.from(slab?.indices ?? { length: obs.count }, (_v, i) => sizeOf(slab ? slab.indices[i] : i));
+        // napari's image view CLEARS the whole layer list on every render, so the
+        // markers go with it whenever the image is re-rendered — a scrub, a contrast
+        // change. The cached handle is then detached, and mutating it draws nothing:
+        // treat a layer that is no longer in the scene as absent so it gets re-added.
+        if (this.spatialPoints && !viewer.layers.items.includes(this.spatialPoints)) {
+            this.spatialPoints = null;
+            this.spatialLayerKey = null;
+        }
+        // A size/colour/opacity/selection change is DISPLAY-only: mutate the layer
+        // rather than dropping and re-adding it. Both setters bump the layer's
+        // dataVersion, which is what makes napari-js rebuild the instance buffer and
+        // redraw — and it avoids rebuilding 84k positions to change one number.
+        // The slice is part of the key: a scrub changes WHICH observations are drawn,
+        // which is geometry, not display.
+        const key = `${dataset.id}:${obs.count}:${slab?.slice ?? ''}`;
+        if (this.spatialPoints && key === this.spatialLayerKey) {
+            this.spatialPoints.size = size;
+            this.spatialPoints.faceColor = this.gatherColors(faceColor, slab?.indices);
+            viewer.requestRender();
+            return;
+        }
+        if (this.spatialPoints) {
+            viewer.layers.remove(this.spatialPoints);
+            this.spatialPoints = null;
+        }
+        const drawn = slab?.indices;
+        const count = drawn ? drawn.length : obs.count;
+        const positions = new Float32Array(count * 2);
+        for (let i = 0; i < count; i++) {
+            const o = drawn ? drawn[i] : i;
+            positions[i * 2] = obs.x[o];
+            positions[i * 2 + 1] = obs.y[o];
+        }
+        this.spatialLayerKey = key;
+        this.spatialPoints = viewer.addPoints(positions, {
+            name: 'observations',
+            size,
+            faceColor: this.gatherColors(faceColor, drawn),
+            // No border: at Visium spot density an outline per marker reads as noise,
+            // and it costs a second colour array.
+            borderWidth: 0,
+            // The dataset's data->world affine. SpatialData records one per coordinate
+            // system (Visium spot coords are in the FULL-resolution frame while the
+            // served image may be the hires downscale), so without this the markers
+            // land in the right shape at the wrong scale. Defaults to identity when
+            // the coordinates are already in the image's pixel space.
+            scale: ref?.scale ?? [1, 1],
+            translate: ref?.translate ?? [0, 0],
+        });
+        this.frameSpatialPointsOnce(viewer, dataset.id, positions, !!ref);
+        this.hideForeignImage(viewer, !!ref || !!dataset.volume);
+        this.setRegionGridFor(dataset, positions);
+    }
+    /**
+     * Tell the region overlay how finely a drawn vertex may be placed.
+     *
+     * Region geometry is stored in whole world units, which is right when the world IS
+     * pixels — a region should align to them. It is wrong for a dataset that registers onto
+     * no image: seqFISH's observations span about 5 x 7 units in total, so whole-unit
+     * vertices leave roughly six by eight placeable positions across the entire sample and
+     * an ROI cannot be drawn at any zoom. Nothing errors; the tool just cannot express the
+     * shape.
+     *
+     * Keyed on whether the dataset brings PIXELS rather than on the extent, because the
+     * extent cannot tell the two apart — 2,000 units is a small slide or a large section
+     * depending only on what the units are, and only the dataset knows.
+     */
+    setRegionGridFor(dataset, positions) {
+        const overlay = this.regionOverlay;
+        if (!overlay?.setWorldQuantum)
+            return;
+        if (dataset.imageRef || dataset.volume) {
+            overlay.setWorldQuantum(PIXEL_WORLD_QUANTUM);
+            return;
+        }
+        let minX = Infinity;
+        let maxX = -Infinity;
+        let minY = Infinity;
+        let maxY = -Infinity;
+        for (let i = 0; i < positions.length; i += 2) {
+            const x = positions[i];
+            const y = positions[i + 1];
+            if (!Number.isFinite(x) || !Number.isFinite(y))
+                continue;
+            if (x < minX)
+                minX = x;
+            if (x > maxX)
+                maxX = x;
+            if (y < minY)
+                minY = y;
+            if (y > maxY)
+                maxY = y;
+        }
+        overlay.setWorldQuantum(worldQuantumForExtent(maxX - minX, maxY - minY));
+    }
+    /**
+     * Frame the 2D camera on the observations, for a dataset that brings no image.
+     *
+     * The 2D camera is normally fitted to the IMAGE, because the observations are in that
+     * image's pixel space and framing the image frames them too. A dataset with no
+     * reference image has coordinates in its own units instead — seqFISH's span about
+     * 5x7 — so the image framing left over from whatever was on screen before puts the
+     * whole cloud offscreen: measured at 9.7 x 13.4 PIXELS, centred 256px from where the
+     * camera was looking. The points are all there and drawn; they are a speck. Which
+     * looks exactly like the dataset having failed to load.
+     *
+     * Once per dataset, as napari-js's `fit3d: 'once'` does for the cloud: re-colouring,
+     * slicing or picking a gene re-adds this layer, and re-framing on those would move
+     * the camera under the user — the camera tools and the canvas drag are meant to be
+     * the only things that do.
+     */
+    /**
+     * Hide the image layer for a dataset that brings no image of its own.
+     *
+     * The host's viewer keeps whatever image was last loaded, and for a dataset that
+     * registers onto none that picture belongs to something else entirely — the example's
+     * default slide, say. It is not merely irrelevant: the two live in different coordinate
+     * spaces (image pixels against the embedding's own units), so the leftover is magnified
+     * roughly a hundredfold. At the fitted zoom the camera sits inside its corner, where it
+     * reads as blank background, and it appears only once you zoom out far enough to find
+     * it — which is exactly how it gets noticed.
+     *
+     * Hidden rather than removed, and hidden HERE rather than by clearing the host's image
+     * state: that state drives the whole render pipeline, including a Plotly backend whose
+     * fields are declared with definite-assignment assertions, so emptying it throws from
+     * whichever field the next path happens to read. This touches one layer's visibility
+     * and nothing else.
+     */
+    hideForeignImage(viewer, datasetHasPixels) {
+        for (const layer of viewer.layers.items) {
+            if (layer.kind !== 'image')
+                continue;
+            // Re-shown when a dataset that owns an image comes back, so switching between
+            // datasets does not leave the tissue permanently hidden.
+            layer.visible = datasetHasPixels;
+        }
+        viewer.requestRender();
+    }
+    frameSpatialPointsOnce(viewer, datasetId, positions, registered) {
+        // Gated on whether THIS dataset registers onto an image, not on `imageW`/`imageH`:
+        // those keep the last plotted image's dimensions after the host clears it, so a
+        // stale 512x383 read as "there is an image" and skipped the framing entirely.
+        if (registered)
+            return;
+        // Once per dataset, as napari-js's `fit3d: 'once'` does for the cloud: re-colouring, slicing
+        // or picking a gene re-adds this layer, and re-framing on those would move the
+        // camera under the user — the camera tools and the canvas drag are meant to be the
+        // only things that do.
+        if (this.spatial2dFramed?.viewer === viewer
+            && this.spatial2dFramed.datasetId === datasetId)
+            return;
+        const fit = framePositions(positions, this.canvas?.clientWidth ?? 0, this.canvas?.clientHeight ?? 0);
+        // Null means there is nothing to frame on; leave the camera where it is rather
+        // than moving the view for a dataset we cannot fit.
+        if (!fit)
+            return;
+        viewer.camera.set(fit.center, fit.zoom ?? viewer.camera.zoom);
+        this.spatial2dFramed = { viewer, datasetId };
+    }
+    /**
+     * The **gene map**: the active gene's expression as a continuous field drawn under
+     * the cells.
+     *
+     * A scatter coloured by a gene says which cells express it; it cannot say where,
+     * because the eye will not integrate thousands of dots into a territory. The field
+     * is a kernel-weighted MEAN per cell (see `spatial-expression.ts`), so a dense
+     * region does not glow merely for being dense, and it is transparent wherever no
+     * cell was measured — an unsampled gap must not read as "not expressed".
+     *
+     * It shares the points' LUT, percentile window and log flag, so the layer under
+     * the cells and the cells themselves cannot disagree about what a colour means.
+     *
+     * Estimated on the DISPLAYED image's pixel grid, coarsened so the long side is at
+     * most {@link GENE_MAP_MAX_SIDE}: a smooth field gains nothing from a slide's full
+     * resolution. For a volume-backed dataset that grid is the current slice, and only
+     * that plane's observations are included — the same rule the markers follow.
+     */
+    async ensureGeneMap(viewer, dataset, view, selection, slab) {
+        const gene = view.geneMap && view.colorBy?.kind === 'feature' ? view.colorBy.name : null;
+        const port = this.spatialData;
+        const smoothing = view.geneMapSmoothing > 0 ? view.geneMapSmoothing : 1;
+        const clip = view.percentileClip ?? [0.01, 0.99];
+        // Two clocks: the FIELD depends on the gene, the plane and the bandwidth, while
+        // the colours depend on the window, the log flag and the opacity. Recolouring a
+        // cached field is a fraction of estimating one.
+        const fieldKey = gene
+            ? [dataset.id, gene, slab?.slice ?? '', smoothing, this.selectionRev(selection)].join('|')
+            : null;
+        const key = fieldKey
+            ? [
+                fieldKey, clip.join(','), view.logScale ? 'log' : 'lin', view.geneMapOpacity,
+                this.continuousColormapKey(view),
+            ].join('|')
+            : null;
+        if (key === this.geneMapKey)
+            return;
+        if (this.geneMapLayer) {
+            viewer.layers.remove(this.geneMapLayer);
+            this.geneMapLayer = null;
+        }
+        // ANY change here changes the order the cells have to sit above — including the
+        // first one, where there is no previous layer to remove — and the layer list is
+        // append-only. So drop the markers unconditionally and let the rebuild below put
+        // them back on top; otherwise the field is appended over the measurement.
+        if (this.spatialPoints) {
+            viewer.layers.remove(this.spatialPoints);
+            this.spatialPoints = null;
+            this.spatialLayerKey = null;
+        }
+        this.geneMapKey = key;
+        if (!key || !gene || !port) {
+            this.geneMapField = null;
+            this.geneMapFieldKey = null;
+            return;
+        }
+        // The raster covers the displayed image; without one there is nothing to
+        // overlay and the cloud is the 3D mode's business, not this one's.
+        const imageW = slab ? dataset.volume.width : this.imageW;
+        const imageH = slab ? dataset.volume.height : this.imageH;
+        if (!imageW || !imageH)
+            return;
+        const step = Math.max(1, Math.ceil(Math.max(imageW, imageH) / NapariVisualizerService.GENE_MAP_MAX_SIDE));
+        if (fieldKey !== this.geneMapFieldKey) {
+            let values;
+            try {
+                values = await port.getFeatureVector(gene);
+            }
+            catch (err) {
+                console.warn(`[napari-js] gene map: "${gene}" unavailable`, err);
+                this.geneMapKey = null;
+                return;
+            }
+            if (this.viewer !== viewer || this.geneMapKey !== key)
+                return;
+            const inSelection = selection.count > 0 ? maskToIndices(selection.mask) : undefined;
+            this.geneMapField = expressionField(dataset.observations, {
+                ref: slab?.ref ?? dataset.imageRef,
+                width: Math.ceil(imageW / step),
+                height: Math.ceil(imageH / step),
+                step,
+                sigma: NapariVisualizerService.GENE_MAP_SIGMA * smoothing,
+                values,
+                // A plane wins over a selection: the 2D view is showing one section, so a
+                // field spanning the specimen's depth would not be the thing on screen.
+                indices: slab?.indices ?? inSelection,
+            });
+            this.geneMapFieldKey = fieldKey;
+        }
+        const field = this.geneMapField;
+        if (!field)
+            return;
+        const node = this.currentColormap;
+        const lut = spatialContinuousLut(node?.data?.value, this.currentReverse, view.continuousColormap);
+        const [lo, hi] = contrastWindow(field.mean, clip[0], clip[1]);
+        const rgba = colorExpressionField(field, lut, [lo, hi], {
+            log: view.logScale,
+            // The MAP's own opacity: reading a field under the cells means turning the
+            // cells down, which must not take the field with them.
+            opacity: view.geneMapOpacity,
+        });
+        this.geneMapLayer = viewer.addImage({ kind: 'typed', width: field.width, height: field.height, channels: 4, dtype: 'uint8', data: rgba }, {
+            name: `gene map · ${gene}`,
+            scale: [step, step],
+            translate: [0, 0],
+            blending: 'translucent',
+        });
+        viewer.requestRender();
+    }
+    /**
+     * The plane a volume-backed dataset is currently showing: its pixel affine, the
+     * observations that fall in it, and the marker floor that grid needs.
+     *
+     * Null for a dataset with a real `imageRef` (its coordinates are already the
+     * image's pixels and every observation belongs to the one section) and for one
+     * with no volume at all — both of which draw exactly as before.
+     */
+    spatialSlab(dataset) {
+        const volume = dataset.volume;
+        if (dataset.imageRef || !volume)
+            return null;
+        const slice = this.loaded?.z ?? 0;
+        return {
+            ref: volumeImageRef(volume, dataset.micronsPerUnit),
+            indices: observationsInSlice(dataset.observations, volume, slice),
+            slice,
+            minDiameter: NapariVisualizerService.SPATIAL_SLICE_MIN_DIAMETER_PX * volume.voxelSize[0],
+        };
+    }
+    /** Per-point colours for the drawn subset. A broadcast tuple stays broadcast —
+     *  it is one colour for every point either way. */
+    gatherColors(colors, indices) {
+        if (!indices || !Array.isArray(colors))
+            return colors;
+        const out = new Array(indices.length);
+        for (let i = 0; i < indices.length; i++)
+            out[i] = colors[indices[i]];
+        return out;
+    }
+    /**
+     * Redraw the observation markers over a freshly rendered image.
+     *
+     * Two reasons, both invisible from the spatial store — which is why a scrub or a
+     * re-render never reached the markers on its own:
+     *  - the image render CLEARS the layer list, taking the markers with it;
+     *  - over a volume-backed dataset the displayed plane decides which
+     *    observations belong on screen at all, so the cells have to move with the
+     *    section rather than hang over a different one.
+     *
+     * Uses the latest values the marker subscription saw; a no-op until it has seen
+     * any, in the 3D cloud (no image, no plane), and with no dataset to draw.
+     */
+    redrawSpatialMarkers() {
+        const latest = this.spatialLatest;
+        if (!latest?.[0] || isSpatialOmics3d(this.currentPlotType))
+            return;
+        void this.rebuildSpatialPoints(...latest);
+    }
+    /**
+     * Mount the SPATIAL_OMICS_3D view: observations as a 3D point cloud under the orbit camera.
+     *
+     * Deliberately much thinner than the 2D mount. There is no tissue image to render (a registered
+     * volume like the Allen CCF has no single reference plane), so no scale bar, no readback, and no
+     * 2D interaction stack — the region tools draw in screen space and have no meaning against an
+     * orbiting camera, which is why `Select from ROIs` is hidden in this mode. `addPoints3D` puts
+     * the viewer in 3D and frames the camera on the cloud itself.
+     */
+    async mountSpatialOmics3d(viewer, host) {
+        this.install3dInteraction(viewer, host);
+        this.installSpatialHover(host);
+        this.subscribeSpatial();
+    }
+    /**
+     * Scale bar for the 3D cloud, measured at the ORBIT PIVOT.
+     *
+     * A perspective camera has no single scale — things farther away are smaller — so a bar can
+     * only be true at one depth. The pivot is the honest choice: it is what the camera is framing,
+     * what a zoom moves towards, and where the eye is anyway. napari's own 3D scale bar works the
+     * same way.
+     *
+     * `NapariScaleBar` needs CSS px per world unit, which an orbit camera does not expose, but at
+     * the pivot it is exactly `viewportHeight / (2 * distance * tan(fov / 2))` — the same
+     * relationship `Camera3D.pan` uses to track the cursor. The bar then converts through
+     * `micronsPerUnit`, and draws nothing at all when the dataset does not declare one, because a
+     * bar labelled in microns over unknown units would read as a measurement.
+     */
+    installSpatial3dScaleBar(viewer, dataset) {
+        this.scaleBar?.destroy();
+        this.scaleBar = null;
+        const micronsPerUnit = dataset?.micronsPerUnit;
+        if (!this.host || !micronsPerUnit || micronsPerUnit <= 0)
+            return;
+        const canvas = this.canvas;
+        const cam = viewer.camera3d;
+        const shim = {
+            get zoom() {
+                const h = canvas?.clientHeight || canvas?.height || 0;
+                const worldPerPx = (2 * cam.distance * Math.tan(cam.fov / 2)) / (h || 1);
+                return worldPerPx > 0 ? 1 / worldPerPx : 0;
+            },
+            changed: cam.changed,
+        };
+        this.scaleBar = new NapariScaleBar(this.host, shim, micronsPerUnit);
+    }
+    /** Base marker diameter for the 3D cloud, in SCREEN pixels (the layer's unit). */
+    static { this.SPATIAL_3D_BASE_SIZE = 3; }
+    /** (Re)build the 3D point cloud for the current dataset + view state. */
+    async rebuildSpatialPoints3d(dataset, view, selection = emptySelection()) {
+        const viewer = this.viewer;
+        if (!viewer)
+            return;
+        const token = ++this.spatialRebuildToken;
+        // Resolve the scalar encoding BEFORE touching the scene, for the same reason
+        // the 2D path does: a gene fetch can fail or be superseded, and dropping the
+        // layer first would blank the view.
+        let enc = null;
+        if (dataset) {
+            try {
+                enc = await this.spatialScalar3d(dataset, view);
+            }
+            catch (err) {
+                console.warn('[napari-js] spatial 3D colouring failed — falling back to a flat colour', err);
+                enc = null;
+            }
+        }
+        if (token !== this.spatialRebuildToken || this.viewer !== viewer)
+            return;
+        const obs = dataset?.observations;
+        // No z means nothing to draw in 3D. The plot type is gated on `requiresSpatial3d`
+        // so this should be unreachable from the UI, but a host can set the type directly.
+        if (!dataset || !obs || obs.count === 0 || !obs.z) {
+            this.removeSpatial3dLayers(viewer);
+            return;
+        }
+        // Anatomy first: on a scene's FIRST layer napari frames the orbit camera, and
+        // the reference volume is the framing we want — the brain, not the outermost
+        // stray segmentation. Every later add keeps the pose instead (napari-js `fit3d: 'once'`).
+        await this.ensureSpatialVolume(viewer, dataset, view);
+        if (token !== this.spatialRebuildToken || this.viewer !== viewer)
+            return;
+        // Then the cluster density volumes, which can set the centring offset when
+        // there is no reference volume — so before any position is computed from it.
+        await this.ensureDensityVolumes(viewer, dataset, view, selection);
+        if (token !== this.spatialRebuildToken || this.viewer !== viewer)
+            return;
+        // Then the gene map, which shares the reference volume's lattice — so it goes
+        // after anything that can still move the centring offset.
+        await this.ensureGeneMapVolume(viewer, dataset, view, selection);
+        if (token !== this.spatialRebuildToken || this.viewer !== viewer)
+            return;
+        // Scale depends on the dataset's declared unit, so it waits for the dataset
+        // rather than being set up at mount time.
+        if (dataset.id !== this.spatialScaleBarKey) {
+            this.spatialScaleBarKey = dataset.id;
+            this.installSpatial3dScaleBar(viewer, dataset);
+        }
+        // The reference volume is hidden, not removed: it also fixes the centring
+        // offset every position is computed from, and re-fetching a 100 MB template
+        // to un-hide it would make a checkbox feel like a load.
+        if (this.spatialVolume) {
+            this.spatialVolume.visible = view.showVolume;
+            this.spatialVolume.opacity = view.volumeOpacity;
+        }
+        const scale = view.pointScale > 0 ? view.pointScale : 1;
+        const size = NapariVisualizerService.SPATIAL_3D_BASE_SIZE * scale;
+        const scalars = enc?.values ?? new Float32Array(obs.count);
+        const colormap = enc?.colormap ?? this.spatialFlatColormap();
+        const contrastLimits = enc?.contrastLimits ?? [0, 1];
+        // One imaged section, or the whole stack. The subset IS the geometry, so it
+        // belongs in the geometry key rather than being re-derived per frame — and an
+        // out-of-range index is clamped rather than dropping the cloud, because the
+        // section count changes with the dataset while the view state persists.
+        const sections = sectionsOf(obs);
+        const section = view.pointSection != null && sections && sections.length > 0
+            ? sections[Math.max(0, Math.min(sections.length - 1, view.pointSection))]
+            : null;
+        const shown = section != null ? observationsInSection(obs, section) : null;
+        const shownCount = shown ? shown.length : obs.count;
+        const key = `${dataset.id}:${obs.count}:${section ?? 'all'}`;
+        // `Points3DLayer.values` is readonly and the layer exposes no dataVersion to
+        // bump, so unlike the 2D path a change of colour SOURCE cannot be mutated in
+        // — the layer has to be rebuilt. Only the size/opacity/colormap knobs are
+        // genuinely display-only. So track the scalars' identity separately from the
+        // geometry's: `colorBy` plus the transforms feeding the encoding.
+        const clip = view.percentileClip ?? [0.01, 0.99];
+        const scalarKey = [
+            key,
+            view.colorBy ? `${view.colorBy.kind}:${view.colorBy.name}` : 'flat',
+            view.logScale ? 'log' : 'lin',
+            clip.join(','),
+        ].join('|');
+        if (key !== this.spatialLayerKey3d) {
+            // New geometry: interleave x,y,z (the layer's documented layout, x-fastest)
+            // and cache it, so later colour changes rebuild the layer without walking
+            // the observations again.
+            const [ox, oy, oz] = this.spatialOrigin3d;
+            const positions = new Float32Array(shownCount * 3);
+            for (let k = 0; k < shownCount; k++) {
+                const i = shown ? shown[k] : k;
+                positions[k * 3] = obs.x[i] + ox;
+                positions[k * 3 + 1] = obs.y[i] + oy;
+                positions[k * 3 + 2] = obs.z[i] + oz;
+            }
+            this.spatialPositions3d = positions;
+            this.spatialDrawn3d = shown;
+        }
+        // The scalars have to follow the geometry: a per-observation vector against one
+        // section's positions would colour each cell by a stranger's value.
+        const valuesFor = () => (shown ? Float32Array.from(shown, (i) => scalars[i]) : scalars);
+        if (!this.spatialPoints3d || key !== this.spatialLayerKey3d) {
+            // New GEOMETRY — a different dataset, or a different section — so a new layer.
+            if (this.spatialPoints3d)
+                viewer.layers.remove(this.spatialPoints3d);
+            this.spatialLayerKey3d = key;
+            this.spatialScalarKey3d = scalarKey;
+            this.spatialPoints3d = viewer.addPoints3D(this.spatialPositions3d, valuesFor(), {
+                name: 'observations',
+                colormap,
+                contrastLimits,
+                size,
+            });
+        }
+        else {
+            if (scalarKey !== this.spatialScalarKey3d) {
+                // A change of colour SOURCE, which used to mean discarding the layer and building
+                // another — and, because adding a 3D layer reframes, a camera jump to undo as well.
+                // napari-js ≥ 0.14 lets the scalars be replaced in place — the setter bumps the
+                // layer's dataVersion so the visual re-uploads — and the positions have not moved,
+                // so there is nothing for the camera to reframe.
+                this.spatialScalarKey3d = scalarKey;
+                this.spatialPoints3d.values = valuesFor();
+            }
+            this.spatialPoints3d.colormap = colormap;
+            this.spatialPoints3d.contrastLimits = contrastLimits;
+            this.spatialPoints3d.size = size;
+        }
+        // Selection is a PER-POINT alpha, in the one layer.
+        //
+        // It used to be a second layer: with a single opacity for the whole cloud, the only way
+        // to highlight a subset was to draw it again on top at full opacity while the parent
+        // dropped to the muted level. That second layer had to be kept in step through every
+        // colormap, window and size change, and the two then depth-sorted against each other as
+        // separate draws. Per-point alphas and sizes give the same reading — muted cloud, bright
+        // selection, slightly larger so a small one is findable inside 3.7M points — in one.
+        const hasSelection = selection.count > 0 && selection.mask.length === obs.count;
+        const cloud = this.spatialPoints3d;
+        if (cloud) {
+            cloud.opacity = view.opacity;
+            if (!hasSelection) {
+                cloud.alphas = null;
+                cloud.sizes = null;
+            }
+            else {
+                const alphas = new Float32Array(shownCount);
+                const sizes = new Float32Array(shownCount);
+                for (let k = 0; k < shownCount; k++) {
+                    const i = shown ? shown[k] : k;
+                    const picked = !!selection.mask[i];
+                    alphas[k] = picked ? 1 : DEFAULT_MUTED_OPACITY;
+                    sizes[k] = picked ? NapariVisualizerService.SPATIAL_SELECTED_SIZE_SCALE : 1;
+                }
+                cloud.alphas = alphas;
+                cloud.sizes = sizes;
+            }
+        }
+        // Last, so it also covers a layer this pass just created.
+        if (this.spatialPoints3d)
+            this.spatialPoints3d.visible = view.showPoints;
+        viewer.requestRender();
+    }
+    /**
+     * The **3D gene map**: the active gene's expression over the whole sectioned
+     * specimen, as one raymarched volume.
+     *
+     * Two things it can be, and the panel's `Volume rendering` toggle picks which:
+     *
+     *  - **sheets** — exactly the planes that were imaged, each carrying that
+     *    slide's own 2D gene map, with the gaps between sections empty. A stack of
+     *    measured fields, at their true z.
+     *  - **volume** — the same fields smoothed along z, so the planes between the
+     *    sections carry an interpolated value. An estimate, and drawn as a
+     *    translucent cloud for the same reason the density volumes are.
+     *
+     * One `VolumeLayer` rather than a textured quad per section: an `ImageLayer`
+     * renders only at `ndisplay === 2`, so 53 sheets in the orbit view would need a
+     * new layer type upstream — while a scalar volume whose z sampling already IS
+     * the section spacing expresses the sheets exactly, and the same lattice then
+     * gives the interpolated version for free.
+     *
+     * Estimated on the reference volume's own lattice (`densityGrid` at stride 1),
+     * so the field lands voxel-for-voxel on the anatomy and needs no offset — a
+     * `VolumeLayer` has no translate, and napari centres both boxes on the world
+     * origin.
+     */
+    async ensureGeneMapVolume(viewer, dataset, view, selection) {
+        const gene = view.geneMap && view.colorBy?.kind === 'feature' ? view.colorBy.name : null;
+        const port = this.spatialData;
+        const smoothing = view.geneMapSmoothing > 0 ? view.geneMapSmoothing : 1;
+        const clip = view.percentileClip ?? [0.01, 0.99];
+        const obs = dataset.observations;
+        // A volume built from ONE section would smear that slide through the whole
+        // depth, so the section restriction only applies to the sheets.
+        const interpolate = !!view.geneMapVolume;
+        const sections = sectionsOf(obs);
+        const section = !interpolate && view.geneMapSection != null && sections && sections.length > 0
+            ? sections[Math.max(0, Math.min(sections.length - 1, view.geneMapSection))]
+            : null;
+        const fieldKey = gene
+            ? [
+                dataset.id, gene, smoothing, section ?? 'all', interpolate ? 'vol' : 'sheets',
+                this.selectionRev(selection),
+            ].join('|')
+            : null;
+        const key = fieldKey
+            ? [
+                fieldKey, clip.join(','), view.logScale ? 'log' : 'lin', view.geneMapOpacity,
+                this.continuousColormapKey(view),
+            ].join('|')
+            : null;
+        if (key === this.geneMapVolumeKey)
+            return;
+        if (this.geneMapVolumeLayer) {
+            viewer.layers.remove(this.geneMapVolumeLayer);
+            this.geneMapVolumeLayer = null;
+        }
+        this.geneMapVolumeKey = key;
+        if (!key || !gene || !port) {
+            this.geneMapVolumeField = null;
+            this.geneMapVolumeFieldKey = null;
+            return;
+        }
+        // Coarsened in-plane but NOT along z: the sheets need one plane per imaged
+        // section, while the field they carry is smooth by construction and gains
+        // nothing from the template's 40 µm detail. At full resolution the estimate is
+        // a 5.7M-voxel pair of blurs on the main thread — seconds of frozen UI for a
+        // checkbox; an eighth of the voxels is an eighth of the work.
+        const grid = densityGrid(dataset, GENE_MAP_VOLUME_STRIDE, 128, 1);
+        if (!grid)
+            return;
+        if (fieldKey !== this.geneMapVolumeFieldKey) {
+            let values;
+            try {
+                values = await port.getFeatureVector(gene);
+            }
+            catch (err) {
+                console.warn(`[napari-js] 3D gene map: "${gene}" unavailable`, err);
+                this.geneMapVolumeKey = null;
+                return;
+            }
+            if (this.viewer !== viewer || this.geneMapVolumeKey !== key)
+                return;
+            const inSelection = selection.count > 0 ? maskToIndices(selection.mask) : undefined;
+            // In-plane bandwidth is the 2D map's, in this lattice's units, so a sheet
+            // and the 2D view of the same section are the same field. Along z it is the
+            // density path's 1.5 voxels — the smallest σ that bridges one section gap.
+            // In-plane σ is a PHYSICAL bandwidth, anchored to the reference volume's own
+            // voxel — the resolution the 2D map estimates at — so a sheet and the 2D
+            // view of the same section are the same field whatever lattice this is
+            // rasterised on. Along z it is the density path's 1.5 voxels: the smallest σ
+            // that bridges one section gap.
+            const inPlane = dataset.volume?.voxelSize ?? grid.voxelSize;
+            this.geneMapVolumeField = expressionVolume(obs, grid, {
+                sigma: [
+                    inPlane[0] * NapariVisualizerService.GENE_MAP_SIGMA * smoothing,
+                    inPlane[1] * NapariVisualizerService.GENE_MAP_SIGMA * smoothing,
+                    grid.voxelSize[2] * 1.5 * smoothing,
+                ],
+                values,
+                indices: section != null ? observationsInSection(obs, section) : inSelection,
+                interpolate,
+            });
+            this.geneMapVolumeFieldKey = fieldKey;
+        }
+        const field = this.geneMapVolumeField;
+        if (!field)
+            return;
+        const [lo, hi] = contrastWindow(field.mean, clip[0], clip[1]);
+        const data = encodeExpressionVolume(field, [lo, hi], { log: view.logScale });
+        const node = this.currentColormap;
+        const lut = spatialContinuousLut(node?.data?.value, this.currentReverse, view.continuousColormap);
+        this.geneMapVolumeLayer = viewer.addVolume(data, field.width, field.height, field.depth, {
+            name: `gene map · ${gene}${interpolate ? ' · volume' : ''}`,
+            colormap: colormapFromLut(`gene-map-${gene}`, lut),
+            // The encoding already applied the window, so the layer must not apply a
+            // second one: 0..255 is the whole of what it was given.
+            contrastLimits: [0, 255],
+            rendering: 'translucent',
+            // Additive like the density volumes, and for the same reason: the sheets
+            // have to read THROUGH each other and through the anatomy, which a
+            // translucent blend would occlude one sheet at a time.
+            blending: 'additive',
+            opacity: view.geneMapOpacity,
+            voxelSize: grid.voxelSize,
+        });
+        viewer.requestRender();
+    }
+    /**
+     * Cluster density volumes: each cluster rasterised into a smooth scalar field and
+     * raymarched alongside the cloud, tinted with the cluster's own legend colour.
+     *
+     * This is what makes a serially sectioned dataset readable as an anatomical
+     * distribution. The cloud shows measured cells and nothing else — but at 200 µm
+     * section spacing the eye cannot integrate a stack of discs into a shape, and
+     * every gap reads as absence. A density field is a different object from a cell:
+     * an estimate, defined between the imaged planes, drawn as a translucent cloud so
+     * it cannot be mistaken for measurement. Individual cells are never interpolated —
+     * consecutive sections sample different cells, so there is nothing to interpolate
+     * along.
+     *
+     * One volume per cluster rather than one for everything: additive blending is what
+     * makes two clusters' territories comparable, and a single blended field would
+     * answer no question anyone asks of a taxonomy. Capped at
+     * {@link DENSITY_MAX_CLUSTERS} by cell count.
+     *
+     * Keyed so it rebuilds only when the field would actually differ — the dataset,
+     * the colour column, the bandwidth, or the selection.
+     */
+    async ensureDensityVolumes(viewer, dataset, view, selection) {
+        const on = !!view.densityVolume && !!dataset.observations.z;
+        const smoothing = view.densitySmoothing > 0 ? view.densitySmoothing : 1;
+        const column = view.colorBy?.kind === 'column' ? view.colorBy.name : null;
+        // The selection enters the key by IDENTITY, not by count: two different ROIs
+        // holding the same number of cells would otherwise look like the same key and
+        // leave the previous ROI's fields on screen.
+        const key = on
+            ? [dataset.id, column ?? 'all', smoothing, this.selectionRev(selection)].join('|')
+            : null;
+        if (key === this.densityKey)
+            return;
+        for (const layer of this.densityLayers)
+            viewer.layers.remove(layer);
+        this.densityLayers = [];
+        this.densityKey = key;
+        if (!key)
+            return;
+        const grid = densityGrid(dataset);
+        if (!grid)
+            return;
+        // With no reference volume there is no offset yet, and a VolumeLayer has no
+        // translate — napari centres its box on the world origin. So the POINTS move by
+        // half the density box, exactly as they do for a reference volume, and the
+        // cached geometry is invalidated because that offset just changed.
+        if (!this.spatialVolume) {
+            this.spatialOrigin3d = [
+                -(grid.width * grid.voxelSize[0]) / 2,
+                -(grid.height * grid.voxelSize[1]) / 2,
+                -(grid.depth * grid.voxelSize[2]) / 2,
+            ];
+            this.spatialLayerKey3d = null;
+        }
+        let groups;
+        try {
+            groups = await this.densityGroups(dataset, column, selection);
+        }
+        catch (err) {
+            console.warn('[napari-js] density volumes: column unavailable', err);
+            this.densityKey = null;
+            return;
+        }
+        if (this.viewer !== viewer || this.densityKey !== key)
+            return;
+        const sigma = defaultSigma(grid, smoothing);
+        // Additive blending SUMS, so a fixed per-layer opacity blows out to white as
+        // soon as several broad clusters overlap — six subclasses at 0.55 each turned
+        // the brain into one cyan mass. Splitting the budget keeps n fully overlapping
+        // peaks inside the display's range, so overlap reads as overlap; a single
+        // cluster still gets the full 0.55. It only mitigates: a translucent raymarch
+        // integrates along the ray, so clusters that are ubiquitous rather than
+        // regional (the largest subclasses are glia, which are everywhere) still pile
+        // up, and one cluster at a time is the readable way to look at those.
+        const opacity = Math.min(0.55, 0.9 / Math.max(1, groups.length));
+        for (const group of groups) {
+            const data = rasterizeDensity(dataset.observations, grid, { sigma, indices: group.indices });
+            // A cluster with nothing on the grid draws no layer, rather than an empty box.
+            if (!data)
+                continue;
+            if (this.viewer !== viewer || this.densityKey !== key)
+                return;
+            this.densityLayers.push((viewer.addVolume(data, grid.width, grid.height, grid.depth, {
+                name: `density · ${group.name}`,
+                colormap: this.channelTintColormap(group.color),
+                // Translucent, not MIP: a cluster's interior is the readable part, and MIP
+                // would flatten every cloud to its brightest shell.
+                rendering: 'translucent',
+                opacity,
+                // Additive, so two clusters overlapping read as both being there instead
+                // of the nearer one hiding the other.
+                blending: 'additive',
+                voxelSize: grid.voxelSize,
+            })));
+        }
+        viewer.requestRender();
+    }
+    /**
+     * Identity of the colour scale a continuous spatial layer will draw with, for a
+     * cache key: the explicit choice, or else the display colormap and its reverse
+     * flag, since that is what {@link spatialContinuousLut} falls back to.
+     *
+     * The gene maps cache their coloured output, so without this in the key a change
+     * of colour scale left the field on screen in the previous colours — the markers
+     * recoloured and the map under them did not.
+     */
+    continuousColormapKey(view) {
+        const node = this.currentColormap;
+        return [
+            colormapId(view.continuousColormap),
+            colormapId(node?.data?.value),
+            this.currentReverse ? 'rev' : '',
+        ].join(':');
+    }
+    /**
+     * A revision number for a selection object.
+     *
+     * The store hands out a NEW mask object per change, so object identity is the
+     * cheap and exact way to tell two selections apart — a fingerprint over 3.7M
+     * mask bytes would be neither. Counting revisions keeps the cache key a short
+     * string.
+     */
+    selectionRev(selection) {
+        if (selection !== this.lastSelectionSeen) {
+            this.lastSelectionSeen = selection;
+            this.selectionRevision++;
+        }
+        return this.selectionRevision;
+    }
+    /**
+     * The clusters to rasterise: the categories of the active categorical colouring,
+     * biggest first and capped, each with its legend colour.
+     *
+     * Restricted to the current selection when there is one, so "select a region,
+     * check the box" answers which clusters live there. With no categorical colouring
+     * there is one group — total cell density, which is a real question on its own
+     * ("where is the tissue dense?") and the honest thing to show when the view is
+     * not encoding a taxonomy.
+     */
+    async densityGroups(dataset, column, selection) {
+        const n = dataset.observations.count;
+        const inSelection = selection.count > 0 ? selection.mask : null;
+        const port = this.spatialData;
+        const meta = column ? findColumnMeta(dataset, column) : undefined;
+        if (!port || !column || !meta || meta.kind !== 'categorical') {
+            const indices = inSelection ? maskToIndices(inSelection) : undefined;
+            const [r, g, b] = NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;
+            const hex = `#${[r, g, b].map((c) => Math.round(c * 255).toString(16).padStart(2, '0')).join('')}`;
+            return [{ name: inSelection ? 'selected cells' : 'all cells', color: hex, indices }];
+        }
+        const loaded = await port.getColumn(column);
+        if (!isCategoricalColumn(loaded))
+            return [];
+        const colors = resolveCategoryColors(loaded.meta);
+        const counts = new Uint32Array(loaded.meta.categories.length);
+        for (let i = 0; i < n; i++) {
+            if (inSelection && !inSelection[i])
+                continue;
+            const code = loaded.codes[i];
+            if (code !== NO_CATEGORY && code < counts.length)
+                counts[code]++;
+        }
+        const ranked = Array.from(counts, (count, code) => ({ code, count }))
+            .filter((c) => c.count > 0)
+            .sort((a, b) => b.count - a.count)
+            .slice(0, NapariVisualizerService.DENSITY_MAX_CLUSTERS);
+        if (counts.filter((c) => c > 0).length > ranked.length) {
+            console.info(`[napari-js] ${column}: drawing the ${ranked.length} largest clusters as density ` +
+                'volumes; more than that stop being separable by eye');
+        }
+        return ranked.map(({ code }) => {
+            const indices = new Uint32Array(counts[code]);
+            let k = 0;
+            for (let i = 0; i < n; i++) {
+                if (inSelection && !inSelection[i])
+                    continue;
+                if (loaded.codes[i] === code)
+                    indices[k++] = i;
+            }
+            return {
+                name: loaded.meta.categories[code],
+                color: colors[code] ?? '#888888',
+                indices: indices.subarray(0, k),
+            };
+        });
+    }
+    /**
+     * Add (or keep) the dataset's reference volume, and derive the offset that sits the
+     * observations inside it.
+     *
+     * `VolumeLayer` has no translate: napari-js maps the volume's unit cube to a world box
+     * **centred on the origin**, sized `dims x voxelSize`. The observations, by contract, are in
+     * the volume's own frame with its near corner at the coordinate origin. So the two only line
+     * up if the POINTS move — by half the box — which is what {@link spatialOrigin3d} is.
+     *
+     * A failed or absent volume is not fatal: the cloud renders on its own, at its own
+     * coordinates, and the camera frames the points instead.
+     */
+    async ensureSpatialVolume(viewer, dataset, view) {
+        const meta = dataset.volume;
+        const port = this.spatialData;
+        const key = meta ? `${dataset.id}:${meta.width}x${meta.height}x${meta.depth}` : null;
+        if (key && key === this.spatialVolumeKey)
+            return;
+        if (this.spatialVolume) {
+            viewer.layers.remove(this.spatialVolume);
+            this.spatialVolume = null;
+            this.spatialVolumeKey = null;
+        }
+        this.spatialOrigin3d = [0, 0, 0];
+        if (!meta || !port?.getVolume)
+            return;
+        let voxels;
+        try {
+            voxels = await port.getVolume();
+        }
+        catch (err) {
+            console.warn('[napari-js] reference volume unavailable — drawing the cloud alone', err);
+            return;
+        }
+        if (this.viewer !== viewer)
+            return;
+        const [vx, vy, vz] = meta.voxelSize;
+        this.spatialVolumeKey = key;
+        this.spatialVolume = (viewer.addVolume(voxels, meta.width, meta.height, meta.depth, {
+            name: 'reference volume',
+            colormap: 'gray',
+            // MIP would draw the brightest voxel along each ray, which for an averaged
+            // template means a flat white shell that hides the cloud. Translucent lets
+            // the points read through the tissue, which is the entire point of drawing
+            // them together.
+            rendering: 'translucent',
+            opacity: view.volumeOpacity,
+            voxelSize: [vx, vy, vz],
+        }));
+        // Half the box, negated: the observations' origin is the box's near corner,
+        // and the box is centred on the world origin.
+        this.spatialOrigin3d = [
+            -(meta.width * vx) / 2,
+            -(meta.height * vy) / 2,
+            -(meta.depth * vz) / 2,
+        ];
+        // Force a geometry rebuild: the offset changed, so cached positions are stale.
+        this.spatialLayerKey3d = null;
+    }
+    removeSpatial3dLayers(viewer) {
+        for (const layer of [
+            this.spatialPoints3d, this.spatialVolume,
+            this.geneMapVolumeLayer, ...this.densityLayers,
+        ]) {
+            if (layer)
+                viewer.layers.remove(layer);
+        }
+        this.geneMapVolumeLayer = null;
+        this.geneMapVolumeKey = null;
+        this.geneMapVolumeField = null;
+        this.geneMapVolumeFieldKey = null;
+        this.densityLayers = [];
+        this.densityKey = null;
+        // The scene is gone, so the next 3D layer should frame itself again. That used to be
+        // `spatialFramed = null` next to a hand-rolled save/restore; the renderer owns the
+        // policy now, and this is the same statement addressed to it.
+        viewer.resetFit3D();
+        this.spatial2dFramed = null;
+        this.spatialVolume = null;
+        this.spatialVolumeKey = null;
+        this.spatialOrigin3d = [0, 0, 0];
+        this.spatialPoints3d = null;
+        this.spatialLayerKey3d = null;
+        this.spatialScalarKey3d = null;
+        this.spatialPositions3d = null;
+        this.spatialDrawn3d = null;
+    }
+    /** A one-colour colormap, for the "nothing to colour by" state. */
+    spatialFlatColormap() {
+        const [r, g, b] = NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;
+        const rgb = [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+        // Two identical stops: colormapFromLut needs at least two, and equal ends
+        // make every value resolve to the same colour.
+        return colormapFromLut('spatial-flat', [rgb, rgb]);
+    }
+    /**
+     * The per-point scalar + colormap + window that colour the 3D cloud.
+     *
+     * Continuous data is the natural fit: values go straight through the active colormap with the
+     * same percentile window the 2D path uses. Categorical data has to be smuggled through the same
+     * scalar channel — see {@link SPATIAL_3D_MAX_CATEGORIES}. Codes map to LUT blocks, and
+     * `contrastLimits` of `[-0.5, K - 0.5]` puts code `i` at the centre of block `i`, which is what
+     * makes the round-trip exact instead of approximately right.
+     */
+    async spatialScalar3d(dataset, view) {
+        const port = this.spatialData;
+        const colorBy = view.colorBy;
+        if (!port || !colorBy)
+            return null;
+        if (colorBy.kind === 'column') {
+            const column = await port.getColumn(colorBy.name);
+            if (isCategoricalColumn(column)) {
+                return this.encodeSpatial3dCategorical(column.codes, resolveCategoryColors(column.meta));
+            }
+            return this.encodeSpatial3dContinuous(column.values, view, view.logScale);
+        }
+        const values = await port.getFeatureVector(colorBy.name);
+        return this.encodeSpatial3dContinuous(values, view, view.logScale);
+    }
+    /** Category codes → a stepped LUT, exact for up to {@link SPATIAL_3D_MAX_CATEGORIES}. */
+    encodeSpatial3dCategorical(codes, colors) {
+        // Slot 0 is reserved for "no category", so the palette occupies 1..K and the
+        // block count is one more than the category count — which is why the published
+        // ceiling is 95 categories rather than the LUT's 96 distinguishable blocks.
+        if (colors.length > SPATIAL_3D_MAX_CATEGORIES) {
+            console.warn(`[napari-js] ${colors.length} categories exceeds the ${SPATIAL_3D_MAX_CATEGORIES} the 3D `
+                + "layer's 256-entry LUT can hold distinctly; drawing flat instead of with wrong colours");
+            return null;
+        }
+        const k = colors.length + 1;
+        const palette = [
+            MISSING_COLOR,
+            ...colors.map(parseHex),
+        ];
+        const lut = new Array(LUT_SIZE);
+        for (let j = 0; j < LUT_SIZE; j++) {
+            lut[j] = palette[Math.min(k - 1, Math.floor((j * k) / LUT_SIZE))];
+        }
+        const values = new Float32Array(codes.length);
+        for (let i = 0; i < codes.length; i++) {
+            values[i] = codes[i] === NO_CATEGORY ? 0 : codes[i] + 1;
+        }
+        return {
+            values,
+            colormap: colormapFromLut('spatial-categories', lut),
+            contrastLimits: [-0.5, k - 0.5],
+        };
+    }
+    /** Continuous values → the active colormap over a percentile-clipped window. */
+    encodeSpatial3dContinuous(source, view, log) {
+        const node = this.currentColormap;
+        const lut = spatialContinuousLut(node?.data?.value, this.currentReverse, view.continuousColormap);
+        const [lo, hi] = view.percentileClip ?? [0.01, 0.99];
+        let values = source;
+        if (log) {
+            values = new Float32Array(source.length);
+            for (let i = 0; i < source.length; i++)
+                values[i] = Math.log1p(Math.max(0, source[i]));
+        }
+        const [min, max] = contrastWindow(values, lo, hi);
+        return {
+            values,
+            colormap: colormapFromLut('spatial-continuous', lut),
+            // A degenerate window would divide by zero in the shader's normalisation.
+            contrastLimits: max > min ? [min, max] : [min, min + 1],
+        };
+    }
+    /**
+     * Per-observation colours for the current view state, or a single flat colour when nothing is
+     * selected to colour by. Categorical columns use the column's own palette; continuous columns
+     * and gene vectors go through the active colormap with a percentile-clipped window.
+     */
+    async spatialFaceColors(dataset, view, selection) {
+        const port = this.spatialData;
+        const colorBy = view.colorBy;
+        // Everything NOT selected is muted; with nothing selected, nothing is muted
+        // and the whole tissue reads normally (the CosMx highlight-vs-mute rule).
+        const muted = mutedFromSelection(selection);
+        if (!port || !colorBy) {
+            const [r, g, b] = NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;
+            // Genuinely uniform: one broadcast tuple, so a flat 84k-observation view
+            // does not allocate 84k of them.
+            if (!muted && view.opacity >= 1)
+                return NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;
+            // Not uniform — the opacity control or a selection varies the alpha, so it
+            // has to be per-point. Returning the constant tuple here is what made the
+            // Opacity slider do nothing in the default state, which is the state anyone
+            // lands in before picking a colour source.
+            const hex = `#${[r, g, b].map((c) => Math.round(c * 255).toString(16).padStart(2, '0')).join('')}`;
+            return toRgbaTuples(encodeCategorical(new Uint16Array(dataset.observations.count), {
+                colors: [hex],
+                opacity: view.opacity,
+                muted,
+            }));
+        }
+        if (colorBy.kind === 'column') {
+            const column = await port.getColumn(colorBy.name);
+            if (isCategoricalColumn(column)) {
+                return toRgbaTuples(encodeCategorical(column.codes, {
+                    colors: resolveCategoryColors(column.meta),
+                    opacity: view.opacity,
+                    muted,
+                }));
+            }
+            // A continuous column may carry its own log hint (counts); the view's
+            // toggle wins once the user has set it.
+            return toRgbaTuples(this.encodeSpatialContinuous(column.values, view, view.logScale, muted));
+        }
+        const values = await port.getFeatureVector(colorBy.name);
+        return toRgbaTuples(this.encodeSpatialContinuous(values, view, view.logScale, muted));
+    }
+    /** Continuous values → RGBA through the active colormap and a clipped window. */
+    encodeSpatialContinuous(values, view, log, muted = null) {
+        const node = this.currentColormap;
+        const lut = spatialContinuousLut(node?.data?.value, this.currentReverse, view.continuousColormap);
+        const [lo, hi] = view.percentileClip ?? [0.01, 0.99];
+        const [min, max] = contrastWindow(values, lo, hi);
+        return encodeContinuous(values, { lut, min, max, log, opacity: view.opacity, muted });
+    }
     /**
      * Mount the NAPARI_SCATTER3D 3D scatter: the downsampled voxel grid as a 3D point cloud colored
      * by intensity (napari-js analog of Plotly's voxel scatter3d). Assembles a coarse volume, then
@@ -1668,6 +3514,25 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
         this.surfaceWindow = null;
         this.scatterRegionSub?.unsubscribe();
         this.scatterRegionSub = null;
+        this.spatialSub?.unsubscribe();
+        this.spatialSub = null;
+        this.removeSpatialHover();
+        this.hoverSource = null;
+        this.hoverSourceKey = null;
+        this.spatialPoints = null;
+        this.spatialLayerKey = null;
+        this.spatialPoints3d = null;
+        this.spatialLayerKey3d = null;
+        this.spatialScalarKey3d = null;
+        this.spatialVolume = null;
+        this.spatialVolumeKey = null;
+        this.spatialOrigin3d = [0, 0, 0];
+        this.spatialScaleBarKey = null;
+        // Drop the cached interleaved coordinates too: holding 3.7M x 3 floats after
+        // a teardown is ~45MB of retained heap for a scene that no longer exists.
+        this.spatialPositions3d = null;
+        // Invalidate any colour fetch still in flight so it can't attach to the next scene.
+        this.spatialRebuildToken++;
         this.scatter2dPoints = null;
         this.scatter3dLayer = null;
         this.axesLayer = null;
@@ -1733,6 +3598,7 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
             v.dims.z = zIndex;
             if (this.descriptor)
                 void this.refreshHistogramSamples(zIndex, this.descriptor);
+            this.redrawSpatialMarkers();
             this.scheduleReadback();
             return;
         }
@@ -1742,8 +3608,14 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
         const req = ++this.sliceReq;
         void this.renderImage(zIndex, req)
             .then(() => {
-            if (req === this.sliceReq)
-                this.scheduleReadback();
+            if (req !== this.sliceReq)
+                return;
+            // AFTER the image, never before: the render clears the layer list, so
+            // markers drawn first are wiped by the very image meant to sit under them.
+            // Over a volume-backed dataset the plane also decides which observations
+            // are drawn at all, so this is what moves the cells with the section.
+            this.redrawSpatialMarkers();
+            this.scheduleReadback();
         })
             .catch((err) => console.error('[napari-js] setZIndex slice failed:', err));
     }
@@ -1829,6 +3701,8 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
             PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_SCATTER3D],
             PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_VOLUME],
             PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_ISOSURFACE],
+            // Gated by `requiresSpatialData`, so the selector hides it until a dataset is published.
+            PLOT_TYPE_DESCRIPTORS[PlotType.SPATIAL_OMICS],
         ];
     }
     /** The napari 3D decimate factor (1 = full … 8 = ⅛). Read by the toolbar to init the control. */
@@ -2293,7 +4167,7 @@ export class NapariVisualizerService extends BaseStoreVisualizer {
     unsubscribe() {
         this.reset();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: NapariVisualizerService, deps: [{ token: TILE_ACCESS_PORT }, { token: i1.VisualizerStore }, { token: i2.RegionStore }, { token: i3.WandToolService }, { token: i4.BrushToolService }, { token: i5.VertexEraserToolService }, { token: i6.ZoomToBoxToolService }, { token: i7.SamToolService }, { token: i8.SamPointToolService }, { token: i9.CellSegmentToolService }, { token: CELL_SEGMENTER, optional: true }, { token: i10.SimpleSliceAccessService }, { token: VIZ_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: NapariVisualizerService, deps: [{ token: TILE_ACCESS_PORT }, { token: i1.VisualizerStore }, { token: i2.RegionStore }, { token: i3.WandToolService }, { token: i4.BrushToolService }, { token: i5.VertexEraserToolService }, { token: i6.ZoomToBoxToolService }, { token: i7.SamToolService }, { token: i8.SamPointToolService }, { token: i9.CellSegmentToolService }, { token: CELL_SEGMENTER, optional: true }, { token: i10.SimpleSliceAccessService }, { token: VIZ_CONFIG }, { token: SPATIAL_DATA_PORT, optional: true }, { token: i11.SpatialSelectionStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: NapariVisualizerService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: NapariVisualizerService, decorators: [{
@@ -2310,5 +4184,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
                 }] }, { type: i10.SimpleSliceAccessService }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [VIZ_CONFIG]
-                }] }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-visualizer.service.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-visualizer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { Observable, BehaviorSubject, Subject, Subscription, combineLatest, from, of } from 'rxjs';\nimport { Image } from 'image-js';\nimport { saveAs } from 'file-saver';\nimport {\n  Viewer,\n  histogramScalar,\n  colormapFromLut,\n  tintColormap,\n  reverseColormap,\n  heightField,\n  MultiChannelImageView,\n  MultiChannelVolumeView,\n} from 'napari-js';\nimport type {\n  AxesLayer,\n  SurfaceLayer,\n  PointsLayer,\n  Points3DLayer,\n  TiledSource,\n  TileKey,\n  PixelChunk,\n  ChannelView,\n  VolumeChannel,\n  Colormap,\n} from 'napari-js';\n\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { IChannelState } from '../../contracts/channel-histogram-api.contract';\nimport { buildColormapLut, Rgb } from '../../contracts/colormap-lut';\nimport {\n  PlotType,\n  PlotTypeDescriptor,\n  PLOT_TYPE_DESCRIPTORS,\n  isNapari3d,\n  isNapariIsosurface,\n  isNapariSurface,\n  isNapariScatter,\n  isNapariScatter3d,\n  NAPARI_DEFAULT_DECIMATE,\n} from '../../contracts/plot-type';\nimport {\n  IVisualizer,\n  PixelData,\n  IntensityProfile,\n  IIsosurfaceControls,\n  IIntensityControls,\n  ISurface3dControls,\n} from '../../contracts/visualizer.contract';\nimport {\n  ViewerCapabilities,\n  ViewerFeature,\n  capabilitiesOf,\n} from '../../contracts/capabilities.contract';\nimport { IRegionOverlay } from '../../contracts/region-overlay.contract';\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { ColormapNode, IWandOptions, IBrushOptions } from '../../contracts/display-types';\nimport { VIZ_CONFIG, VizConfig } from '../../contracts/viz-config';\nimport { TILE_ACCESS_PORT, TileAccessPort } from '../../contracts/ports/tile-access.port';\nimport { BaseStoreVisualizer } from '../base-store-visualizer';\nimport { SimpleSliceAccessService } from '../simple-slice-access.service';\nimport { VisualizerStore } from '../../store/visualizer-store.service';\nimport { RegionStore } from '../../store/region-store.service';\nimport { NapariScaleBar, formatUm } from './napari-scale-bar';\nimport { NapariRegionOverlay } from './napari-region-overlay';\nimport { NapariAxesLabels, AxisLabelSpec } from './napari-axes-labels';\nimport { NapariVolumeZHandle } from './napari-volume-z-handle';\nimport {\n  ICoordinateTransform,\n} from '../../contracts/coordinate-transform.contract';\nimport { WandToolService, WandToolHost, CachedImageData } from '../../toolbar/wand/wand-tool.service';\nimport { WandOptions } from '../../toolbar/wand/wand.service';\nimport { BrushToolService, BrushOptions } from '../../toolbar/brush/brush-tool.service';\nimport {\n  VertexEraserToolService,\n  VertexEraserToolHost,\n} from '../../toolbar/vertex-eraser/vertex-eraser-tool.service';\nimport {\n  ZoomToBoxToolService,\n  ZoomToBoxToolHost,\n} from '../../toolbar/zoom-to-box/zoom-to-box-tool.service';\nimport { SamToolService } from '../../toolbar/segmentation/sam-tool.service';\nimport { SamPointToolService } from '../../toolbar/segmentation/sam-point-tool.service';\nimport { CellSegmentToolService } from '../../toolbar/segmentation/cell-segment-tool.service';\nimport { ICellSegmenter, CELL_SEGMENTER } from '../../contracts/cell-segmenter.contract';\n\n/** ICoordinateTransform over the napari camera: pointer client coords ↔ image/world coords. */\nclass NapariCoordinateTransform implements ICoordinateTransform {\n  constructor(\n    private readonly viewer: {\n      canvasToWorld(clientX: number, clientY: number): [number, number];\n      readonly camera: { zoom: number };\n    },\n    private readonly ready: () => boolean,\n  ) {}\n  clientToData(clientX: number, clientY: number): { x: number; y: number } {\n    const [x, y] = this.viewer.canvasToWorld(clientX, clientY);\n    return { x, y };\n  }\n  dataLengthToScreen(dataLength: number): number {\n    return dataLength * this.viewer.camera.zoom; // CSS px per world unit\n  }\n  isReady(): boolean {\n    return this.ready();\n  }\n}\n\n/** Opaque handle from {@link NapariVisualizerService.load}, passed back to plot(). */\ninterface NapariLoaded {\n  imageInfo: IImageInfo;\n  z: number;\n  /** Must match `IImageInfo.fileName` — the render orchestrator drops the result if the\n   *  handle's `filename` doesn't match the requested image (guards against stale clicks). */\n  filename: string;\n}\n\nconst VOLUME_MAX_SLICE = 1024; // \"Full\" in-plane cap; the default ¼ load uses 256\n/** Reference in-plane world size (long side) for the volume/axes box, in arbitrary world units.\n *  The box is anchored to this reference regardless of the chosen decimate factor, so changing the\n *  resolution changes DETAIL, not the volume's proportions (Z no longer appears to shrink when the\n *  in-plane sampling grows). Set to the DEFAULT decimate's in-plane cap so the default view is\n *  unchanged; higher/lower resolutions keep that same shape. See {@link mountVolume}. */\nconst VOLUME_WORLD_INPLANE_REF = VOLUME_MAX_SLICE / NAPARI_DEFAULT_DECIMATE;\n/** Max concurrent slice fetches when assembling a volume — keeps the connection pool busy\n *  without flooding it (browsers cap ~6/host) on a deep stack. */\nconst VOLUME_FETCH_CONCURRENCY = 8;\n\n/** Volume/isosurface sampling for a decimate factor `scale` (1 = Full 1024, 2 = ½ 512, 4 = ¼ 256\n *  default, 8 = ⅛ 128): the in-plane cap halves each step; slices stay un-subsampled until ⅛, then\n *  subsample. */\nfunction volumeResolutionFor(scale: number): { maxSlice: number; sliceStep: number } {\n  const s = Math.max(1, Math.round(scale));\n  return {\n    maxSlice: Math.max(8, Math.round(VOLUME_MAX_SLICE / s)),\n    sliceStep: Math.max(1, Math.floor(s / 4)),\n  };\n}\n/** Fully-normalized intensity height as a fraction of the in-plane extent — matches the Plotly\n *  SURFACE z-aspect (~0.4) so the relief isn't exaggerated. */\nconst SURFACE_Z_ASPECT = 0.4;\n/** \"Full\" mesh grid cap; the decimate factor divides it (default ¼ → 220, ½ → 440, Full → 880). */\nconst SURFACE_MAX_GRID = 880;\n/** Coefficient scaling the pyramid tile budget with the target resolution — a higher target pulls a\n *  finer pyramid level (more real detail). Shared by the surface plane fetch + volume assembly. */\nconst STITCH_BUDGET_COEFF = 16;\n/** Surface mesh target grid for a decimate factor `scale`: the grid cap shrinks by `scale` (every\n *  slice is kept — the z-slider needs them all). The source is fetched at a matching resolution. */\nfunction surfaceResolutionFor(scale: number): { maxGrid: number } {\n  const s = Math.max(1, Math.round(scale));\n  return { maxGrid: Math.max(16, Math.round(SURFACE_MAX_GRID / s)) };\n}\n\n/** 3D scatter: in-plane cap for the assembled voxel grid, and the max number of points emitted\n *  (the grid is flat-strided down to this) — keeps the billboard count interactive. */\nconst SCATTER3D_MAX_XY = 64;\nconst SCATTER3D_MAX_POINTS = 150000;\n\nconst TILE_SIZE = 512; // server tile edge (matches the OSD backend)\n/** Max tiles stitched for one displayed slice (512px tiles → up to ~6144² at full res). Beyond\n *  this we step to a coarser pyramid level so a large image stays tractable. */\nconst MAX_STITCH_TILES = 144;\n/** WebGPU default `maxTextureDimension2D` — a stitched slice's longest side must fit a texture. */\nconst MAX_TEXTURE_DIM = 8192;\n/** Concurrent tile requests per stitched slice. Firing a whole grid at once (hundreds of requests\n *  for a large level) overwhelmed the tile server (504s); a small pool keeps the pipe full without\n *  flooding it — and slice-level workers already run several stitches in parallel on top of this. */\nconst TILE_FETCH_CONCURRENCY = 6;\n/** How long to poll `/tiles/info` (202 while the server caches the source) before falling back to\n *  a single tile. Generous like the OSD backend — a cold whole-slide can take minutes to cache. */\nconst DESCRIPTOR_TIMEOUT_MS = 120000;\n\n/** Default per-channel tints (Fiji-style) when the store/descriptor offers no colour. */\nconst DEFAULT_TINTS = ['#ff0000', '#00ff00', '#0000ff', '#ffff00', '#ff00ff', '#00ffff', '#ffffff'];\n\n/** Default tint for a channel index, cycling the Fiji palette. */\nfunction tintFor(channel: number): string {\n  return DEFAULT_TINTS[channel % DEFAULT_TINTS.length];\n}\n\n/** One pyramid level from `GET /tiles/info` (res 0 = full resolution). */\ninterface TileLevel {\n  res: number;\n  width: number;\n  height: number;\n}\n\n/** Subset of the `/tiles/info` descriptor this backend reads (tile grid, channels, scale). */\ninterface TileDescriptor {\n  width: number;\n  height: number;\n  tileSize: number;\n  z: number;\n  channels: number;\n  multichannel?: boolean;\n  /** Real Bio-Formats levels at the front of `levels`; per-channel tiles exist only there. */\n  realLevels?: number;\n  channelInfo?: Array<{\n    name?: string;\n    color?: string;\n    bitDepth?: number;\n    minAllowed?: number;\n    maxAllowed?: number;\n  }> | null;\n  levels: TileLevel[];\n  mppX?: number;\n  mppY?: number;\n}\n\n/**\n * A WebGPU image backend built on the published `napari-js` library — the POC engine for\n * jit-ui#102 (a browser-based napari shipped as a JS library, swapping image plotting with\n * OpenSeadragon and 3D slicing/isosurfaces with Plotly).\n *\n * Render strategy: rather than re-implement the server's tile/pyramid protocol (which OSD\n * already handles), this backend renders the **complete per-slice image URLs the app already\n * produces** (`IImageInfo.urls`) — `urls[z]` for the 2D image, and the full `urls` stack\n * assembled into a downsampled volume for the 3D types. Region state and display options\n * delegate to the shared {@link RegionStore} / {@link VisualizerStore}, exactly as OSD does.\n *\n * Follow-ups (jit-ui#102): native-resolution pyramidal tiling, on-canvas tools, region\n * overlay rendering, per-channel histograms, TIFF export.\n */\n@Injectable({ providedIn: 'root' })\nexport class NapariVisualizerService extends BaseStoreVisualizer implements IVisualizer {\n  readonly capabilities: ViewerCapabilities = capabilitiesOf([\n    ViewerFeature.ImageDisplay,\n    ViewerFeature.StackSlider,\n    ViewerFeature.PixelReadback,\n    ViewerFeature.Surface3D,\n    ViewerFeature.Isosurface,\n  ]);\n\n  private readonly api: string;\n\n  private viewer: Viewer | null = null;\n  private canvas: HTMLCanvasElement | null = null;\n  private host: HTMLElement | null = null;\n  private loaded: NapariLoaded | null = null;\n  private lastPixels: PixelData | null = null;\n  private currentPlotType: PlotType = PlotType.NAPARI_IMAGE;\n  /** napari-js high-level view owning the 3D volume layers (one additive tinted layer per channel\n   *  for multichannel, or a single grayscale volume). Null in 2D. */\n  private volumeView: MultiChannelVolumeView | null = null;\n  /** True when the volume is composited from per-channel layers (vs a single grayscale volume). */\n  private volumeMultichannel = false;\n  /** napari-js height-field surface mesh (NAPARI_SURFACE plot type; null otherwise). Built from a\n   *  single grayscale slice by {@link buildSurface} via napari-js's `heightField` + `addSurface`. */\n  private surfaceLayer: SurfaceLayer | null = null;\n  /** Which band the surface samples (a channel index for multichannel, else the composite). */\n  private surfaceChannel: number | undefined = undefined;\n  /** True when the mounted Surface follows one band of a multichannel image. */\n  private surfaceMultichannel = false;\n  /** Pre-loaded per-slice luminance planes (already decimated to the surface grid), keyed by z,\n   *  so the stack slider rebuilds the surface instantly. Filled by {@link preloadSurfacePlanes}. */\n  private readonly surfacePlanes = new Map<\n    number,\n    { data: Uint8Array; width: number; height: number }\n  >();\n  /** In-plane grid cap for the active surface load (full grid ÷ the decimate factor). */\n  private surfaceMaxGrid = SURFACE_MAX_GRID;\n  /** Contrast window [min,max] the current surface mesh was built with. A change reshapes the\n   *  mesh (pixel height = intensity within [min,max]), so it triggers a geometry rebuild. */\n  private surfaceWindow: [number, number] | null = null;\n  /** Persisted wireframe choice for the surface (re-applied when a new surface mounts). */\n  private surfaceWireframe = false;\n  /** napari-js 2D scatter points (region centroids) + its region-change subscription. */\n  private scatter2dPoints: PointsLayer | null = null;\n  private scatterRegionSub: Subscription | null = null;\n  /** napari-js 3D scatter (voxel point cloud). */\n  private scatter3dLayer: Points3DLayer | null = null;\n  /** Monotonic load generation. Bumped by {@link reset} and {@link cancelLoading}; the frame-loading\n   *  loops (volume assembly, surface preload) capture it and bail when it changes, so a Cancel (or a\n   *  new plot) actually stops fetching frames instead of running to completion in the background. */\n  private loadToken = 0;\n  /** Decimate factor for the napari 3D types (1 = Full, 2 = ½ default, 4 = ¼, 8 = ⅛). Applied when a\n   *  volume/isosurface/surface (re)loads; changing it needs a re-plot (it changes fetched data). */\n  private resolutionScale = NAPARI_DEFAULT_DECIMATE;\n  /** 3D coordinate-axes / scale gizmo for the volume/isosurface view (null in 2D). */\n  private axesLayer: AxesLayer | null = null;\n  /** DOM X/Y/Z + scale labels tracking the 3D axes gizmo (null in 2D). */\n  private axesLabels: NapariAxesLabels | null = null;\n  /** Draggable Z-height grip over the volume (null unless a volume/isosurface is mounted). */\n  private zHandle: NapariVolumeZHandle | null = null;\n  /** User Z-height factor for the volume (1 = the volume's natural proportions); driven by the\n   *  in-view drag handle. Reset per mount. */\n  private volumeZScale = 1;\n  /** Volume world box at `volumeZScale = 1` (base) + the sampled voxel depth — enough to recompute\n   *  the Z-axis voxel scale, axes depth, and overlay anchors as the handle stretches Z. */\n  private volumeWorldBase: { width: number; height: number; depth: number } | null = null;\n  private volumeSampledDepth = 1;\n  /** Persisted axes on/off choice, re-applied when a new volume mounts. Defaults on. */\n  private axesVisible = true;\n  private volumeDims: { width: number; height: number; depth: number } | null = null;\n  /** Assembled uint8 volume data per channel (key = channel index), kept for the volume intensity\n   *  histogram. Key 0 holds the grayscale/composite volume in the single-channel case. */\n  private readonly volumeChannelData = new Map<number, Uint8Array>();\n  private imageW = 0;\n  private imageH = 0;\n  /** Monotonic slice-request id so a slow out-of-order slice fetch can't clobber a newer one. */\n  private sliceReq = 0;\n  /** Cached `/tiles/info` pyramid descriptor + the infoB64 it was fetched for. */\n  private descriptor: TileDescriptor | null = null;\n  private descriptorKey: string | null = null;\n\n  /** How the current 2D image is composited (drives histogram + state application). */\n  private imageMode: 'grayscale' | 'multichannel' | 'rgb' = 'rgb';\n  /** napari-js high-level view that owns the per-channel layer set (build + live display\n   *  updates) for the current {@link imageMode}. Rebuilt on each (re)render. */\n  private channelView: MultiChannelImageView | null = null;\n  /** Live subscription applying channel-state / colormap changes to the layers. */\n  private displaySub: Subscription | null = null;\n  /** Latest grayscale colormap selection from the store (applied to the single gray layer). */\n  private currentColormap: ColormapNode | null = null;\n  private currentReverse = false;\n  /** Latest invert toggle from the store (flips intensity before the colormap, like OSD). */\n  private invertEnabled = false;\n  /** Physical scale bar overlay for the 2D image (null when 3D or the image has no µm/pixel). */\n  private scaleBar: NapariScaleBar | null = null;\n  /** SVG region-drawing overlay for the 2D image (null until a 2D image is plotted). */\n  private regionOverlay: NapariRegionOverlay | null = null;\n  /** Pixel-tool plumbing: the plot div id, coord transform, and bound tool hosts. */\n  private plotDivId = '';\n  private coordTransform: ICoordinateTransform | null = null;\n  private wandHost: WandToolHost | null = null;\n  private eraserHost: VertexEraserToolHost | null = null;\n  /** Cached CachedImageData built from the last readback (rebuilt when lastPixels changes). */\n  private cachedImage: CachedImageData | null = null;\n  private cachedImageSource: PixelData | null = null;\n  /** Visible world rect captured AT the last readback — must pair with `lastPixels` so the pixel\n   *  tools' ratios/origin match the matrix's camera (using the live rect after a pan/zoom would\n   *  mis-scale the region). */\n  private lastPixelsRect: { x: number; y: number; width: number; height: number } | null = null;\n  /** Image smoothing (bilinear) vs nearest-neighbour (crisp pixels, the default). */\n  private imageSmoothing = false;\n  /** True when the 2D image is rendered via pyramidal TiledSources (descriptor available). */\n  private tiled = false;\n  /** Debounced readback timer + camera-change unsubscribe (keep lastPixels current for tools). */\n  private readbackTimer: ReturnType<typeof setTimeout> | null = null;\n  private cameraReadbackOff: (() => void) | null = null;\n  /** Coarse per-channel luminance sample (keyed by channel index) for the histogram in tiled mode,\n   *  where the layers have no full in-memory pixels. Refreshed on plot + slice change. */\n  private readonly histSamples = new Map<number, Uint8Array>();\n  /** Native-bit-depth histograms from `/histogram`, keyed `${z}|${channel}` (>8-bit images). */\n  private readonly nativeHistograms = new Map<string, IHistogram>();\n\n  private readonly stackLoading$ = new BehaviorSubject<boolean>(false);\n  private readonly stackLoadingProgress$ = new BehaviorSubject<number>(0);\n  private readonly autoscaleEvent$ = new Subject<unknown>();\n  private readonly intensityProfile$ = new Subject<IntensityProfile[]>();\n  private readonly viewportChange$ = new Subject<{\n    x: number;\n    y: number;\n    width: number;\n    height: number;\n  }>();\n\n  constructor(\n    @Inject(TILE_ACCESS_PORT) private readonly tiles: TileAccessPort,\n    store: VisualizerStore,\n    regionStore: RegionStore,\n    private readonly wandTool: WandToolService,\n    private readonly brushTool: BrushToolService,\n    private readonly eraserTool: VertexEraserToolService,\n    private readonly zoomToBoxTool: ZoomToBoxToolService,\n    private readonly samTool: SamToolService,\n    private readonly samPointTool: SamPointToolService,\n    private readonly cellSegmentTool: CellSegmentToolService,\n    @Optional() @Inject(CELL_SEGMENTER) private readonly cellSegmenter: ICellSegmenter | null,\n    private readonly simpleStack: SimpleSliceAccessService,\n    @Inject(VIZ_CONFIG) config: VizConfig,\n  ) {\n    super(regionStore, store);\n    this.api = config.slideCropServer;\n  }\n\n  /**\n   * Fetch + cache the server pyramid descriptor (`GET /tiles/info`): the REAL per-level tile grid,\n   * tile size, channel metadata and physical pixel size. The backend returns 202 while the source\n   * is still caching, so we poll briefly. Cached per `infoB64`; returns null if it never becomes\n   * ready (callers fall back to a single-tile fetch). This is the authoritative grid — guessing\n   * level dims from `trueImageSize` overshoots the real grid and the server 400s out-of-range tiles.\n   */\n  private async ensureDescriptor(): Promise<TileDescriptor | null> {\n    // Self-contained multi-slice stack (no tile server — e.g. a numbered image\n    // series assembled client-side, each slice a different file): there is no\n    // single server-tiled pyramid to describe. Returning null routes every\n    // caller (2D image, volume, surface) to their stitched/single-fetch\n    // fallback, which — via fetchSlice's own SimpleSliceAccessService branch —\n    // correctly fetches each slice's own URL instead of one fixed file's tile\n    // pyramid.\n    if (this.simpleStack.isSimple(this.loaded?.imageInfo)) return null;\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) return null;\n    if (this.descriptor && this.descriptorKey === infoB64) return this.descriptor;\n    const headers = await this.tiles\n      .getAuthHeaders()\n      .catch(() => ({}) as Record<string, string>);\n    const url = `${this.api}tiles/info?info=${infoB64}`;\n    const deadline = Date.now() + DESCRIPTOR_TIMEOUT_MS;\n    for (;;) {\n      try {\n        const resp = await fetch(url, { headers });\n        if (resp.status === 200) {\n          const body = (await resp.json()) as TileDescriptor;\n          if (body?.levels?.length) {\n            this.descriptor = body;\n            this.descriptorKey = infoB64;\n            return body;\n          }\n        }\n        // 202 (still caching) or empty body → re-poll until the deadline.\n      } catch (err) {\n        console.warn('[napari-js] tiles/info poll retry', err);\n      }\n      if (Date.now() > deadline) {\n        console.warn('[napari-js] tiles/info not ready; falling back to single-tile fetch');\n        return null;\n      }\n      await new Promise((r) => setTimeout(r, 1200));\n    }\n  }\n\n  /**\n   * Fetch a COMPLETE rendered slice as an `ImageBitmap` by stitching the server's REAL tile grid\n   * (from `/tiles/info`) — not just the top-left tile, which only ever showed a large image's\n   * corner. Picks the finest pyramid level whose grid fits `budgetTiles` and whose longest side is\n   * within the GPU texture limit, fetches that grid concurrently, and stitches it into one canvas.\n   *\n   * `channel` selects a single band as grayscale (real levels only); omit for the server composite.\n   * `budgetTiles` caps the grid: the 2D view uses the full budget for detail; the 3D volume passes\n   * 1 for a cheap overview tile per slice (it downsamples to {@link VOLUME_MAX_SLICE}). Falls back\n   * to a single `col=0,row=0` tile when no descriptor is available (small/simple images, volumes).\n   */\n  private async fetchSlice(\n    z: number,\n    channel?: number,\n    budgetTiles: number = MAX_STITCH_TILES,\n    /** When a specific channel has no pyramid level within `budgetTiles`, drop to the server\n     *  COMPOSITE overview instead of stitching the huge per-channel level. Only safe when the caller\n     *  wants a single decimated plane (the surface height): for a multichannel VOLUME every channel\n     *  would then fetch the same composite and the channels would collapse into one, so volume\n     *  assembly leaves this `false` to keep each band distinct. */\n    allowCompositeFallback = false,\n  ): Promise<ImageBitmap> {\n    // Self-contained multi-slice stack (tiled:false): `z` indexes a completely\n    // different file's own preview URL, not an internal slice of one server-\n    // tiled file — resolved and fetched via SimpleSliceAccessService (shared\n    // with OSD; see its docs for why this can't be a bare fetch()) instead of\n    // building a /tile?info=...&z= request against whichever single file\n    // getSelectedInfoB64() points at (which would 400/mismatch for any z\n    // beyond that one file's own extent).\n    const info = this.loaded?.imageInfo;\n    if (this.simpleStack.isSimple(info)) {\n      // Serverless multichannel volume: fetch the requested channel's OWN plane\n      // (channelUrls[z][channel]) so each band stays distinct — the client-side\n      // analog of the server's per-channel /tile?channel=c. Else the z-anchor URL.\n      const chUrls = (info as IImageInfo).channelUrls;\n      const url = channel != null && chUrls?.[z]?.[channel] != null\n        ? chUrls[z][channel]\n        : this.simpleStack.urlFor(info as IImageInfo, z);\n      if (!url) throw new Error(`[napari-js] no URL for slice ${z}`);\n      return this.simpleStack.fetchAsBitmap(url);\n    }\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) throw new Error('[napari-js] no selected image info (getSelectedInfoB64 null)');\n    const headers = await this.tiles\n      .getAuthHeaders()\n      .catch(() => ({}) as Record<string, string>);\n    const desc = await this.ensureDescriptor();\n\n    // The requested band; may be dropped to the composite (undefined) below when the channel has no\n    // pyramid level small enough to stitch within budget.\n    let effectiveChannel = channel;\n    const fetchTile = async (\n      res: number,\n      col: number,\n      row: number,\n      t: number,\n    ): Promise<ImageBitmap> => {\n      const ch = effectiveChannel == null ? '' : `&channel=${effectiveChannel}`;\n      const url = `${this.api}tile?info=${infoB64}&res=${res}&col=${col}&row=${row}&z=${z}&tileSize=${t}${ch}`;\n      const resp = await fetch(url, { headers });\n      if (!resp.ok) {\n        throw new Error(`[napari-js] slice fetch failed: ${resp.status} (${col}/${row} res ${res})`);\n      }\n      return createImageBitmap(await resp.blob());\n    };\n\n    // No descriptor → single top-left tile (legacy fallback; correct for small/simple images).\n    if (!desc || !desc.levels?.length) return fetchTile(0, 0, 0, TILE_SIZE);\n\n    const t = desc.tileSize || TILE_SIZE;\n    // Per-channel tiles exist ONLY at REAL Bio-Formats levels (the front of `levels`); the server\n    // composite exists at every level, including the small overviews.\n    const perChannelLevels = desc.realLevels ?? desc.levels.length;\n    const usable =\n      channel == null ? desc.levels : desc.levels.slice(0, Math.max(1, perChannelLevels));\n\n    // Finest level whose stitched grid fits BOTH the tile budget and the GPU texture limit; if none\n    // fits, the coarsest available (fits=false).\n    const tilesFor = (lvl: TileLevel): number =>\n      Math.max(1, Math.ceil(lvl.width / t)) * Math.max(1, Math.ceil(lvl.height / t));\n    const pick = (levels: TileLevel[]): { lvl: TileLevel; fits: boolean } => {\n      let c = levels[0];\n      for (const lvl of levels) {\n        c = lvl;\n        if (tilesFor(lvl) <= budgetTiles && Math.max(lvl.width, lvl.height) <= MAX_TEXTURE_DIM) {\n          return { lvl, fits: true };\n        }\n      }\n      return { lvl: c, fits: false };\n    };\n\n    let sel = pick(usable);\n    // A specific channel only has tiles at the (few, large) real levels. When none of them fit the\n    // budget — e.g. the coarsest real level is still 14982×18670 → ~1100 full-res tiles — stitching\n    // it per slice floods the server (504s) and stalls the load. The composite pyramid has small\n    // overview levels, so fetch the composite instead and derive luminance from it. Every caller here\n    // (surface height, volume assembly, readback) downscales the plane anyway, so a composite-derived\n    // plane is the right trade for one that actually loads. Only kicks in when the channel can't fit.\n    if (allowCompositeFallback && !sel.fits && channel != null && desc.levels.length > perChannelLevels) {\n      const composite = pick(desc.levels);\n      if (composite.fits || tilesFor(composite.lvl) < tilesFor(sel.lvl)) {\n        effectiveChannel = undefined;\n        sel = composite;\n        console.warn(\n          `[napari-js] channel ${channel} has no pyramid level within the ${budgetTiles}-tile ` +\n            `budget; using the composite overview (res ${sel.lvl.res}, ${sel.lvl.width}×` +\n            `${sel.lvl.height}) for this plane.`,\n        );\n      }\n    }\n    const chosen = sel.lvl;\n    const cols = Math.max(1, Math.ceil(chosen.width / t));\n    const rows = Math.max(1, Math.ceil(chosen.height / t));\n    if (!sel.fits && budgetTiles === MAX_STITCH_TILES) {\n      console.warn(\n        `[napari-js] full resolution exceeds the ${budgetTiles}-tile/${MAX_TEXTURE_DIM}px budget; ` +\n          `displaying overview level res ${chosen.res} (${chosen.width}×${chosen.height}).`,\n      );\n    }\n\n    if (cols === 1 && rows === 1) return fetchTile(chosen.res, 0, 0, t);\n\n    // Stitch into one level-sized canvas. Fetch the grid with BOUNDED concurrency: firing every tile\n    // at once (a big grid = hundreds of requests) overwhelmed the tile server (504s). Edge tiles are\n    // narrower/shorter; drawImage places each at its grid offset so partial tiles line up.\n    const coords: Array<{ col: number; row: number }> = [];\n    for (let row = 0; row < rows; row++) {\n      for (let col = 0; col < cols; col++) coords.push({ col, row });\n    }\n    const tiles: Array<{ col: number; row: number; bmp: ImageBitmap }> = [];\n    const stitchWorker = async (): Promise<void> => {\n      for (;;) {\n        const job = coords.shift();\n        if (!job) return;\n        const bmp = await fetchTile(chosen.res, job.col, job.row, t);\n        tiles.push({ col: job.col, row: job.row, bmp });\n      }\n    };\n    await Promise.all(\n      Array.from({ length: Math.min(TILE_FETCH_CONCURRENCY, coords.length) }, () => stitchWorker()),\n    );\n\n    let canvas: HTMLCanvasElement | OffscreenCanvas;\n    if (typeof OffscreenCanvas !== 'undefined') {\n      canvas = new OffscreenCanvas(chosen.width, chosen.height);\n    } else {\n      canvas = document.createElement('canvas');\n      canvas.width = chosen.width;\n      canvas.height = chosen.height;\n    }\n    const ctx = canvas.getContext('2d') as\n      | CanvasRenderingContext2D\n      | OffscreenCanvasRenderingContext2D\n      | null;\n    if (!ctx) throw new Error('[napari-js] slice stitch: 2D context unavailable');\n    for (const { col, row, bmp } of tiles) {\n      ctx.drawImage(bmp, col * t, row * t);\n      bmp.close?.();\n    }\n\n    // Safety net: if the chosen level still exceeds the GPU texture limit (e.g. a multichannel\n    // image whose coarsest REAL level is huge — overview levels are composite-only), downscale the\n    // stitched canvas to fit so the WebGPU texture upload can't fail.\n    const longest = Math.max(chosen.width, chosen.height);\n    if (longest > MAX_TEXTURE_DIM) {\n      const scale = MAX_TEXTURE_DIM / longest;\n      const outW = Math.max(1, Math.floor(chosen.width * scale));\n      const outH = Math.max(1, Math.floor(chosen.height * scale));\n      console.warn(\n        `[napari-js] stitched level ${chosen.width}×${chosen.height} exceeds the ` +\n          `${MAX_TEXTURE_DIM}px texture limit; downscaling to ${outW}×${outH}.`,\n      );\n      let out: HTMLCanvasElement | OffscreenCanvas;\n      if (typeof OffscreenCanvas !== 'undefined') {\n        out = new OffscreenCanvas(outW, outH);\n      } else {\n        out = document.createElement('canvas');\n        out.width = outW;\n        out.height = outH;\n      }\n      const octx = out.getContext('2d') as\n        | CanvasRenderingContext2D\n        | OffscreenCanvasRenderingContext2D\n        | null;\n      if (!octx) throw new Error('[napari-js] slice downscale: 2D context unavailable');\n      octx.drawImage(canvas as unknown as CanvasImageSource, 0, 0, outW, outH);\n      return createImageBitmap(out as unknown as ImageBitmapSource);\n    }\n    return createImageBitmap(canvas as unknown as ImageBitmapSource);\n  }\n\n  // ── IDataRenderer: load / render / viewport ───────────────────────────────\n  async load(imageInfo: IImageInfo, zIndex: number): Promise<NapariLoaded> {\n    // Keeps SimpleSliceAccessService's blob cache in sync even when the user\n    // switches backends (e.g. OSD Image → napari Volume) on the same file —\n    // whichever backend loads a genuinely different file first evicts it.\n    this.simpleStack.noteActiveFile(imageInfo.fileName);\n    this.loaded = { imageInfo, z: zIndex, filename: imageInfo.fileName };\n    return this.loaded;\n  }\n\n  async plot(\n    plotDiv: string,\n    imageLoaded: unknown,\n    imageInfo: IImageInfo,\n    screenHeight: number,\n    plotType: PlotType,\n    _inPlace?: boolean,\n  ): Promise<boolean> {\n    const host = document.getElementById(plotDiv);\n    if (!host) {\n      console.error(`[napari-js] plot target #${plotDiv} not found`);\n      return false;\n    }\n    this.reset();\n    this.host = host;\n    this.plotDivId = plotDiv;\n    this.currentPlotType = plotType;\n\n    const canvas = document.createElement('canvas');\n    canvas.style.display = 'block';\n    canvas.style.width = '100%';\n    canvas.style.height = screenHeight ? `${screenHeight}px` : '100%';\n    host.appendChild(canvas);\n    this.canvas = canvas;\n\n    const info = (imageLoaded as NapariLoaded)?.imageInfo ?? imageInfo;\n    const z = (imageLoaded as NapariLoaded)?.z ?? 0;\n\n    try {\n      const viewer = new Viewer({ canvas, background: { r: 0.07, g: 0.07, b: 0.09, a: 1 } });\n      this.viewer = viewer;\n      await viewer.ready;\n\n      if (isNapariScatter(plotType)) {\n        await this.mountScatter(viewer, z);\n      } else if (isNapariScatter3d(plotType)) {\n        await this.mountScatter3d(viewer, info);\n      } else if (isNapariSurface(plotType)) {\n        await this.mountSurface(viewer);\n      } else if (isNapari3d(plotType)) {\n        await this.mountVolume(viewer, info, plotType);\n      } else {\n        await this.renderImage(z);\n        this.fitCameraSoon();\n        this.subscribeDisplayState();\n        this.installScaleBar();\n        this.regionOverlay = new NapariRegionOverlay(host, viewer, this.regionStore);\n        this.buildToolHosts();\n        // Keep the pixel-tool readback (lastPixels) current as the view pans/zooms and tiled\n        // levels load, so wand/brush/SAM sample the actually-displayed image (jit-ui#102).\n        this.cameraReadbackOff = viewer.camera.changed.connect(() => this.armReadback());\n      }\n      this.scheduleReadback();\n      return true;\n    } catch (err) {\n      console.error('[napari-js] plot failed:', err);\n      return false;\n    }\n  }\n\n  // ── Channels: per-channel composite, LUT, native histograms (jit-ui#102) ──────────────────\n\n  /** The grayscale display colormap from the store selection (+reverse), defaulting to gray.\n   *  Maps the jit-ui store colormap node to a napari `Colormap` via the library's LUT factory;\n   *  the multichannel tint ramps are built inside {@link MultiChannelImageView} from each\n   *  channel's hex colour. */\n  private grayscaleColormap(): Colormap | string {\n    const value = (this.currentColormap as { data?: { value?: unknown } } | null)?.data?.value;\n    const lut = value != null ? buildColormapLut(value, this.currentReverse) : null;\n    if (lut) return colormapFromLut('gray-cmap', lut);\n    return this.currentReverse\n      ? colormapFromLut('gray-rev', [[255, 255, 255], [0, 0, 0]] as Rgb[])\n      : 'gray';\n  }\n\n  /** Fetch a stitched slice and read it back as a single-channel uint8 plane. `channel` selects a\n   *  band (multichannel); omit it for the grayscale composite (all overview levels available, so a\n   *  large image picks a fitting downscaled level rather than only the full-res real level). */\n  private async fetchChannelData(\n    z: number,\n    channel?: number,\n    budgetTiles?: number,\n  ): Promise<{ data: Uint8Array; width: number; height: number }> {\n    const bmp = await this.fetchSlice(z, channel, budgetTiles);\n    return this.bitmapToLuminance(bmp);\n  }\n\n  /** Decode an `ImageBitmap` (server bands are grayscale, R=G=B) to a single-channel uint8 plane.\n   *  `maxSide` caps the longest side (downscaling on the canvas draw) — used to keep pre-loaded\n   *  surface slice planes small. */\n  private bitmapToLuminance(\n    bmp: ImageBitmap,\n    maxSide?: number,\n  ): { data: Uint8Array; width: number; height: number } {\n    const scale = maxSide ? Math.min(1, maxSide / Math.max(bmp.width, bmp.height, 1)) : 1;\n    const w = Math.max(1, Math.round(bmp.width * scale));\n    const h = Math.max(1, Math.round(bmp.height * scale));\n    let canvas: HTMLCanvasElement | OffscreenCanvas;\n    if (typeof OffscreenCanvas !== 'undefined') {\n      canvas = new OffscreenCanvas(w, h);\n    } else {\n      canvas = document.createElement('canvas');\n      canvas.width = w;\n      canvas.height = h;\n    }\n    const ctx = canvas.getContext('2d') as\n      | CanvasRenderingContext2D\n      | OffscreenCanvasRenderingContext2D\n      | null;\n    if (!ctx) throw new Error('[napari-js] channel readback: 2D context unavailable');\n    // Scale the WHOLE bitmap into the (possibly smaller) target canvas — drawing at natural size\n    // would crop to the top-left w×h corner when downscaling a large slice (maxSide < bmp size).\n    ctx.drawImage(bmp, 0, 0, w, h);\n    bmp.close?.();\n    const rgba = ctx.getImageData(0, 0, w, h).data;\n    const data = new Uint8Array(w * h);\n    for (let i = 0; i < w * h; i++) data[i] = rgba[i * 4];\n    return { data, width: w, height: h };\n  }\n\n  /**\n   * Render the 2D image for slice `z`. With a server pyramid descriptor we use a pyramidal\n   * {@link TiledSource} per layer so the view refines to higher resolution on zoom (like OSD) and\n   * sits naturally in full-resolution coordinates; without one we fall back to the single-level\n   * stitch. Three display modes either way: multichannel additive tint, grayscale colormap, RGB.\n   */\n  private async renderImage(z: number, token?: number): Promise<void> {\n    const v = this.viewer;\n    if (!v) return;\n    const desc = await this.ensureDescriptor();\n    if (desc && desc.levels?.length) {\n      if (token != null && token !== this.sliceReq) return;\n      await this.renderImageTiled(z, desc);\n      return;\n    }\n    return this.renderImageStitched(z, token);\n  }\n\n  /** Single-level stitch fallback (no descriptor): the pre-tiling path. */\n  private async renderImageStitched(z: number, token?: number): Promise<void> {\n    const v = this.viewer;\n    if (!v) return;\n    const desc = await this.ensureDescriptor();\n    const states = this.store.currentChannelStates();\n    const channelCount = desc?.channels ?? (states.length || 1);\n    const multichannel = !!desc?.multichannel && channelCount > 1;\n\n    // 1) Fetch all pixel data BEFORE touching the viewer, so a superseded scrub can bail without\n    //    having torn down the visible layers (avoids flicker / out-of-order layer state).\n    let mode: 'grayscale' | 'multichannel' | 'rgb';\n    let planes: Array<{ data: Uint8Array; width: number; height: number }> = [];\n    let bitmap: ImageBitmap | null = null;\n    if (multichannel) {\n      mode = 'multichannel';\n      planes = await Promise.all(\n        Array.from({ length: channelCount }, (_, c) => this.fetchChannelData(z, c)),\n      );\n    } else if (channelCount === 1) {\n      mode = 'grayscale';\n      // Composite fetch (no channel) → all overview levels usable, so a large grayscale image\n      // selects a fitting downscaled level instead of the full-res real level (texture limit).\n      planes = [await this.fetchChannelData(z)];\n    } else {\n      mode = 'rgb';\n      bitmap = await this.fetchSlice(z);\n    }\n\n    // 2) Commit — unless a newer scrub superseded us or the viewer was torn down.\n    if ((token != null && token !== this.sliceReq) || this.viewer !== v) {\n      bitmap?.close?.();\n      return;\n    }\n\n    // The displayed texture may be a downscaled pyramid level; scale the layer into FULL-RESOLUTION\n    // world coordinates (level-0 pixels) so the camera, readback and — critically — pre-saved\n    // regions (stored in full-res coords, e.g. ndpi) all line up regardless of which level is shown.\n    // This mirrors OSD, whose coordinate system is always level 0.\n    const texW = mode === 'rgb' ? (bitmap as ImageBitmap).width : planes[0]?.width ?? 0;\n    const texH = mode === 'rgb' ? (bitmap as ImageBitmap).height : planes[0]?.height ?? 0;\n    const fullW = desc?.width || texW || 1;\n    const fullH = desc?.height || texH || 1;\n    const scale: [number, number] = [texW ? fullW / texW : 1, texH ? fullH / texH : 1];\n\n    this.imageMode = mode;\n    const interpolation: 'linear' | 'nearest' = this.imageSmoothing ? 'linear' : 'nearest';\n    this.channelView = new MultiChannelImageView(v);\n    if (mode === 'multichannel') {\n      const views: ChannelView[] = planes.map((d, c) => {\n        const st = states.find((s) => s.index === c);\n        const color = st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c);\n        return {\n          source: { kind: 'typed', width: d.width, height: d.height, channels: 1, dtype: 'uint8', data: d.data },\n          tint: color,\n          name: st?.name ?? `ch${c}`,\n          contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n          gamma: st?.gamma ?? 1,\n          visible: st?.visible ?? true,\n          invert: this.invertEnabled,\n          scale,\n        };\n      });\n      this.channelView.render('multichannel', views, { interpolation });\n    } else if (mode === 'grayscale') {\n      const d = planes[0];\n      const st = states[0];\n      this.channelView.render(\n        'grayscale',\n        [\n          {\n            source: { kind: 'typed', width: d.width, height: d.height, channels: 1, dtype: 'uint8', data: d.data },\n            colormap: this.grayscaleColormap(),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: st?.gamma ?? 1,\n            invert: this.invertEnabled,\n            scale,\n          },\n        ],\n        { interpolation },\n      );\n    } else {\n      this.channelView.render('rgb', [{ source: bitmap as ImageBitmap, scale }], { interpolation });\n    }\n    this.imageW = fullW;\n    this.imageH = fullH;\n  }\n\n  /**\n   * Render the 2D image with pyramidal {@link TiledSource}s — the view refines to higher resolution\n   * as you zoom in (the visual fetches the level whose texels ≈ screen pixels) and sits in full-res\n   * coordinates so regions align. Same three modes as the stitch path. Per-channel layers use the\n   * REAL pyramid levels (per-channel tiles only exist there); the composite uses all levels.\n   */\n  private async renderImageTiled(z: number, desc: TileDescriptor): Promise<void> {\n    const v = this.viewer;\n    if (!v) return;\n    const states = this.store.currentChannelStates();\n    const channelCount = desc.channels ?? (states.length || 1);\n    const multichannel = !!desc.multichannel && channelCount > 1;\n    const interpolation: 'linear' | 'nearest' = this.imageSmoothing ? 'linear' : 'nearest';\n\n    this.tiled = true;\n    this.channelView = new MultiChannelImageView(v);\n\n    if (multichannel) {\n      this.imageMode = 'multichannel';\n      const views: ChannelView[] = [];\n      for (let c = 0; c < channelCount; c++) {\n        const st = states.find((s) => s.index === c);\n        const color = st?.color ?? desc.channelInfo?.[c]?.color ?? tintFor(c);\n        views.push({\n          source: this.buildTiledSource(desc, c, 1),\n          tint: color,\n          name: st?.name ?? `ch${c}`,\n          contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n          gamma: st?.gamma ?? 1,\n          visible: st?.visible ?? true,\n          invert: this.invertEnabled,\n        });\n      }\n      this.channelView.render('multichannel', views, { interpolation });\n    } else if (channelCount === 1) {\n      this.imageMode = 'grayscale';\n      const st = states[0];\n      this.channelView.render(\n        'grayscale',\n        [\n          {\n            source: this.buildTiledSource(desc, undefined, 1),\n            colormap: this.grayscaleColormap(),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: st?.gamma ?? 1,\n            invert: this.invertEnabled,\n          },\n        ],\n        { interpolation },\n      );\n    } else {\n      this.imageMode = 'rgb';\n      this.channelView.render('rgb', [{ source: this.buildTiledSource(desc, undefined, 4) }], {\n        interpolation,\n      });\n    }\n    this.imageW = desc.width;\n    this.imageH = desc.height;\n    // Await on the initial render so getHistogram/autoContrast have data immediately; slice changes\n    // refresh fire-and-forget (the histogram pane retries).\n    await this.refreshHistogramSamples(z, desc);\n  }\n\n  /** Build a pyramidal TiledSource backed by the server `/tile` endpoint. `channel` selects a band\n   *  (grayscale luminance, real levels only); omit it for the composite (RGBA, all levels). */\n  private buildTiledSource(\n    desc: TileDescriptor,\n    channel: number | undefined,\n    channels: 1 | 4,\n  ): TiledSource {\n    const infoB64 = this.tiles.getSelectedInfoB64() ?? '';\n    // Per-channel tiles exist only at REAL Bio-Formats levels; the composite exists at all levels.\n    const usable =\n      channel == null\n        ? desc.levels\n        : desc.levels.slice(0, Math.max(1, desc.realLevels ?? desc.levels.length));\n    const levelScales = usable.map((l) => desc.width / Math.max(1, l.width)); // level-0 px per level px\n    const tileSize = desc.tileSize || TILE_SIZE;\n    const ch = channel == null ? '' : `&channel=${channel}`;\n    const api = this.api;\n    return {\n      kind: 'tiled',\n      width: desc.width,\n      height: desc.height,\n      tileSize,\n      levels: usable.length,\n      levelScales,\n      depth: Math.max(1, desc.z || 1),\n      channels,\n      dtype: 'uint8',\n      fetchTile: async (key: TileKey): Promise<PixelChunk> => {\n        const res = usable[key.level]?.res ?? key.level;\n        const url = `${api}tile?info=${infoB64}&res=${res}&col=${key.col}&row=${key.row}&z=${key.z}&tileSize=${tileSize}${ch}`;\n        const headers = await this.tiles\n          .getAuthHeaders()\n          .catch(() => ({}) as Record<string, string>);\n        const resp = await fetch(url, { headers });\n        if (!resp.ok) {\n          throw new Error(`[napari-js] tile ${key.level}/${key.col}/${key.row} → ${resp.status}`);\n        }\n        const bmp = await createImageBitmap(await resp.blob());\n        if (channels === 4) return { width: bmp.width, height: bmp.height, data: bmp };\n        return this.bitmapToLuminance(bmp);\n      },\n    };\n  }\n\n  /** (Re)fetch a coarse per-channel luminance sample for the histogram (tiled mode has no full\n   *  in-memory pixels). One cheap overview tile per channel; cached by channel index. */\n  private async refreshHistogramSamples(z: number, desc: TileDescriptor): Promise<void> {\n    this.histSamples.clear();\n    if (this.imageMode === 'rgb') return; // RGB uses the displayed-pixel readback (rgbHistogram)\n    const channelCount = this.imageMode === 'multichannel' ? desc.channels ?? 1 : 1;\n    for (let c = 0; c < channelCount; c++) {\n      try {\n        const ch = this.imageMode === 'multichannel' ? c : undefined;\n        const d = await this.fetchChannelData(z, ch, 1); // budget 1 → coarsest single tile\n        this.histSamples.set(c, d.data);\n      } catch {\n        /* leave this channel's sample unset */\n      }\n    }\n  }\n\n  /** Subscribe channel states + grayscale colormap → live-apply to the rendered layers (no\n   *  re-fetch; only z changes re-fetch). Replaces any prior subscription. */\n  private subscribeDisplayState(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = combineLatest([\n      this.store.getChannelStates(),\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n    ]).subscribe(([channels, colormap, reverse, invert]) => {\n      this.currentColormap = (colormap as ColormapNode) ?? null;\n      this.currentReverse = reverse;\n      this.invertEnabled = invert;\n      this.applyDisplayState(channels);\n    });\n  }\n\n  /** Subscribe the store colormap (+reverse), invert, and channel state → the volume/isosurface\n   *  transfer function: colour (channel tint or selected colormap), the intensity **window\n   *  (min/max → contrastLimits)** and **gamma**, mirroring the grayscale image's display controls\n   *  so the histogram pane drives the 3D render. Replaces any prior subscription. */\n  private subscribeVolumeDisplayState(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = combineLatest([\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n      this.store.getChannelStates(),\n    ]).subscribe(([colormap, reverse, invert, channels]) => {\n      this.currentColormap = (colormap as ColormapNode) ?? null;\n      this.currentReverse = reverse;\n      this.invertEnabled = invert;\n      const view = this.volumeView;\n      if (!view) return;\n      if (this.volumeMultichannel) {\n        // Each channel's layer is tinted by its colour and gets its own window/gamma/visibility.\n        view.layers.forEach((_, c) => {\n          const st = channels.find((s) => s.index === c);\n          view.updateChannel(c, {\n            colormap: this.channelTintColormap(st?.color ?? '#ffffff'),\n            ...(st\n              ? {\n                  contrastLimits: [st.min, st.max] as [number, number],\n                  gamma: st.gamma,\n                  visible: st.visible,\n                }\n              : {}),\n          });\n        });\n      } else {\n        const st = channels[0];\n        view.updateChannel(0, {\n          colormap: this.volumeColormap(st),\n          ...(st ? { contrastLimits: [st.min, st.max] as [number, number], gamma: st.gamma } : {}),\n        });\n      }\n    });\n  }\n\n  /** A channel's tint colormap (black→colour) with reverse-scale / invert applied by flipping. */\n  private channelTintColormap(color: string): Colormap | string {\n    let cmap: Colormap | string = tintColormap(color);\n    if (this.currentReverse) cmap = reverseColormap(cmap);\n    if (this.invertEnabled) cmap = reverseColormap(cmap);\n    return cmap;\n  }\n\n  /**\n   * Colour map for the volume/isosurface. A real colormap selection (viridis/magma/…) wins;\n   * otherwise the channel's colour tints it (so the channel-dialog colour swatch recolors the 3D\n   * render). Reverse-scale and invert each flip the ramp — the `VolumeLayer` has no per-layer\n   * invert, so both are emulated by reversing the colormap.\n   */\n  private volumeColormap(st: IChannelState | undefined): Colormap | string {\n    const node = this.currentColormap as { label?: string; data?: { value?: unknown } } | null;\n    // A colored colormap (viridis/magma/…) drives the volume; the default grayscale family\n    // (gray / Greys / Greys Inv) yields to the channel's colour so the dialog colour swatch\n    // recolors the 3D render.\n    const label = (node?.label ?? '').toLowerCase();\n    const grayFamily = label === '' || label.includes('grey') || label.includes('gray');\n    const value = node?.data?.value;\n    const lut = !grayFamily && value != null ? buildColormapLut(value, false) : null;\n    let cmap: Colormap | string = lut\n      ? colormapFromLut('vol-cmap', lut)\n      : tintColormap(st?.color ?? '#ffffff');\n    // Reverse-scale and invert each flip the ramp (the VolumeLayer has no per-layer invert).\n    if (this.currentReverse) cmap = reverseColormap(cmap);\n    if (this.invertEnabled) cmap = reverseColormap(cmap);\n    return cmap;\n  }\n\n  /** Apply the current channel states / colormap to the live layers (no re-fetch), delegating the\n   *  per-channel layer mutations to the {@link MultiChannelImageView}. */\n  private applyDisplayState(channels: IChannelState[]): void {\n    const view = this.channelView;\n    if (!this.viewer || !view) return;\n    if (this.imageMode === 'multichannel') {\n      view.layers.forEach((_, c) => {\n        const st = channels.find((s) => s.index === c);\n        if (!st) return;\n        view.updateChannel(c, {\n          tint: st.color,\n          contrastLimits: [st.min, st.max],\n          gamma: st.gamma,\n          visible: st.visible,\n          invert: this.invertEnabled,\n        });\n      });\n    } else if (this.imageMode === 'grayscale') {\n      const st = channels[0];\n      view.updateChannel(0, {\n        colormap: this.grayscaleColormap(),\n        invert: this.invertEnabled,\n        ...(st ? { contrastLimits: [st.min, st.max] as [number, number], gamma: st.gamma } : {}),\n      });\n    }\n  }\n\n  /** (Re)install the physical scale bar over the 2D image, sized from the image's µm/pixel\n   *  (`/tiles/info` mppX, falling back to the image metadata). No-op without a physical size. */\n  private installScaleBar(): void {\n    this.scaleBar?.destroy();\n    this.scaleBar = null;\n    const mppX = this.descriptor?.mppX || this.loaded?.imageInfo.imageMeta?.[0]?.mppX || 0;\n    if (this.viewer && this.host && mppX > 0) {\n      this.scaleBar = new NapariScaleBar(this.host, this.viewer.camera, mppX);\n    }\n  }\n\n  /** Convert a napari-js `Histogram` (bin count + min/max) to the pane's `IHistogram` (bin edges). */\n  private toIHistogram(h: { counts: Uint32Array; bins: number; min: number; max: number }): IHistogram {\n    const span = h.max - h.min || 1;\n    const bins = Array.from({ length: h.bins }, (_, i) => h.min + (i * span) / h.bins);\n    const counts = Array.from(h.counts);\n    return { bins, counts, max: counts.reduce((m, c) => (c > m ? c : m), 0) };\n  }\n\n  /**\n   * Mount the 3D volume/isosurface. A multichannel image becomes one additive, tinted\n   * {@link VolumeLayer} per channel (so each channel's colour composites into the render); a\n   * grayscale/composite image uses a single volume. Adds the axes gizmo + labels and wires the\n   * display-state subscription. The caller owns `viewer.ready`.\n   */\n  private async mountVolume(\n    viewer: Viewer,\n    info: IImageInfo | undefined,\n    plotType: PlotType,\n  ): Promise<void> {\n    const token = this.loadToken; // bail before rendering if a Cancel / new plot bumps this\n    const desc = await this.ensureDescriptor();\n    // Serverless multichannel (tiled:false + channelUrls): no tile descriptor, so\n    // derive the channel count from imageMeta and assemble each band from its own\n    // channelUrls[z][c] plane (fetchSlice does the per-channel routing).\n    const simpleMc = this.simpleStack.isSimple(info) && !!info?.channelUrls?.length\n      && (info?.imageMeta?.[0]?.channelCount ?? 1) > 1;\n    const channelCount = simpleMc ? info!.imageMeta![0].channelCount : (desc?.channels ?? 1);\n    const multichannel = simpleMc || (!!desc?.multichannel && channelCount > 1);\n    const res = volumeResolutionFor(this.resolutionScale);\n    const rendering: 'iso' | 'mip' = isNapariIsosurface(plotType) ? 'iso' : 'mip';\n    const states = this.store.currentChannelStates();\n\n    this.volumeChannelData.clear();\n    this.volumeMultichannel = multichannel;\n    this.imageMode = multichannel ? 'multichannel' : 'grayscale';\n    const view = new MultiChannelVolumeView(viewer);\n    this.volumeView = view;\n\n    // Assemble per-channel scalar volumes from the server tiles (jit-specific); the napari-js view\n    // owns the layer orchestration (one additive tinted volume per channel, or a single grayscale\n    // volume). The adapter computes each channel's colormap (incl. invert/reverse flips).\n    let dims: { width: number; height: number; depth: number } | null = null;\n    const channels: VolumeChannel[] = [];\n    this.stackLoading$.next(true);\n    this.stackLoadingProgress$.next(0);\n    try {\n      if (multichannel) {\n        for (let c = 0; c < channelCount; c++) {\n          const vol = await this.assembleVolume(info, res, c);\n          if (!vol) continue;\n          dims = vol;\n          this.volumeChannelData.set(c, vol.data);\n          const st = states.find((s) => s.index === c);\n          const color = st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c);\n          channels.push({\n            data: vol.data,\n            width: vol.width,\n            height: vol.height,\n            depth: vol.depth,\n            colormap: this.channelTintColormap(color),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: st?.gamma ?? 1,\n            visible: st?.visible ?? true,\n          });\n        }\n      } else {\n        const vol = await this.assembleVolume(info, res);\n        if (vol) {\n          dims = vol;\n          this.volumeChannelData.set(0, vol.data);\n          const st = states[0];\n          channels.push({\n            data: vol.data,\n            width: vol.width,\n            height: vol.height,\n            depth: vol.depth,\n            colormap: this.volumeColormap(st),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: st?.gamma ?? 1,\n          });\n        }\n      }\n    } finally {\n      this.stackLoading$.next(false);\n      this.stackLoadingProgress$.next(0);\n    }\n\n    if (!dims || !channels.length || this.loadToken !== token) return; // cancelled → don't render\n\n    // Resolution-invariant world box. Sizing the box by the sampled voxel counts made higher\n    // in-plane resolution grow X/Y while the depth stayed the (constant) slice count — so Z appeared\n    // to shrink at higher resolution. Instead anchor the in-plane long side to a fixed reference and\n    // let Z span the full slice count; the box shape is then identical at every decimate factor. The\n    // per-axis `voxelSize` (napari `scale`) maps the sampled grid onto that fixed world box.\n    const fullW = this.descriptor?.width ?? dims.width;\n    const fullH = this.descriptor?.height ?? dims.height;\n    const fullD =\n      this.loaded?.imageInfo.imageMeta?.[0]?.z || this.loaded?.imageInfo.urls?.length || dims.depth;\n    const fullLong = Math.max(1, fullW, fullH);\n    const world = {\n      width: (fullW * VOLUME_WORLD_INPLANE_REF) / fullLong,\n      height: (fullH * VOLUME_WORLD_INPLANE_REF) / fullLong,\n      depth: fullD,\n    };\n    // Base box (Z-scale = 1) + the sampled depth drive the live Z-height handle below; the persisted\n    // `volumeZScale` (user drag) applies on top so changing resolution keeps the chosen height.\n    this.volumeWorldBase = world;\n    this.volumeSampledDepth = Math.max(1, dims.depth);\n    const worldZ = world.depth * this.volumeZScale;\n    const voxelSize: [number, number, number] = [\n      world.width / dims.width,\n      world.height / dims.height,\n      worldZ / this.volumeSampledDepth,\n    ];\n    for (const ch of channels) ch.voxelSize = voxelSize;\n\n    view.render(multichannel ? 'multichannel' : 'grayscale', channels, { rendering });\n    this.imageW = dims.width;\n    this.imageH = dims.height;\n    this.volumeDims = dims;\n\n    // 3D coordinate-axes / scale gizmo + labels, sharing the volume's world box so the gizmo tracks\n    // the rendered proportions. Physical scale text still comes from the FULL image extent.\n    const mppX = this.descriptor?.mppX || this.loaded?.imageInfo.imageMeta?.[0]?.mppX || 0;\n    this.axesLayer = viewer.addAxes(world.width, world.height, worldZ, { visible: this.axesVisible });\n    if (this.host) {\n      this.axesLabels = new NapariAxesLabels(\n        this.host,\n        viewer.camera3d,\n        this.buildAxesLabels({ width: world.width, height: world.height, depth: worldZ }, mppX),\n      );\n      this.axesLabels.setVisible(this.axesVisible);\n      // In-view drag handle at the TOP END OF THE Z AXIS (the box's min-XY corner, where the blue\n      // \"Z\" axis + label live), so it reads as the Z-height control. Floated a little past the axis\n      // tip (×1.12) so the grip clears the \"Z · …\" label. Drag ↕ to restretch Z live.\n      this.zHandle = new NapariVolumeZHandle(this.host, viewer.camera3d, {\n        topAnchor: () => [\n          -this.volumeWorldBase!.width / 2,\n          -this.volumeWorldBase!.height / 2,\n          ((this.volumeWorldBase!.depth * this.volumeZScale) / 2) * 1.12,\n        ],\n        getScale: () => this.volumeZScale,\n        setScale: (s) => this.setVolumeZScale(s),\n      });\n    }\n    this.subscribeVolumeDisplayState();\n  }\n\n  /**\n   * Restretch the volume's Z height live (driven by the in-view {@link NapariVolumeZHandle}). Only\n   * the per-axis `voxelSize` / axes depth change — the voxel textures are untouched — so dragging is\n   * smooth. `factor` is relative to the volume's natural proportions (1). Persists across re-mounts\n   * (resolution changes) so the chosen height sticks.\n   */\n  private setVolumeZScale(factor: number): void {\n    this.volumeZScale = Math.min(10, Math.max(0.1, factor));\n    const base = this.volumeWorldBase;\n    if (!base || !this.volumeView) return;\n    const worldZ = base.depth * this.volumeZScale;\n    const vsZ = worldZ / this.volumeSampledDepth;\n    for (const layer of this.volumeView.layers) {\n      const [sx, sy] = layer.voxelSize;\n      layer.voxelSize = [sx, sy, vsZ];\n    }\n    if (this.axesLayer) this.axesLayer.depth = worldZ;\n    const mppX = this.descriptor?.mppX || this.loaded?.imageInfo.imageMeta?.[0]?.mppX || 0;\n    this.axesLabels?.updateAnchors(\n      this.buildAxesLabels({ width: base.width, height: base.height, depth: worldZ }, mppX),\n    );\n    this.zHandle?.reposition();\n    this.viewer?.requestRender();\n  }\n\n  /** Build the X/Y/Z axis-end label specs for the 3D gizmo. Anchors are in the volume's centred\n   *  world box (matching the AxesLayer geometry); the scale text reflects the FULL image extent —\n   *  physical µm when µm/pixel is known, else pixel (X/Y) / slice (Z) counts. */\n  private buildAxesLabels(\n    vol: { width: number; height: number; depth: number },\n    mppX: number,\n  ): AxisLabelSpec[] {\n    const hx = vol.width / 2;\n    const hy = vol.height / 2;\n    const hz = vol.depth / 2;\n    const descW = this.descriptor?.width ?? vol.width;\n    const descH = this.descriptor?.height ?? vol.height;\n    const slices =\n      this.loaded?.imageInfo.imageMeta?.[0]?.z || this.loaded?.imageInfo.urls?.length || vol.depth;\n    const len = (px: number): string => (mppX > 0 ? formatUm(px * mppX) : `${px} px`);\n    return [\n      { anchor: [hx, -hy, -hz], text: `X · ${len(descW)}`, color: '#ed4545' },\n      { anchor: [-hx, hy, -hz], text: `Y · ${len(descH)}`, color: '#4dd959' },\n      { anchor: [-hx, -hy, hz], text: `Z · ${slices} px`, color: '#668cff' },\n    ];\n  }\n\n  /**\n   * Assemble a downsampled uint8 volume (luminance) from the per-slice tile endpoint. Slices are\n   * fetched with bounded concurrency (keeps the connection pool full without flooding it on a deep\n   * stack) and read into the volume as each arrives, driving {@link stackLoadingProgress$} so the\n   * host shows a determinate progress bar instead of a bare spinner.\n   */\n  private async assembleVolume(\n    info: IImageInfo | undefined,\n    opts: { maxSlice?: number; sliceStep?: number } = {},\n    channel?: number,\n  ): Promise<{ data: Uint8Array; width: number; height: number; depth: number } | null> {\n    const token = this.loadToken; // bail if a Cancel / new plot bumps this while we fetch\n    const fullDepth = info?.imageMeta?.[0]?.z || info?.urls?.length || 1;\n    if (fullDepth < 1) {\n      console.warn('[napari-js] no slices to assemble a volume');\n      return null;\n    }\n    const step = Math.max(1, Math.floor(opts.sliceStep ?? 1));\n    const maxSlice = opts.maxSlice ?? VOLUME_MAX_SLICE;\n    // Source-slice indices sampled into the volume (every `step`th plane → low-res is faster).\n    const zIndices: number[] = [];\n    for (let z = 0; z < fullDepth; z += step) zIndices.push(z);\n    const depth = zIndices.length;\n\n    this.stackLoadingProgress$.next(0);\n    try {\n      // Fetch each slice at a pyramid level matching `maxSlice` (budget scales with the decimate\n      // factor), so a higher factor pulls a finer level → more real in-plane detail; then downsample\n      // to `maxSlice`. `channel` selects a band (multichannel volume); omit for the grayscale\n      // composite. The caller owns the stackLoading flag (multichannel assembles channels in turn).\n      const budget = this.tileBudgetFor(maxSlice);\n      const first = await this.fetchSlice(zIndices[0], channel, budget);\n      const scale = Math.min(1, maxSlice / Math.max(first.width, first.height, 1));\n      const width = Math.max(1, Math.round(first.width * scale));\n      const height = Math.max(1, Math.round(first.height * scale));\n      const data = new Uint8Array(width * height * depth);\n\n      let canvas: HTMLCanvasElement | OffscreenCanvas;\n      if (typeof OffscreenCanvas !== 'undefined') {\n        canvas = new OffscreenCanvas(width, height);\n      } else {\n        canvas = document.createElement('canvas');\n        canvas.width = width;\n        canvas.height = height;\n      }\n      const ctx = canvas.getContext('2d') as\n        | CanvasRenderingContext2D\n        | OffscreenCanvasRenderingContext2D\n        | null;\n      if (!ctx) throw new Error('napari-js volume assembly: 2D context unavailable');\n\n      // Read one fetched slice bitmap into the volume plane `z` (luminance). Synchronous between\n      // awaits, so the shared 2D context is safe to reuse across the concurrent fetch workers.\n      let done = 0;\n      const readSlice = (z: number, bmp: ImageBitmap): void => {\n        ctx.clearRect(0, 0, width, height);\n        ctx.drawImage(bmp, 0, 0, width, height);\n        const rgba = ctx.getImageData(0, 0, width, height).data;\n        const base = z * width * height;\n        for (let i = 0; i < width * height; i++) {\n          data[base + i] =\n            (rgba[i * 4] * 0.299 + rgba[i * 4 + 1] * 0.587 + rgba[i * 4 + 2] * 0.114) | 0;\n        }\n        bmp.close?.();\n        done++;\n        this.stackLoadingProgress$.next(Math.round((done / depth) * 100));\n      };\n\n      readSlice(0, first);\n\n      // Remaining planes via a small pool of workers draining a shared queue. Each plane `p`\n      // maps to source slice `zIndices[p]` (subsampled for low-res).\n      const pending: number[] = [];\n      for (let p = 1; p < depth; p++) pending.push(p);\n      const worker = async (): Promise<void> => {\n        for (;;) {\n          const p = pending.shift();\n          if (p === undefined || this.loadToken !== token) return;\n          readSlice(p, await this.fetchSlice(zIndices[p], channel, budget));\n        }\n      };\n      const poolSize = Math.min(VOLUME_FETCH_CONCURRENCY, Math.max(1, depth - 1));\n      await Promise.all(Array.from({ length: poolSize }, () => worker()));\n\n      if (this.loadToken !== token) return null; // cancelled → don't render a partial volume\n      return { data, width, height, depth };\n    } finally {\n      this.stackLoadingProgress$.next(0);\n    }\n  }\n\n  /**\n   * Mount the NAPARI_SCATTER 2D scatter: the slice image with a points layer at each region's\n   * centroid (napari-js analog of Plotly's region-centroid scatter). Rebuilds the points live as\n   * regions change.\n   */\n  private async mountScatter(viewer: Viewer, z: number): Promise<void> {\n    await this.renderImage(z);\n    this.fitCameraSoon();\n    this.subscribeDisplayState();\n    this.installScaleBar();\n    this.rebuildScatterPoints();\n    this.scatterRegionSub = this.regionStore\n      .getRegionUpdateEvent()\n      .subscribe(() => this.rebuildScatterPoints());\n    this.scheduleReadback();\n  }\n\n  /** (Re)build the 2D scatter's point layer at the current region centroids. */\n  private rebuildScatterPoints(): void {\n    const v = this.viewer;\n    if (!v) return;\n    if (this.scatter2dPoints) {\n      v.layers.remove(this.scatter2dPoints);\n      this.scatter2dPoints = null;\n    }\n    const centroids = this.regionCentroids();\n    if (centroids.length === 0) return;\n    this.scatter2dPoints = v.addPoints(centroids, {\n      size: 12,\n      faceColor: [1, 0.85, 0.2, 1],\n      borderColor: [0, 0, 0, 1],\n      borderWidth: 2,\n    });\n  }\n\n  /** Region centroids as flat `[x, y, …]` data coords (rectangle / polygon / multipolygon). */\n  private regionCentroids(): Float32Array {\n    const out: number[] = [];\n    const polyCentroid = (xs: number[], ys: number[]): void => {\n      const n = xs.length;\n      if (n === 0) return;\n      let cx = 0;\n      let cy = 0;\n      for (let i = 0; i < n; i++) {\n        cx += xs[i];\n        cy += ys[i];\n      }\n      out.push(cx / n, cy / n);\n    };\n    for (const r of this.regionStore.getRegions()) {\n      const b = r.bounds as\n        | { x: number; y: number; width: number; height: number }\n        | { xpoints: number[]; ypoints: number[] }\n        | { polygons: { xpoints: number[]; ypoints: number[] }[] }\n        | null\n        | undefined;\n      if (!b) continue;\n      if ('width' in b && 'x' in b) {\n        out.push(b.x + b.width / 2, b.y + b.height / 2);\n      } else if ('xpoints' in b) {\n        polyCentroid(b.xpoints, b.ypoints);\n      } else if ('polygons' in b) {\n        for (const p of b.polygons) polyCentroid(p.xpoints, p.ypoints);\n      }\n    }\n    return new Float32Array(out);\n  }\n\n  /**\n   * Mount the NAPARI_SCATTER3D 3D scatter: the downsampled voxel grid as a 3D point cloud colored\n   * by intensity (napari-js analog of Plotly's voxel scatter3d). Assembles a coarse volume, then\n   * emits a flat-strided sample of voxels (capped at {@link SCATTER3D_MAX_POINTS}) via `addPoints3D`.\n   */\n  private async mountScatter3d(viewer: Viewer, info: IImageInfo | undefined): Promise<void> {\n    this.imageMode = 'grayscale';\n    this.volumeMultichannel = false;\n    const res = volumeResolutionFor(this.resolutionScale);\n    this.stackLoading$.next(true);\n    this.stackLoadingProgress$.next(0);\n    let vol: { data: Uint8Array; width: number; height: number; depth: number } | null = null;\n    try {\n      vol = await this.assembleVolume(info, {\n        maxSlice: Math.min(res.maxSlice, SCATTER3D_MAX_XY),\n        sliceStep: res.sliceStep,\n      });\n    } finally {\n      this.stackLoading$.next(false);\n      this.stackLoadingProgress$.next(0);\n    }\n    if (!vol || this.viewer !== viewer) return;\n\n    const { data, width, height, depth } = vol;\n    const zScale = Math.max(width, height) / Math.max(1, depth); // ≈ cubic aspect\n    const total = width * height * depth;\n    const stride = Math.max(1, Math.ceil(total / SCATTER3D_MAX_POINTS));\n    const pos: number[] = [];\n    const val: number[] = [];\n    for (let i = 0; i < total; i += stride) {\n      const x = i % width;\n      const y = Math.floor(i / width) % height;\n      const zi = Math.floor(i / (width * height));\n      pos.push(x, y, zi * zScale);\n      val.push(data[i]);\n    }\n\n    const st = this.store.currentChannelStates()[0];\n    this.scatter3dLayer = viewer.addPoints3D(new Float32Array(pos), new Float32Array(val), {\n      colormap: this.volumeColormap(st),\n      contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n      size: 3,\n    });\n    this.imageW = width;\n    this.imageH = height;\n    this.volumeDims = { width, height, depth };\n    // Feed the intensity histogram from the assembled volume (key 0).\n    this.volumeChannelData.clear();\n    this.volumeChannelData.set(0, data);\n    this.subscribeScatter3dDisplayState();\n    this.scheduleReadback();\n  }\n\n  /** Store colormap / reverse / invert / channel window → the 3D scatter's colormap + contrast. */\n  private subscribeScatter3dDisplayState(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = combineLatest([\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n      this.store.getChannelStates(),\n    ]).subscribe(([colormap, reverse, invert, channels]) => {\n      this.currentColormap = (colormap as ColormapNode) ?? null;\n      this.currentReverse = reverse;\n      this.invertEnabled = invert;\n      const layer = this.scatter3dLayer;\n      if (!layer) return;\n      const st = channels[0];\n      layer.colormap = this.volumeColormap(st);\n      if (st) layer.contrastLimits = [st.min, st.max];\n      this.viewer?.requestRender();\n    });\n  }\n\n  /**\n   * Mount the NAPARI_SURFACE height-field surface. A height field is single-scalar, so for a\n   * multichannel image the surface follows ONE band — the first visible channel (fallback 0) —\n   * coloured by that channel's window/colormap (like the Plotly SURFACE, which is grayscale-only).\n   * Pre-loads every slice's height data with a progress bar (as the volume does) so the stack\n   * slider re-slices instantly, then builds the mesh for the current slice. All mesh + GPU work\n   * lives in napari-js (`heightField` + `Viewer.addSurface`); this backend supplies scalar slices.\n   */\n  private async mountSurface(viewer: Viewer): Promise<void> {\n    const desc = await this.ensureDescriptor();\n    const info = this.loaded?.imageInfo;\n    // Serverless multichannel (tiled:false + channelUrls) has no descriptor — detect\n    // it from imageMeta so the Surface still follows one band.\n    const simpleMc = this.simpleStack.isSimple(info) && !!info?.channelUrls?.length\n      && (info?.imageMeta?.[0]?.channelCount ?? 1) > 1;\n    const multichannel = simpleMc || (!!desc?.multichannel && (desc?.channels ?? 1) > 1);\n    this.surfaceMultichannel = multichannel;\n    // A height field is single-scalar → follow the pane-SELECTED channel.\n    this.surfaceChannel = multichannel ? this.store.currentSelectedChannel() : undefined;\n    this.surfaceMaxGrid = surfaceResolutionFor(this.resolutionScale).maxGrid;\n    this.imageMode = 'grayscale';\n    this.volumeMultichannel = false;\n    await this.preloadSurfacePlanes(viewer);\n    if (this.viewer !== viewer) return;\n    await this.buildSurface(viewer, this.loaded?.z ?? 0);\n    this.installSurfaceAxes(viewer);\n    // Subscribe after the first build so display-state edits target a live layer.\n    this.subscribeSurfaceDisplayState();\n  }\n\n  /** Add the 3D axes gizmo + DOM labels around the (origin-centered) surface mesh, matching the\n   *  volume/isosurface. Installed once per mount; the box tracks the mesh bounds, X/Y show the\n   *  physical (or pixel) extent, and Z is the intensity/height axis. */\n  private installSurfaceAxes(viewer: Viewer): void {\n    if (!this.surfaceLayer) return;\n    const b = this.surfaceLayer.bounds();\n    const boxW = Math.max(1, b.max[0] - b.min[0]);\n    const boxH = Math.max(1, b.max[1] - b.min[1]);\n    const boxD = Math.max(1, b.max[2] - b.min[2]);\n    const mppX = this.descriptor?.mppX || this.loaded?.imageInfo.imageMeta?.[0]?.mppX || 0;\n    const voxel = mppX > 0 ? (mppX * (this.descriptor?.width ?? this.imageW)) / Math.max(1, this.imageW) : 1;\n    this.axesLayer = viewer.addAxes(boxW, boxH, boxD, {\n      voxelSize: [voxel, voxel, 1],\n      visible: this.axesVisible,\n    });\n    if (this.host) {\n      this.axesLabels = new NapariAxesLabels(\n        this.host,\n        viewer.camera3d,\n        this.buildSurfaceAxesLabels(boxW, boxH, boxD, mppX),\n      );\n      this.axesLabels.setVisible(this.axesVisible);\n    }\n  }\n\n  /** X/Y/Z end-labels for the surface gizmo: X/Y are the physical (µm) or pixel extent of the FULL\n   *  image; Z is the intensity/height axis. Anchors are in the centered box (matching AxesLayer). */\n  private buildSurfaceAxesLabels(\n    boxW: number,\n    boxH: number,\n    boxD: number,\n    mppX: number,\n  ): AxisLabelSpec[] {\n    const hx = boxW / 2;\n    const hy = boxH / 2;\n    const hz = boxD / 2;\n    const descW = this.descriptor?.width ?? this.imageW;\n    const descH = this.descriptor?.height ?? this.imageH;\n    const len = (px: number): string => (mppX > 0 ? formatUm(px * mppX) : `${px} px`);\n    return [\n      { anchor: [hx, -hy, -hz], text: `X · ${len(descW)}`, color: '#ed4545' },\n      { anchor: [-hx, hy, -hz], text: `Y · ${len(descH)}`, color: '#4dd959' },\n      { anchor: [-hx, -hy, hz], text: 'Z · intensity', color: '#668cff' },\n    ];\n  }\n\n  /**\n   * Pre-fetch every stack slice's luminance plane (decimated to the surface grid) into\n   * {@link surfacePlanes}, driving {@link stackLoadingProgress$} — the same load-with-progress UX\n   * as the volume, but keeping one 2D plane per slice rather than packing a 3D volume. Bounded\n   * concurrency keeps the connection pool busy without flooding it on a deep stack.\n   */\n  private async preloadSurfacePlanes(viewer: Viewer): Promise<void> {\n    const token = this.loadToken; // bail if a Cancel / new plot bumps this while we fetch\n    const info = this.loaded?.imageInfo;\n    const depth = info?.imageMeta?.[0]?.z || info?.urls?.length || 1;\n    const { maxGrid } = surfaceResolutionFor(this.resolutionScale);\n    this.surfacePlanes.clear();\n    this.stackLoading$.next(true);\n    this.stackLoadingProgress$.next(0);\n    try {\n      const pending: number[] = [];\n      for (let z = 0; z < depth; z++) pending.push(z);\n      let done = 0;\n      const worker = async (): Promise<void> => {\n        for (;;) {\n          const z = pending.shift();\n          if (z === undefined || this.viewer !== viewer || this.loadToken !== token) return;\n          try {\n            this.surfacePlanes.set(z, await this.fetchSurfacePlane(z, maxGrid));\n          } catch (err) {\n            console.warn(`[napari-js] surface slice ${z} preload failed`, err);\n          }\n          done++;\n          this.stackLoadingProgress$.next(Math.round((done / depth) * 100));\n        }\n      };\n      const pool = Math.min(VOLUME_FETCH_CONCURRENCY, Math.max(1, depth));\n      await Promise.all(Array.from({ length: pool }, () => worker()));\n    } finally {\n      this.stackLoading$.next(false);\n      this.stackLoadingProgress$.next(0);\n    }\n  }\n\n  /**\n   * Fetch slice `z` as a single WHOLE-image luminance plane (decimated to `maxGrid`). Prefers the\n   * app's complete per-slice image (`smallUrls`/`urls`, exactly like the Plotly surface) so the\n   * surface always covers the FULL slice — the tile-pyramid `fetchSlice` path would fall back to a\n   * single top-left tile (a corner) for self-contained / non-`/tiles/info` images. Falls back to\n   * stitching the tile grid only when no complete-image URL is available.\n   */\n  /** Tile budget to stitch a whole slice at ~`targetPx` resolution from the pyramid: a higher target\n   *  pulls a FINER pyramid level (more real detail). Shared by the surface plane fetch and the volume\n   *  assembly so both scale their in-plane resolution with the decimate factor. */\n  private tileBudgetFor(targetPx: number): number {\n    const tileSize = this.descriptor?.tileSize || TILE_SIZE;\n    return Math.min(\n      MAX_STITCH_TILES,\n      Math.max(1, Math.round((targetPx / tileSize) ** 2 * STITCH_BUDGET_COEFF)),\n    );\n  }\n\n  private async fetchSurfacePlane(\n    z: number,\n    maxGrid: number,\n  ): Promise<{ data: Uint8Array; width: number; height: number }> {\n    const info = this.loaded?.imageInfo;\n    const desc = await this.ensureDescriptor();\n    let plane: { data: Uint8Array; width: number; height: number } | null = null;\n\n    // Preferred: stitch the WHOLE slice from the server pyramid at a resolution driven by the\n    // decimate factor — a higher target grid pulls a FINER pyramid level (more real detail). With a\n    // descriptor, fetchSlice stitches the whole chosen level (never a corner), then we downscale to\n    // the grid. This is what makes \"Full\" actually higher-res than \"½\", not just a fixed preview.\n    if (desc?.levels?.length) {\n      const budget = this.tileBudgetFor(maxGrid);\n      // The surface is a single decimated plane, so the composite fallback is acceptable when the\n      // channel has no small pyramid level (keeps it fast); a multichannel VOLUME must not do this.\n      plane = this.bitmapToLuminance(\n        await this.fetchSlice(z, this.surfaceChannel, budget, true),\n        maxGrid,\n      );\n    }\n\n    // Fallback (no pyramid): the app's COMPLETE per-slice image (urls[z], not the small blurry\n    // thumbnail) — whole slice, avoids a corner tile. Capped at the image's own resolution.\n    if (!plane) {\n      const url = info?.urls?.[z] ?? info?.smallUrls?.[z];\n      if (url) {\n        try {\n          const headers = await this.tiles\n            .getAuthHeaders()\n            .catch(() => ({}) as Record<string, string>);\n          const resp = await fetch(url, { headers });\n          if (resp.ok) {\n            plane = this.bitmapToLuminance(await createImageBitmap(await resp.blob()), maxGrid);\n          }\n        } catch (err) {\n          console.warn(`[napari-js] surface url fetch failed for z=${z}`, err);\n        }\n      }\n    }\n\n    // Last resort (no pyramid and no complete image): a single tile.\n    if (!plane) {\n      plane = this.bitmapToLuminance(\n        await this.fetchSlice(z, this.surfaceChannel, this.tileBudgetFor(maxGrid), true),\n        maxGrid,\n      );\n    }\n    return plane;\n  }\n\n  /** The channel state driving the surface: the chosen band for multichannel (matched by index),\n   *  else the single grayscale channel. */\n  private surfaceState(channels: IChannelState[]): IChannelState | undefined {\n    if (this.surfaceChannel == null) return channels[0];\n    return channels.find((s) => s.index === this.surfaceChannel) ?? channels[0];\n  }\n\n  /**\n   * (Re)build the surface mesh for slice `z` from the pre-loaded plane cache (instant — this is\n   * what the stack slider calls); a slice missing from the cache is fetched on demand. napari-js's\n   * pure `heightField` builds the triangle grid (z = normalized intensity), then `addSurface`\n   * renders it. The slice plane also feeds the intensity histogram (key 0).\n   */\n  private async buildSurface(viewer: Viewer, z: number): Promise<void> {\n    let plane = this.surfacePlanes.get(z);\n    if (!plane) {\n      this.stackLoading$.next(true);\n      try {\n        plane = await this.fetchSurfacePlane(z, this.surfaceMaxGrid);\n        this.surfacePlanes.set(z, plane);\n      } catch (err) {\n        console.error('[napari-js] surface slice fetch failed:', err);\n      } finally {\n        this.stackLoading$.next(false);\n      }\n    }\n    if (!plane || plane.width < 2 || plane.height < 2 || this.viewer !== viewer) return;\n\n    const st = this.surfaceState(this.store.currentChannelStates());\n    const win: [number, number] = [st?.min ?? 0, st?.max ?? 255];\n    this.surfaceWindow = win;\n    // Height AND colour are normalized by the same contrast window, so changing min/max reshapes the\n    // surface (a pixel's height = its intensity within [min,max]). Center it for the axes gizmo. The\n    // plane is already decimated to the grid cap → stride 1.\n    const zScale = SURFACE_Z_ASPECT * Math.max(plane.width, plane.height);\n    const { vertices, faces, values } = heightField(plane.data, plane.width, plane.height, {\n      zScale,\n      zLimits: win,\n      center: true,\n    });\n\n    // Preserve the orbit camera across a re-slice / window rebuild — only the first mount frames, so\n    // stepping the stack or changing the window keeps the current zoom/pan/orientation.\n    const cam = viewer.camera3d;\n    const preserveCamera = this.surfaceLayer != null;\n    const savedTarget = cam.target;\n    const savedDistance = cam.distance;\n    if (this.surfaceLayer) {\n      viewer.layers.remove(this.surfaceLayer);\n      this.surfaceLayer = null;\n    }\n    this.surfaceLayer = viewer.addSurface(vertices, faces, values, {\n      colormap: this.volumeColormap(st),\n      contrastLimits: win,\n      gamma: st?.gamma ?? 1,\n      wireframe: this.surfaceWireframe,\n    });\n    if (preserveCamera) {\n      cam.target = savedTarget;\n      cam.distance = savedDistance;\n    }\n\n    this.imageW = plane.width;\n    this.imageH = plane.height;\n    this.volumeDims = { width: plane.width, height: plane.height, depth: Math.max(1, Math.round(zScale)) };\n    // Reuse the volume intensity-histogram path: the slice's scalar plane is the histogram source.\n    this.volumeChannelData.clear();\n    this.volumeChannelData.set(0, plane.data);\n    this.scheduleReadback();\n  }\n\n  /** Subscribe the store colormap / reverse / invert / channel window → the surface, so histogram\n   *  & channel-dialog edits update it live without a re-fetch. **min/max reshapes the surface's\n   *  height** (a pixel's height = its intensity within [min,max]), so a window change rebuilds the\n   *  mesh geometry (from the cached slice); colour-only edits (colormap/LUT, gamma, reverse, invert)\n   *  just update the layer's uniforms. */\n  private subscribeSurfaceDisplayState(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = combineLatest([\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n      this.store.getChannelStates(),\n      this.store.getSelectedChannel(),\n    ]).subscribe(([colormap, reverse, invert, channels, selected]) => {\n      this.currentColormap = (colormap as ColormapNode) ?? null;\n      this.currentReverse = reverse;\n      this.invertEnabled = invert;\n      const layer = this.surfaceLayer;\n      if (!layer || !this.viewer) return;\n      // Selected channel changed (multichannel): re-fetch THAT band's planes and\n      // rebuild the height-field for the current slice.\n      if (this.surfaceMultichannel && selected !== this.surfaceChannel) {\n        this.surfaceChannel = selected;\n        void (async () => {\n          await this.preloadSurfacePlanes(this.viewer!);\n          if (this.viewer) await this.buildSurface(this.viewer, this.loaded?.z ?? 0);\n        })().catch((err) => console.error('[napari-js] surface channel switch failed:', err));\n        return;\n      }\n      const st = this.surfaceState(channels);\n      const win: [number, number] = [st?.min ?? 0, st?.max ?? 255];\n      const windowChanged =\n        !this.surfaceWindow || win[0] !== this.surfaceWindow[0] || win[1] !== this.surfaceWindow[1];\n      if (windowChanged) {\n        // Height follows the contrast window → rebuild the mesh for the new [min,max] (camera kept).\n        void this.buildSurface(this.viewer, this.loaded?.z ?? 0).catch((err) =>\n          console.error('[napari-js] surface window rebuild failed:', err),\n        );\n        return;\n      }\n      // Colour-only change: update uniforms in place, no geometry rebuild.\n      layer.colormap = this.volumeColormap(st);\n      if (st) {\n        layer.contrastLimits = win;\n        layer.gamma = st.gamma;\n      }\n      this.viewer.requestRender();\n    });\n  }\n\n  private fitCameraSoon(): void {\n    const run = (): void => {\n      if (this.viewer && this.canvas && this.imageW > 0 && this.imageH > 0) {\n        this.viewer.camera.fit(\n          this.imageW,\n          this.imageH,\n          this.canvas.clientWidth || this.imageW,\n          this.canvas.clientHeight || this.imageH,\n        );\n      }\n    };\n    if (typeof requestAnimationFrame === 'function') requestAnimationFrame(run);\n    else run();\n  }\n\n  /** @deprecated Plotly-specific; host re-drives plot() from its image stream. */\n  reloadAndPlot(): void {\n    /* no-op */\n  }\n\n  reset(): void {\n    this.loadToken++; // invalidate any in-flight frame loading from the previous plot\n    this.displaySub?.unsubscribe();\n    this.displaySub = null;\n    this.scaleBar?.destroy();\n    this.scaleBar = null;\n    this.regionOverlay?.destroy();\n    this.regionOverlay = null;\n    this.axesLabels?.destroy();\n    this.axesLabels = null;\n    this.zHandle?.destroy();\n    this.zHandle = null;\n    this.volumeWorldBase = null;\n    this.cachedImage = null;\n    this.cachedImageSource = null;\n    this.lastPixelsRect = null;\n    this.nativeHistograms.clear();\n    this.tiled = false;\n    this.histSamples.clear();\n    if (this.readbackTimer != null) {\n      clearTimeout(this.readbackTimer);\n      this.readbackTimer = null;\n    }\n    this.cameraReadbackOff?.();\n    this.cameraReadbackOff = null;\n    this.channelView = null;\n    this.viewer?.dispose();\n    this.viewer = null;\n    if (this.canvas && this.host?.contains(this.canvas)) this.host.removeChild(this.canvas);\n    this.canvas = null;\n    this.lastPixels = null;\n    this.volumeView = null;\n    this.volumeMultichannel = false;\n    this.surfaceLayer = null;\n    this.surfaceChannel = undefined;\n    this.surfacePlanes.clear();\n    this.surfaceWindow = null;\n    this.scatterRegionSub?.unsubscribe();\n    this.scatterRegionSub = null;\n    this.scatter2dPoints = null;\n    this.scatter3dLayer = null;\n    this.axesLayer = null;\n    this.volumeDims = null;\n    this.volumeChannelData.clear();\n  }\n\n  relayout(_trueImageSize?: number[]): void {\n    this.viewer?.requestRender();\n  }\n\n  /** @deprecated Plotly-specific axis reset. */\n  resetAxes(): void {\n    this.fitCameraSoon();\n  }\n\n  /** @deprecated Plotly-specific autoscale. */\n  autoscale(): void {\n    this.fitCameraSoon();\n    this.autoscaleEvent$.next(undefined);\n  }\n\n  zoomIn(): void {\n    if (this.viewer) this.viewer.camera.zoom = this.viewer.camera.zoom * 1.3;\n  }\n\n  zoomOut(): void {\n    if (this.viewer) this.viewer.camera.zoom = this.viewer.camera.zoom / 1.3;\n  }\n\n  setDragMode(_mode: string | false): void {\n    // No-op: pan and zoom are always the napari camera's default gestures, and pan/zoom gating for\n    // drawing is owned by the region overlay's setMode (setControlsEnabled). Toggling controls here\n    // would fight that — the host calls setDragMode(false) alongside overlay.setMode(<tool>).\n  }\n\n  setNavigatorVisible(_visible: boolean): void {\n    /* napari-js has no minimap; no-op */\n  }\n\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.imageSmoothing = enabled;\n    // Apply live to the rendered image layers; baked into the next render too.\n    this.channelView?.setInterpolation(enabled ? 'linear' : 'nearest');\n  }\n\n  setShowStack(_showstack: boolean): void {\n    /* stack navigated via setZIndex */\n  }\n\n  setZIndex(zIndex: number): void {\n    if (this.loaded) this.loaded.z = zIndex;\n    const v = this.viewer;\n    if (!v) return;\n    // Surface: one slice → one mesh, so re-build the height field for the new slice.\n    if (this.surfaceLayer) {\n      void this.buildSurface(v, zIndex).catch((err) =>\n        console.error('[napari-js] setZIndex surface failed:', err),\n      );\n      return;\n    }\n    // Volume / isosurface: step the volume's z plane in place.\n    if (this.volumeView) {\n      v.dims.z = zIndex;\n      this.scheduleReadback();\n      return;\n    }\n    // Tiled 2D image: just move the dims plane — the tiled visual fetches the new slice's tiles\n    // (cached per z), no layer rebuild. Refresh the coarse histogram sample for the new slice.\n    if (this.tiled) {\n      v.dims.z = zIndex;\n      if (this.descriptor) void this.refreshHistogramSamples(zIndex, this.descriptor);\n      this.scheduleReadback();\n      return;\n    }\n    // 2D image (stitch fallback): re-render the slice (re-fetches per-channel / composite). Branch\n    // of a volume layer (not currentPlotType, which could be stale and silently no-op the swap).\n    // The token lets renderImage drop a superseded scrub so a slow older slice can't clobber a newer one.\n    const req = ++this.sliceReq;\n    void this.renderImage(zIndex, req)\n      .then(() => {\n        if (req === this.sliceReq) this.scheduleReadback();\n      })\n      .catch((err) => console.error('[napari-js] setZIndex slice failed:', err));\n  }\n\n  setStackLoading(stackLoading: boolean): void {\n    this.stackLoading$.next(stackLoading);\n  }\n\n  /** Cancel in-flight frame loading: bump the load generation so the volume-assembly / surface\n   *  preload workers stop fetching more frames, and clear the loading flag + progress. */\n  cancelLoading(): void {\n    this.loadToken++;\n    this.stackLoading$.next(false);\n    this.stackLoadingProgress$.next(0);\n  }\n\n  isStackLoading(): Observable<boolean> {\n    return this.stackLoading$.asObservable();\n  }\n\n  getStackLoadingProgress(): Observable<number> {\n    return this.stackLoadingProgress$.asObservable();\n  }\n\n  getTrueImageSize(): { width: number; height: number } | null {\n    return this.imageW > 0 && this.imageH > 0 ? { width: this.imageW, height: this.imageH } : null;\n  }\n\n  getCurrentImage(): Promise<Image | null> {\n    return Promise.resolve(null);\n  }\n\n  getDisplayedPixelData(): PixelData | null {\n    return this.lastPixels;\n  }\n\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    const v = this.viewer;\n    const size = this.getTrueImageSize();\n    if (!v || !size) return null;\n    const r = v.visibleWorldRect();\n    const x = Math.max(0, r.x);\n    const y = Math.max(0, r.y);\n    return {\n      x,\n      y,\n      width: Math.min(size.width, r.x + r.width) - x,\n      height: Math.min(size.height, r.y + r.height) - y,\n    };\n  }\n\n  downloadImage(): void {\n    void this.exportComposite();\n  }\n\n  setPlotType(plotType: PlotType): void {\n    this.currentPlotType = plotType;\n  }\n\n  /** Map a Plotly-style 3D drag mode onto napari-js's camera drag mode. */\n  setSurfaceDragMode(mode: string): void {\n    if (!this.viewer) return;\n    const m = mode === 'pan' ? 'pan' : mode === 'zoom' ? 'zoom' : 'rotate'; // orbit/turntable → rotate\n    this.viewer.setCameraDragMode(m);\n  }\n\n  /** Re-frame the 3D camera on the current 3D layer. A surface mesh sits in the positive octant\n   *  (not centred), so frame it by its own bounds; a volume/isosurface uses its centred box. */\n  resetSurfaceCamera(): void {\n    if (!this.viewer) return;\n    const meshLayer = this.surfaceLayer ?? this.scatter3dLayer;\n    if (meshLayer) {\n      const b = meshLayer.bounds();\n      this.viewer.camera3d.target = b.center;\n      this.viewer.camera3d.distance = Math.max(b.radius * 2.5, 1e-3);\n      this.viewer.requestRender();\n      return;\n    }\n    const d = this.volumeDims;\n    if (d) this.viewer.camera3d.frame(d.width, d.height, d.depth);\n  }\n\n  getAutoscaleEvent(): Observable<unknown> {\n    return this.autoscaleEvent$.asObservable();\n  }\n\n  getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    // The WebGPU napari-js options, offered alongside (not replacing) the OSD/Plotly types.\n    return [\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_IMAGE]!,\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_SCATTER]!,\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_SURFACE]!,\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_SCATTER3D]!,\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_VOLUME]!,\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_ISOSURFACE]!,\n    ];\n  }\n\n  /** The napari 3D decimate factor (1 = full … 8 = ⅛). Read by the toolbar to init the control. */\n  getResolutionScale(): number {\n    return this.resolutionScale;\n  }\n\n  /** Set the decimate factor for the napari 3D types. Takes effect on the next (re)load — the host\n   *  re-plots after calling this, since decimation changes the fetched/assembled data. */\n  setResolutionScale(scale: number): void {\n    this.resolutionScale = Math.max(1, Math.round(scale));\n  }\n\n  getIntensityProfile$(): Observable<IntensityProfile[]> {\n    return this.intensityProfile$.asObservable();\n  }\n\n  renderIntensityInset(_divId: string, _profiles: IntensityProfile[]): void {\n    /* Plotly owns the intensity inset */\n  }\n\n  /** Read the displayed composite into `lastPixels` (the pixel-tools' source) + emit the clamped\n   *  visible region. A fresh PixelData object means cachedImageData() rebuilds automatically. */\n  private async runReadback(): Promise<void> {\n    const v = this.viewer;\n    if (!v) return;\n    try {\n      const px = await v.readDisplayedPixels();\n      if (this.viewer !== v) return;\n      const rect = v.visibleWorldRect(); // capture WITH the pixels (same camera)\n      this.lastPixels = px;\n      this.lastPixelsRect = rect;\n      const size = this.getTrueImageSize();\n      if (size && rect) {\n        const x = Math.max(0, Math.min(size.width, rect.x));\n        const y = Math.max(0, Math.min(size.height, rect.y));\n        const width = Math.max(1, Math.min(size.width - x, rect.width));\n        const height = Math.max(1, Math.min(size.height - y, rect.height));\n        this.viewportChange$.next({ x, y, width, height });\n      }\n    } catch {\n      /* readback unavailable */\n    }\n  }\n\n  private scheduleReadback(): void {\n    if (!this.viewer) return;\n    if (typeof requestAnimationFrame === 'function') requestAnimationFrame(() => void this.runReadback());\n    else setTimeout(() => void this.runReadback(), 0);\n  }\n\n  /** Debounced readback — armed on camera changes so `lastPixels` tracks the current view after a\n   *  pan/zoom settles (and after tiled levels finish loading), which the on-canvas pixel tools\n   *  (wand/brush/SAM) read synchronously. Coalesces rapid changes. */\n  private armReadback(delayMs = 250): void {\n    if (this.readbackTimer != null) clearTimeout(this.readbackTimer);\n    this.readbackTimer = setTimeout(() => {\n      this.readbackTimer = null;\n      void this.runReadback();\n    }, delayMs);\n  }\n\n  // ── IRegionStore + classification colours ──────────────────────────────────\n  // Inherited from BaseStoreVisualizer — pure delegations to the shared\n  // RegionStore / VisualizerStore (identical to the OSD backend).\n\n  // ── Pixel tools: reuse the shared, backend-agnostic tool services with a napari host ───────\n\n  /** Build the coordinate transform + tool hosts for the current viewer (called from plot()). The\n   *  pixel tools read displayed pixels synchronously from the last readback and convert pointer\n   *  coords via the napari camera, exactly mirroring the OSD host. */\n  private buildToolHosts(): void {\n    if (!this.viewer) return;\n    this.coordTransform = new NapariCoordinateTransform(\n      this.viewer,\n      () => !!this.viewer && this.imageW > 0,\n    );\n    const regions = this.regionStore;\n    this.wandHost = {\n      getRegions: () => regions.getRegions(),\n      setRegions: (r) => regions.setRegions(r),\n      getCachedImageData: () => this.cachedImageData(),\n      getActiveFrameIndex: () => this.loaded?.z ?? 0,\n      getOverlayContainer: () => this.host,\n      getCoordinateTransform: () => this.coordTransform as ICoordinateTransform,\n      getFileName: () => this.loaded?.filename,\n      getShapeColor: () => regions.getShapeColor(),\n    };\n    this.eraserHost = {\n      getRegions: () => regions.getRegions(),\n      setRegions: (r) => regions.setRegions(r),\n      invalidateWandRegion: () => this.wandTool.clearActiveRegion(),\n      getOverlayContainer: () => this.host,\n      getCoordinateTransform: () => this.coordTransform as ICoordinateTransform,\n      getCachedImageRatio: () => this.cachedImageData()?.ratios[0] ?? 1,\n    };\n  }\n\n  private zoomBoxHost(): ZoomToBoxToolHost {\n    return {\n      getPlotDiv: () => this.plotDivId,\n      pixelToData: (px, py) => {\n        const rect = this.host?.getBoundingClientRect();\n        if (!this.viewer || !rect) return { x: 0, y: 0 };\n        const [x, y] = this.viewer.canvasToWorld(rect.left + px, rect.top + py);\n        return { x, y };\n      },\n      applyZoomToBox: (coords) => this.applyZoomToBox(coords),\n    };\n  }\n\n  /** Zoom/pan the camera to fit a data-space rectangle `[xMin, xMax, yMax, yMin]`. */\n  private applyZoomToBox(coordinates: number[]): void {\n    const v = this.viewer;\n    if (!v || !this.canvas || coordinates.length < 4) return;\n    const [xMin, xMax, yA, yB] = coordinates;\n    const x0 = Math.min(xMin, xMax);\n    const x1 = Math.max(xMin, xMax);\n    const y0 = Math.min(yA, yB);\n    const y1 = Math.max(yA, yB);\n    const w = Math.max(1, x1 - x0);\n    const h = Math.max(1, y1 - y0);\n    const vw = this.canvas.clientWidth || w;\n    const vh = this.canvas.clientHeight || h;\n    v.camera.center = [(x0 + x1) / 2, (y0 + y1) / 2];\n    v.camera.zoom = Math.min(vw / w, vh / h);\n    v.requestRender();\n  }\n\n  /** Build CachedImageData from the most recent readback (RGBA device pixels → [y][x]=[r,g,b]),\n   *  with ratios/origin mapping image coords ↔ readback pixels. Cached until the readback changes. */\n  private cachedImageData(): CachedImageData | null {\n    const px = this.lastPixels;\n    if (!px || !this.viewer) return null;\n    if (this.cachedImage && this.cachedImageSource === px) return this.cachedImage;\n    const w = px.width;\n    const h = px.height;\n    const data = px.data;\n    const matrix: number[][][] = new Array(h);\n    for (let y = 0; y < h; y++) {\n      const row: number[][] = new Array(w);\n      const base = y * w * 4;\n      for (let x = 0; x < w; x++) {\n        const o = base + x * 4;\n        row[x] = [data[o], data[o + 1], data[o + 2]];\n      }\n      matrix[y] = row;\n    }\n    // Use the rect captured WITH this readback (not the live one) so ratios/origin match the\n    // matrix's camera — otherwise a pan/zoom since the readback mis-scales the traced region.\n    const rect = this.lastPixelsRect ?? this.viewer.visibleWorldRect();\n    this.cachedImage = {\n      frames: [matrix],\n      width: w,\n      height: h,\n      ratios: [rect.width / w, rect.height / h],\n      isGrayscale: false,\n      originX: rect.x,\n      originY: rect.y,\n    };\n    this.cachedImageSource = px;\n    return this.cachedImage;\n  }\n\n  // ── IToolController ────────────────────────────────────────────────────────\n  // Control gating: a tool that ACTIVATES disables the camera controls; deactivation is a no-op\n  // because the host always calls the region overlay's setMode FIRST in each toggle (which sets\n  // the baseline enabled/disabled), so re-enabling here would fight a freshly-activated draw mode.\n  setWandMode(active: boolean, options?: IWandOptions): void {\n    if (!this.viewer) return; // no plot yet → nothing to drive\n    if (!active) {\n      this.wandTool.setMode(false);\n      return;\n    }\n    this.viewer?.setControlsEnabled(false);\n    this.cachedImageSource = null;\n    this.armReadback(0);\n    if (this.wandHost) this.wandTool.bindHost(this.wandHost);\n    this.wandTool.setMode(true, (options ?? {}) as unknown as WandOptions);\n  }\n  setWandOptions(options: IWandOptions): void {\n    this.wandTool.setOptions((options ?? {}) as unknown as WandOptions);\n  }\n  clearActiveWandRegion(): void {\n    this.wandTool.clearActiveRegion();\n  }\n  setBrushMode(active: boolean, options?: IBrushOptions): void {\n    if (!this.viewer) return;\n    if (!active) {\n      this.brushTool.setMode(false);\n      return;\n    }\n    this.viewer?.setControlsEnabled(false);\n    this.cachedImageSource = null;\n    this.armReadback(0);\n    if (this.wandHost) this.brushTool.bindHost(this.wandHost);\n    this.brushTool.setMode(true, (options ?? {}) as unknown as BrushOptions);\n  }\n  setBrushOptions(options: IBrushOptions): void {\n    if (options?.size != null) this.brushTool.setSize(options.size);\n  }\n  setVertexEraserMode(active: boolean): void {\n    if (!this.viewer) return;\n    if (active) {\n      this.viewer?.setControlsEnabled(false);\n      this.cachedImageSource = null;\n      if (this.eraserHost) this.eraserTool.bindHost(this.eraserHost);\n    }\n    this.eraserTool.setMode(active);\n  }\n  setVertexEraserRadius(radius: number): void {\n    this.eraserTool.setRadius(radius);\n  }\n  setZoomToBoxMode(active: boolean): void {\n    if (!this.viewer) return;\n    if (active) {\n      this.viewer?.setControlsEnabled(false);\n      this.zoomToBoxTool.bindHost(this.zoomBoxHost());\n    }\n    this.zoomToBoxTool.setMode(active);\n  }\n  // SAM / cellpose — server round-trips that read the drawn rectangles + displayed pixels through\n  // the same wand host (rectangles from the RegionStore, image from the readback).\n  async segmentRectangles(): Promise<number> {\n    if (!this.viewer || !this.wandHost) return 0;\n    await this.runReadback(); // the SAM embedding samples the currently-displayed image\n    this.cachedImageSource = null;\n    this.samTool.bindHost(this.wandHost);\n    return this.samTool.segmentBoxes();\n  }\n  async segmentRectanglesCellpose(): Promise<number> {\n    if (!this.viewer || !this.wandHost || !this.cellSegmenter) return 0;\n    await this.runReadback();\n    this.cachedImageSource = null;\n    this.cellSegmentTool.bindHost(this.wandHost);\n    return this.cellSegmentTool.segmentBoxes(this.cellSegmenter);\n  }\n  setSamModel(id: string): void {\n    this.samTool.setModel(id);\n    this.samPointTool.setModel(id);\n  }\n  setSamPointMode(active: boolean): void {\n    if (!this.viewer) return;\n    if (active) {\n      this.viewer?.setControlsEnabled(false);\n      this.cachedImageSource = null;\n      this.armReadback(0); // refresh the readback the click's embedding will sample\n      if (this.wandHost) this.samPointTool.bindHost(this.wandHost);\n    }\n    this.samPointTool.setMode(active);\n  }\n  commitSamPoints(): void {\n    this.samPointTool.commit();\n  }\n  clearSamPoints(): void {\n    this.samPointTool.clear();\n  }\n\n  // ── IDisplayOptions ───────────────────────────────────────────────────────\n  // Inherited from BaseStoreVisualizer — pure delegations to the shared\n  // VisualizerStore (identical to the OSD backend).\n\n  // ── IIntensitySampling: Plotly owns sampling; emit viewport changes ───────\n  ensureIntensitySampling(_imageInfo: IImageInfo, _zIndex: number): Promise<void> {\n    return Promise.resolve();\n  }\n  refreshIntensitySamplingForRoi(\n    _x: number,\n    _y: number,\n    _width: number,\n    _height: number,\n    _zIndex: number,\n  ): void {}\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return this.viewportChange$.asObservable();\n  }\n\n  // ── IVisualizer composite members ─────────────────────────────────────────\n  getRegionOverlay(): IRegionOverlay | null {\n    return this.regionOverlay;\n  }\n  getIsosurfaceControls(): IIsosurfaceControls | null {\n    if (!this.volumeView) return null;\n    return {\n      setIsoRange: (isoMin: number, isoMax: number): void => {\n        // Apply to every channel's volume layer.\n        for (const layer of this.volumeView?.layers ?? []) {\n          layer.contrastLimits = [isoMin, isoMax];\n          layer.rendering = 'iso';\n          layer.isoThreshold = 0.5;\n        }\n        this.viewer?.requestRender();\n      },\n    };\n  }\n  getIntensityControls(): IIntensityControls | null {\n    return null;\n  }\n  getSurface3dControls(): ISurface3dControls | null {\n    if (!this.volumeView && !this.surfaceLayer && !this.scatter3dLayer) return null;\n    return {\n      setSurfaceDragMode: (mode: string): void => this.setSurfaceDragMode(mode),\n      resetSurfaceCamera: (): void => this.resetSurfaceCamera(),\n      setAxesVisible: (visible: boolean): void => {\n        this.axesVisible = visible;\n        this.axesLabels?.setVisible(visible);\n        if (this.axesLayer) {\n          this.axesLayer.visible = visible;\n          this.viewer?.requestRender();\n        }\n      },\n      axesVisible: (): boolean => this.axesVisible,\n      // Surface wireframe (napari-js surface only) — a live layer property, no rebuild needed.\n      setWireframe: (on: boolean): void => {\n        this.surfaceWireframe = on;\n        if (this.surfaceLayer) {\n          this.surfaceLayer.wireframe = on;\n          this.viewer?.requestRender();\n        }\n      },\n      wireframe: (): boolean => this.surfaceWireframe,\n    };\n  }\n  getHistogram(channelIndex: number, bins: number): IHistogram | null {\n    const v = this.viewer;\n    if (!v) return null;\n    // Volume / isosurface: intensity histogram of the assembled (downsampled) uint8 volume for the\n    // requested channel (multichannel) or the single grayscale volume (key 0).\n    if (this.volumeChannelData.size) {\n      const data = this.volumeChannelData.get(channelIndex) ?? this.volumeChannelData.get(0);\n      return data ? this.toIHistogram(histogramScalar(data, bins, 0, 255)) : null;\n    }\n    // Tiled mode has no full in-memory pixels → use the coarse per-channel sample (RGB: readback).\n    if (this.tiled) {\n      if (this.imageMode === 'rgb') return this.rgbHistogram(channelIndex, bins);\n      const sample = this.histSamples.get(this.imageMode === 'grayscale' ? 0 : channelIndex);\n      return sample ? this.toIHistogram(histogramScalar(sample, bins, 0, 255)) : null;\n    }\n    // Grayscale/multichannel (stitch): native per-channel histogram straight from the in-memory\n    // scalar layer (no GPU readback). RGB: bin the displayed pixels' R/G/B byte (8-bit client path).\n    const layer = this.channelView?.layers[this.imageMode === 'grayscale' ? 0 : channelIndex];\n    if (layer) {\n      const h = v.layerHistogram(layer, bins);\n      if (h) return this.toIHistogram(h);\n    }\n    if (this.imageMode === 'rgb') return this.rgbHistogram(channelIndex, bins);\n    return null;\n  }\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    // >8-bit channels: fetch the true native distribution from the server (the displayed pixels\n    // are 8-bit, so the client histogram would be clipped). 8-bit channels use the client path.\n    const bitDepth = this.descriptor?.channelInfo?.[channelIndex]?.bitDepth ?? 8;\n    if (bitDepth > 8) {\n      const z = this.loaded?.z ?? 0;\n      const key = `${z}|${channelIndex}`;\n      const cached = this.nativeHistograms.get(key);\n      if (cached) return of(cached);\n      return from(this.fetchNativeHistogram(channelIndex, bins, z, key));\n    }\n    return of(this.getHistogram(channelIndex, bins));\n  }\n\n  /** Fetch + cache one channel's native-bit-depth histogram from `GET /histogram` (>8-bit). */\n  private async fetchNativeHistogram(\n    channel: number,\n    bins: number,\n    z: number,\n    key: string,\n  ): Promise<IHistogram | null> {\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) return null;\n    const headers = await this.tiles\n      .getAuthHeaders()\n      .catch(() => ({}) as Record<string, string>);\n    const url = `${this.api}histogram?info=${infoB64}&channel=${channel}&z=${z}&bins=${bins}`;\n    try {\n      const resp = await fetch(url, { headers });\n      if (!resp.ok) return null; // 202 (still caching) or transient → null; the pane retries\n      const hi = (await resp.json()) as {\n        bitDepth: number;\n        rangeMin: number;\n        rangeMax: number;\n        observedMin: number;\n        observedMax: number;\n        binWidth: number;\n        counts: number[];\n      };\n      if (!hi?.counts) return null;\n      const out: IHistogram = {\n        bins: hi.counts.map((_, i) => hi.rangeMin + i * hi.binWidth),\n        counts: hi.counts,\n        max: hi.counts.reduce((m, c) => (c > m ? c : m), 0),\n        bitDepth: hi.bitDepth,\n        rangeMin: hi.rangeMin,\n        rangeMax: hi.rangeMax,\n        observedMin: hi.observedMin,\n        observedMax: hi.observedMax,\n      };\n      this.nativeHistograms.set(key, out);\n      return out;\n    } catch (err) {\n      console.warn('[napari-js] native histogram fetch failed', err);\n      return null;\n    }\n  }\n\n  /** Per-channel histogram of the displayed RGB composite (R/G/B byte), from the last readback. */\n  private rgbHistogram(channelIndex: number, bins: number): IHistogram | null {\n    const px = this.lastPixels;\n    if (!px) return null;\n    const band = Math.max(0, Math.min(2, channelIndex));\n    const n = Math.max(1, Math.min(256, Math.floor(bins) || 256));\n    const counts = new Array(n).fill(0);\n    const data = px.data;\n    for (let i = 0; i < data.length; i += 4) {\n      if (data[i + 3] === 0) continue; // skip transparent padding\n      counts[Math.min(n - 1, (data[i + band] * n) >> 8)]++;\n    }\n    const binsArr = Array.from({ length: n }, (_, i) => (i * 256) / n);\n    return { bins: binsArr, counts, max: counts.reduce((m, c) => (c > m ? c : m), 0) };\n  }\n  exportComposite(): void {\n    const v = this.viewer;\n    if (!v) return;\n    void v.screenshot().then((blob) => {\n      const url = URL.createObjectURL(blob);\n      const a = document.createElement('a');\n      a.href = url;\n      a.download = 'napari-js.png';\n      a.click();\n      URL.revokeObjectURL(url);\n    });\n  }\n  /** Native-bit-depth (16/32-bit) multi-band TIFF export via the server `/export/tiff` endpoint —\n   *  the displayed PNG is an 8-bit figure, this preserves the true pixel values. Visible channels\n   *  only (omitted when all are visible → server default). Mirrors the OSD backend. */\n  async exportData(): Promise<void> {\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) return;\n    const states = this.store.currentChannelStates();\n    const visible = states.filter((c) => c.visible).map((c) => c.index);\n    const chParam =\n      visible.length && visible.length < states.length ? `&channels=${visible.join(',')}` : '';\n    const z = this.loaded?.z ?? 0;\n    const url = `${this.api}export/tiff?info=${infoB64}&z=${z}${chParam}`;\n    const stem = (this.loaded?.filename || 'image').replace(/\\.[^.]+$/, '');\n    const headers = await this.tiles\n      .getAuthHeaders()\n      .catch(() => ({}) as Record<string, string>);\n    try {\n      const resp = await fetch(url, { headers });\n      if (resp.status === 202) {\n        console.warn('[napari-js] 16-bit export: file still caching — try again shortly.');\n        return;\n      }\n      if (!resp.ok) throw new Error(`status ${resp.status}`);\n      saveAs(await resp.blob(), `${stem}_16bit.ome.tif`);\n    } catch (err) {\n      console.warn('[napari-js] 16-bit TIFF export failed', err);\n    }\n  }\n  unsubscribe(): void {\n    this.reset();\n  }\n}\n"]}
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [SPATIAL_DATA_PORT]
+                }] }, { type: i11.SpatialSelectionStore }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-visualizer.service.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-visualizer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport {\n  Observable, BehaviorSubject, Subject, Subscription, combineLatest, from, of, firstValueFrom,\n} from 'rxjs';\nimport { Image } from 'image-js';\nimport { saveAs } from 'file-saver';\nimport {\n  Viewer,\n  histogramScalar,\n  colormapFromLut,\n  tintColormap,\n  reverseColormap,\n  heightField,\n  LUT_SIZE,\n  MultiChannelImageView,\n  MultiChannelVolumeView,\n} from 'napari-js';\nimport type {\n  AxesLayer,\n  ImageLayer,\n  SurfaceLayer,\n  VolumeLayer,\n  PointsLayer,\n  Points3DLayer,\n  TiledSource,\n  TileKey,\n  PixelChunk,\n  ChannelView,\n  VolumeChannel,\n  Colormap,\n  ProjectedPoints,\n} from 'napari-js';\nimport { nearestProjectedIndex, ScreenIndex, SCREEN_INDEX_MIN_POINTS } from 'napari-js';\n\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { IChannelState } from '../../contracts/channel-histogram-api.contract';\nimport { buildColormapLut, Rgb } from '../../contracts/colormap-lut';\nimport { SPATIAL_DATA_PORT, SpatialDataPort } from '../../contracts/ports/spatial-data.port';\nimport {\n  SpatialColumn, SpatialDataset, SpatialImageRef, findColumnMeta, isCategoricalColumn,\n} from '../../contracts/spatial-dataset.contract';\nimport { SpatialViewState } from '../../contracts/display-types';\nimport {\n  contrastWindow, encodeCategorical, encodeContinuous, markerDiameters,\n  resolveCategoryColors, toRgbaTuples, parseHex, MISSING_COLOR, DEFAULT_MUTED_OPACITY,\n  SPATIAL_3D_MAX_CATEGORIES, spatialContinuousLut,\n} from '../../spatial/spatial-encoding';\nimport { NO_CATEGORY } from '../../contracts/spatial-dataset.contract';\nimport { SpatialObservations } from '../../contracts/spatial-dataset.contract';\nimport {\n  SpatialSelectionMask, emptySelection, maskToIndices, mutedFromSelection, sameSelection,\n  selectByCategory,\n} from '../../spatial/spatial-selection';\nimport { framePositions } from '../../spatial/spatial-framing';\nimport { PIXEL_WORLD_QUANTUM, worldQuantumForExtent } from '../../spatial/world-grid';\nimport { observationsInSlice, volumeImageRef } from '../../spatial/spatial-volume-image';\nimport { defaultSigma, densityGrid, rasterizeDensity } from '../../spatial/spatial-density';\nimport { observationsInSection, sectionsOf } from '../../spatial/spatial-sections';\nimport { type HoverSource, hoverText, nearestObservation } from '../../spatial/spatial-hover';\nimport { NapariSpatialTooltip } from './napari-spatial-tooltip';\nimport { NAPARI_WHEEL_ZOOM_SPEED } from './napari-zoom';\n\n/**\n * A short, stable id for a colormap value, for cache keys.\n *\n * Half the library's colormaps are NAMES and half are inline `[stop, colour]`\n * arrays of 256 entries. Stringifying the array kind would put 6 KB in a key that\n * is rebuilt and compared on every view change; hashing it keeps the key small,\n * and it only has to distinguish one colormap from another.\n */\nfunction colormapId(value: unknown): string {\n  if (value == null) return '';\n  if (typeof value === 'string') return value;\n  if (!Array.isArray(value)) return '?';\n  // FNV-1a over the stops. A collision would leave a stale colouring on screen,\n  // not corrupt anything, and 32 bits over a few hundred colormaps will not.\n  let hash = 0x811c9dc5;\n  const text = value.map((stop) => String(stop)).join(',');\n  for (let i = 0; i < text.length; i++) {\n    hash ^= text.charCodeAt(i);\n    hash = Math.imul(hash, 0x01000193);\n  }\n  return `#${(hash >>> 0).toString(36)}`;\n}\n\n/**\n * In-plane coarsening of the 3D gene map's lattice, relative to the reference\n * volume. The field is smooth, so its detail is set by the kernel rather than the\n * raster — and the estimate is a pair of separable blurs on the main thread, which\n * at the template's full resolution means seconds of frozen UI per toggle.\n */\nconst GENE_MAP_VOLUME_STRIDE = 2;\nimport {\n  type ExpressionField, type ExpressionVolumeField, colorExpressionField,\n  encodeExpressionVolume, expressionField, expressionVolume,\n} from '../../spatial/spatial-expression';\nimport { SpatialSelectionStore } from '../../store/spatial-selection.service';\nimport {\n  PlotType,\n  PlotTypeDescriptor,\n  PLOT_TYPE_DESCRIPTORS,\n  isNapari3d,\n  isNapariIsosurface,\n  isNapariSurface,\n  isNapariScatter,\n  isNapariScatter3d,\n  isSpatialOmics,\n  isSpatialOmics3d,\n  NAPARI_DEFAULT_DECIMATE,\n} from '../../contracts/plot-type';\nimport {\n  IVisualizer,\n  PixelData,\n  IntensityProfile,\n  IIsosurfaceControls,\n  IIntensityControls,\n  ISurface3dControls,\n} from '../../contracts/visualizer.contract';\nimport {\n  ViewerCapabilities,\n  ViewerFeature,\n  capabilitiesOf,\n} from '../../contracts/capabilities.contract';\nimport { IRegionOverlay } from '../../contracts/region-overlay.contract';\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { ColormapNode, IWandOptions, IBrushOptions } from '../../contracts/display-types';\nimport { VIZ_CONFIG, VizConfig } from '../../contracts/viz-config';\nimport { TILE_ACCESS_PORT, TileAccessPort } from '../../contracts/ports/tile-access.port';\nimport { BaseStoreVisualizer } from '../base-store-visualizer';\nimport { SimpleSliceAccessService } from '../simple-slice-access.service';\nimport { VisualizerStore } from '../../store/visualizer-store.service';\nimport { RegionStore } from '../../store/region-store.service';\nimport { NapariScaleBar, ScaleBarCamera, formatUm } from './napari-scale-bar';\nimport { NapariRegionOverlay, OverlayViewer } from './napari-region-overlay';\nimport { NapariAxesLabels, AxisLabelSpec } from './napari-axes-labels';\nimport { NapariVolumeZHandle } from './napari-volume-z-handle';\nimport {\n  ICoordinateTransform,\n} from '../../contracts/coordinate-transform.contract';\nimport { WandToolService, WandToolHost, CachedImageData } from '../../toolbar/wand/wand-tool.service';\nimport { WandOptions } from '../../toolbar/wand/wand.service';\nimport { BrushToolService, BrushOptions } from '../../toolbar/brush/brush-tool.service';\nimport {\n  VertexEraserToolService,\n  VertexEraserToolHost,\n} from '../../toolbar/vertex-eraser/vertex-eraser-tool.service';\nimport {\n  ZoomToBoxToolService,\n  ZoomToBoxToolHost,\n} from '../../toolbar/zoom-to-box/zoom-to-box-tool.service';\nimport { SamToolService } from '../../toolbar/segmentation/sam-tool.service';\nimport { SamPointToolService } from '../../toolbar/segmentation/sam-point-tool.service';\nimport { CellSegmentToolService } from '../../toolbar/segmentation/cell-segment-tool.service';\nimport { ICellSegmenter, CELL_SEGMENTER } from '../../contracts/cell-segmenter.contract';\n\n/** ICoordinateTransform over the napari camera: pointer client coords ↔ image/world coords. */\nclass NapariCoordinateTransform implements ICoordinateTransform {\n  constructor(\n    private readonly viewer: {\n      canvasToWorld(clientX: number, clientY: number): [number, number];\n      readonly camera: { zoom: number };\n    },\n    private readonly ready: () => boolean,\n  ) {}\n  clientToData(clientX: number, clientY: number): { x: number; y: number } {\n    const [x, y] = this.viewer.canvasToWorld(clientX, clientY);\n    return { x, y };\n  }\n  dataLengthToScreen(dataLength: number): number {\n    return dataLength * this.viewer.camera.zoom; // CSS px per world unit\n  }\n  isReady(): boolean {\n    return this.ready();\n  }\n}\n\n/** Opaque handle from {@link NapariVisualizerService.load}, passed back to plot(). */\ninterface NapariLoaded {\n  imageInfo: IImageInfo;\n  z: number;\n  /** Must match `IImageInfo.fileName` — the render orchestrator drops the result if the\n   *  handle's `filename` doesn't match the requested image (guards against stale clicks). */\n  filename: string;\n}\n\nconst VOLUME_MAX_SLICE = 1024; // \"Full\" in-plane cap; the default ¼ load uses 256\n/** Reference in-plane world size (long side) for the volume/axes box, in arbitrary world units.\n *  The box is anchored to this reference regardless of the chosen decimate factor, so changing the\n *  resolution changes DETAIL, not the volume's proportions (Z no longer appears to shrink when the\n *  in-plane sampling grows). Set to the DEFAULT decimate's in-plane cap so the default view is\n *  unchanged; higher/lower resolutions keep that same shape. See {@link mountVolume}. */\nconst VOLUME_WORLD_INPLANE_REF = VOLUME_MAX_SLICE / NAPARI_DEFAULT_DECIMATE;\n/** Max concurrent slice fetches when assembling a volume — keeps the connection pool busy\n *  without flooding it (browsers cap ~6/host) on a deep stack. */\nconst VOLUME_FETCH_CONCURRENCY = 8;\n\n/** Volume/isosurface sampling for a decimate factor `scale` (1 = Full 1024, 2 = ½ 512, 4 = ¼ 256\n *  default, 8 = ⅛ 128): the in-plane cap halves each step; slices stay un-subsampled until ⅛, then\n *  subsample. */\nfunction volumeResolutionFor(scale: number): { maxSlice: number; sliceStep: number } {\n  const s = Math.max(1, Math.round(scale));\n  return {\n    maxSlice: Math.max(8, Math.round(VOLUME_MAX_SLICE / s)),\n    sliceStep: Math.max(1, Math.floor(s / 4)),\n  };\n}\n/** Fully-normalized intensity height as a fraction of the in-plane extent — matches the Plotly\n *  SURFACE z-aspect (~0.4) so the relief isn't exaggerated. */\nconst SURFACE_Z_ASPECT = 0.4;\n/** \"Full\" mesh grid cap; the decimate factor divides it (default ¼ → 220, ½ → 440, Full → 880). */\nconst SURFACE_MAX_GRID = 880;\n/** Coefficient scaling the pyramid tile budget with the target resolution — a higher target pulls a\n *  finer pyramid level (more real detail). Shared by the surface plane fetch + volume assembly. */\nconst STITCH_BUDGET_COEFF = 16;\n/** Surface mesh target grid for a decimate factor `scale`: the grid cap shrinks by `scale` (every\n *  slice is kept — the z-slider needs them all). The source is fetched at a matching resolution. */\nfunction surfaceResolutionFor(scale: number): { maxGrid: number } {\n  const s = Math.max(1, Math.round(scale));\n  return { maxGrid: Math.max(16, Math.round(SURFACE_MAX_GRID / s)) };\n}\n\n/** 3D scatter: in-plane cap for the assembled voxel grid, and the max number of points emitted\n *  (the grid is flat-strided down to this) — keeps the billboard count interactive. */\nconst SCATTER3D_MAX_XY = 64;\nconst SCATTER3D_MAX_POINTS = 150000;\n\nconst TILE_SIZE = 512; // server tile edge (matches the OSD backend)\n/** Max tiles stitched for one displayed slice (512px tiles → up to ~6144² at full res). Beyond\n *  this we step to a coarser pyramid level so a large image stays tractable. */\nconst MAX_STITCH_TILES = 144;\n/** WebGPU default `maxTextureDimension2D` — a stitched slice's longest side must fit a texture. */\nconst MAX_TEXTURE_DIM = 8192;\n/** Concurrent tile requests per stitched slice. Firing a whole grid at once (hundreds of requests\n *  for a large level) overwhelmed the tile server (504s); a small pool keeps the pipe full without\n *  flooding it — and slice-level workers already run several stitches in parallel on top of this. */\nconst TILE_FETCH_CONCURRENCY = 6;\n/** How long to poll `/tiles/info` (202 while the server caches the source) before falling back to\n *  a single tile. Generous like the OSD backend — a cold whole-slide can take minutes to cache. */\nconst DESCRIPTOR_TIMEOUT_MS = 120000;\n\n/** Default per-channel tints (Fiji-style) when the store/descriptor offers no colour. */\nconst DEFAULT_TINTS = ['#ff0000', '#00ff00', '#0000ff', '#ffff00', '#ff00ff', '#00ffff', '#ffffff'];\n\n/** Default tint for a channel index, cycling the Fiji palette. */\nfunction tintFor(channel: number): string {\n  return DEFAULT_TINTS[channel % DEFAULT_TINTS.length];\n}\n\n/** One pyramid level from `GET /tiles/info` (res 0 = full resolution). */\ninterface TileLevel {\n  res: number;\n  width: number;\n  height: number;\n}\n\n/** Subset of the `/tiles/info` descriptor this backend reads (tile grid, channels, scale). */\ninterface TileDescriptor {\n  width: number;\n  height: number;\n  tileSize: number;\n  z: number;\n  channels: number;\n  multichannel?: boolean;\n  /** Real Bio-Formats levels at the front of `levels`; per-channel tiles exist only there. */\n  realLevels?: number;\n  channelInfo?: Array<{\n    name?: string;\n    color?: string;\n    bitDepth?: number;\n    minAllowed?: number;\n    maxAllowed?: number;\n  }> | null;\n  levels: TileLevel[];\n  mppX?: number;\n  mppY?: number;\n}\n\n/**\n * A WebGPU image backend built on the published `napari-js` library — the POC engine for\n * jit-ui#102 (a browser-based napari shipped as a JS library, swapping image plotting with\n * OpenSeadragon and 3D slicing/isosurfaces with Plotly).\n *\n * Render strategy: rather than re-implement the server's tile/pyramid protocol (which OSD\n * already handles), this backend renders the **complete per-slice image URLs the app already\n * produces** (`IImageInfo.urls`) — `urls[z]` for the 2D image, and the full `urls` stack\n * assembled into a downsampled volume for the 3D types. Region state and display options\n * delegate to the shared {@link RegionStore} / {@link VisualizerStore}, exactly as OSD does.\n *\n * Follow-ups (jit-ui#102): native-resolution pyramidal tiling, on-canvas tools, region\n * overlay rendering, per-channel histograms, TIFF export.\n */\n/**\n * What the 3D points layer needs to colour a cloud: one scalar per point, a colormap, and the\n * window that maps scalars onto it. Categorical and continuous colourings both reduce to this,\n * because the layer offers no per-point colour channel.\n */\ninterface Spatial3dEncoding {\n  values: Float32Array;\n  colormap: Colormap;\n  contrastLimits: [number, number];\n}\n\n@Injectable({ providedIn: 'root' })\nexport class NapariVisualizerService extends BaseStoreVisualizer implements IVisualizer {\n  readonly capabilities: ViewerCapabilities = capabilitiesOf([\n    ViewerFeature.ImageDisplay,\n    ViewerFeature.StackSlider,\n    ViewerFeature.PixelReadback,\n    ViewerFeature.Surface3D,\n    ViewerFeature.Isosurface,\n  ]);\n\n  private readonly api: string;\n\n  private viewer: Viewer | null = null;\n  private canvas: HTMLCanvasElement | null = null;\n  private host: HTMLElement | null = null;\n  private loaded: NapariLoaded | null = null;\n  private lastPixels: PixelData | null = null;\n  private currentPlotType: PlotType = PlotType.NAPARI_IMAGE;\n  /** napari-js high-level view owning the 3D volume layers (one additive tinted layer per channel\n   *  for multichannel, or a single grayscale volume). Null in 2D. */\n  private volumeView: MultiChannelVolumeView | null = null;\n  /** True when the volume is composited from per-channel layers (vs a single grayscale volume). */\n  private volumeMultichannel = false;\n  /** napari-js height-field surface mesh (NAPARI_SURFACE plot type; null otherwise). Built from a\n   *  single grayscale slice by {@link buildSurface} via napari-js's `heightField` + `addSurface`. */\n  private surfaceLayer: SurfaceLayer | null = null;\n  /** Which band the surface samples (a channel index for multichannel, else the composite). */\n  private surfaceChannel: number | undefined = undefined;\n  /** True when the mounted Surface follows one band of a multichannel image. */\n  private surfaceMultichannel = false;\n  /** Pre-loaded per-slice luminance planes (already decimated to the surface grid), keyed by z,\n   *  so the stack slider rebuilds the surface instantly. Filled by {@link preloadSurfacePlanes}. */\n  private readonly surfacePlanes = new Map<\n    number,\n    { data: Uint8Array; width: number; height: number }\n  >();\n  /** In-plane grid cap for the active surface load (full grid ÷ the decimate factor). */\n  private surfaceMaxGrid = SURFACE_MAX_GRID;\n  /** Contrast window [min,max] the current surface mesh was built with. A change reshapes the\n   *  mesh (pixel height = intensity within [min,max]), so it triggers a geometry rebuild. */\n  private surfaceWindow: [number, number] | null = null;\n  /** Persisted wireframe choice for the surface (re-applied when a new surface mounts). */\n  private surfaceWireframe = false;\n  /** napari-js 2D scatter points (region centroids) + its region-change subscription. */\n  private scatter2dPoints: PointsLayer | null = null;\n  private scatterRegionSub: Subscription | null = null;\n  /** napari-js 3D scatter (voxel point cloud). */\n  private scatter3dLayer: Points3DLayer | null = null;\n  /** Spatial-omics observation markers + the dataset/view subscription driving them. */\n  private spatialPoints: PointsLayer | null = null;\n  /** The 3D point cloud. One layer: selection is a per-point alpha on it, not a second. */\n  private spatialPoints3d: Points3DLayer | null = null;\n  private spatialLayerKey3d: string | null = null;\n  /** Interleaved x,y,z, cached so a colour change does not re-walk 3.7M observations. */\n  private spatialPositions3d: Float32Array | null = null;\n  /** Identity of the scalars currently uploaded — see {@link rebuildSpatialPoints3d}. */\n  private spatialScalarKey3d: string | null = null;\n  /** The anatomical volume the cloud sits inside, when the dataset has one. */\n  private spatialVolume: VolumeLayer | null = null;\n  private spatialVolumeKey: string | null = null;\n  /** Per-cluster density volumes drawn alongside the cloud, and what they were\n   *  built from — rasterising is seconds of work, so it must not repeat for a\n   *  change that cannot affect the field. */\n  private densityLayers: VolumeLayer[] = [];\n  private densityKey: string | null = null;\n  /** Selection identity, as a number the density key can carry. */\n  private lastSelectionSeen: SpatialSelectionMask | null = null;\n  private selectionRevision = 0;\n  /** The gene map: its layer, the field it was estimated from, and the inputs each\n   *  was built for — the field is the expensive half and survives a recolour. */\n  private geneMapLayer: ImageLayer | null = null;\n  private geneMapKey: string | null = null;\n  private geneMapField: ExpressionField | null = null;\n  private geneMapFieldKey: string | null = null;\n  /** The 3D gene map: its volume layer, the field behind it, and the inputs each\n   *  was built for — same two clocks as the 2D map. */\n  private geneMapVolumeLayer: VolumeLayer | null = null;\n  private geneMapVolumeKey: string | null = null;\n  private geneMapVolumeField: ExpressionVolumeField | null = null;\n  private geneMapVolumeFieldKey: string | null = null;\n  /** Offset applied to observation coordinates to sit them in the volume's box. */\n  private spatialOrigin3d: [number, number, number] = [0, 0, 0];\n  /** Cursor tooltip for the spatial views, and everything it needs: what the\n   *  cloud is coloured by, and where each drawn observation is. */\n  private spatialTooltip: NapariSpatialTooltip | null = null;\n  private hoverSource: HoverSource | null = null;\n  private hoverSourceKey: string | null = null;\n  /** Sequences the async resolutions. The KEY is only committed once one lands,\n   *  so a superseded fetch cannot leave the cache claiming to hold a source it\n   *  never stored. */\n  private hoverSourceToken = 0;\n  /** Drawn observations' positions for hit-testing, indexed BY OBSERVATION with\n   *  NaN for anything not drawn. Screen pixels in 3D (the camera moves them, so\n   *  they are rebuilt when it does) and WORLD units in 2D (where the camera only\n   *  scales, so the pointer is converted instead of 374k points). */\n  private hoverPositions: Float32Array | null = null;\n  private hoverPositionsRev = -1;\n\n  /**\n   * Screen-space bucket index over the 3D projection, built on the first hover after the\n   * scene moved rather than when it moves.\n   *\n   * Lazily, and that is the whole design: an orbit drag changes the camera every frame, so\n   * building eagerly would spend tens of milliseconds a frame indexing for picks nobody is\n   * making. Deferred, it is built once when the drag stops and the pointer next moves —\n   * measured upstream at 3.7M points, that turns a 12.6 ms scan per pointermove into\n   * 0.066 ms.\n   */\n  private hoverIndex: ScreenIndex | null = null;\n  /** Bumped whenever the cached positions go stale: a marker rebuild, or — in 3D\n   *  only, where the projection depends on it — a camera move. */\n  private spatialSceneRev = 0;\n  private hoverPointer: { x: number; y: number; clientX: number; clientY: number } | null = null;\n  private hoverFrame = 0;\n  private hoverOff: (() => void)[] = [];\n  /** Observation indices the cached 3D positions belong to, in the same order;\n   *  null when every observation is drawn. Without it a projection built from the\n   *  positions is indexed by DRAWN order and silently attributes each point to\n   *  the wrong observation as soon as a section is isolated. */\n  private spatialDrawn3d: Uint32Array | null = null;\n\n  /** Reused projection buffers — see {@link getSpatialScreenProjection}. */\n  private spatialProjection3d: ProjectedPoints | undefined = undefined;\n\n  /** Per-observation depth from the last projection, for the depth-aware hover pick. */\n  private spatialDepths3d: Float32Array | null = null;\n  /** The (viewer, dataset) whose 3D scene has already had its opening framing. */\n  /** Whose 2D observations the camera has been framed on — see {@link frameSpatialPointsOnce}. */\n  private spatial2dFramed: { viewer: Viewer; datasetId: string } | null = null;\n  /** Dataset the 3D scale bar was built for. */\n  private spatialScaleBarKey: string | null = null;\n  private spatialSub: Subscription | null = null;\n  /** Latest (dataset, view, selection) the spatial subscription saw, so a slice\n   *  change can rebuild the markers for the new plane. */\n  private spatialLatest: [SpatialDataset | null, SpatialViewState, SpatialSelectionMask] | null =\n    null;\n  /** Which dataset the current marker layer was built for, so a display-only\n   *  change (size, colour, opacity, selection) can update it in place. */\n  private spatialLayerKey: string | null = null;\n  /** Monotonic guard for the async colour rebuild: fetching a gene vector is a\n   *  round-trip, so a fast sequence of colour-by changes can resolve out of\n   *  order. Only the newest rebuild is allowed to touch the layer. */\n  private spatialRebuildToken = 0;\n  /** Monotonic load generation. Bumped by {@link reset} and {@link cancelLoading}; the frame-loading\n   *  loops (volume assembly, surface preload) capture it and bail when it changes, so a Cancel (or a\n   *  new plot) actually stops fetching frames instead of running to completion in the background. */\n  private loadToken = 0;\n  /** Decimate factor for the napari 3D types (1 = Full, 2 = ½ default, 4 = ¼, 8 = ⅛). Applied when a\n   *  volume/isosurface/surface (re)loads; changing it needs a re-plot (it changes fetched data). */\n  private resolutionScale = NAPARI_DEFAULT_DECIMATE;\n  /** 3D coordinate-axes / scale gizmo for the volume/isosurface view (null in 2D). */\n  private axesLayer: AxesLayer | null = null;\n  /** DOM X/Y/Z + scale labels tracking the 3D axes gizmo (null in 2D). */\n  private axesLabels: NapariAxesLabels | null = null;\n  /** Draggable Z-height grip over the volume (null unless a volume/isosurface is mounted). */\n  private zHandle: NapariVolumeZHandle | null = null;\n  /** User Z-height factor for the volume (1 = the volume's natural proportions); driven by the\n   *  in-view drag handle. Reset per mount. */\n  private volumeZScale = 1;\n  /** Volume world box at `volumeZScale = 1` (base) + the sampled voxel depth — enough to recompute\n   *  the Z-axis voxel scale, axes depth, and overlay anchors as the handle stretches Z. */\n  private volumeWorldBase: { width: number; height: number; depth: number } | null = null;\n  private volumeSampledDepth = 1;\n  /** Persisted axes on/off choice, re-applied when a new volume mounts. Defaults on. */\n  private axesVisible = true;\n  private volumeDims: { width: number; height: number; depth: number } | null = null;\n  /** Assembled uint8 volume data per channel (key = channel index), kept for the volume intensity\n   *  histogram. Key 0 holds the grayscale/composite volume in the single-channel case. */\n  private readonly volumeChannelData = new Map<number, Uint8Array>();\n  private imageW = 0;\n  private imageH = 0;\n  /** Monotonic slice-request id so a slow out-of-order slice fetch can't clobber a newer one. */\n  private sliceReq = 0;\n  /** Cached `/tiles/info` pyramid descriptor + the infoB64 it was fetched for. */\n  private descriptor: TileDescriptor | null = null;\n  private descriptorKey: string | null = null;\n\n  /** How the current 2D image is composited (drives histogram + state application). */\n  private imageMode: 'grayscale' | 'multichannel' | 'rgb' = 'rgb';\n  /** napari-js high-level view that owns the per-channel layer set (build + live display\n   *  updates) for the current {@link imageMode}. Rebuilt on each (re)render. */\n  private channelView: MultiChannelImageView | null = null;\n  /** Live subscription applying channel-state / colormap changes to the layers. */\n  private displaySub: Subscription | null = null;\n  /** Latest grayscale colormap selection from the store (applied to the single gray layer). */\n  private currentColormap: ColormapNode | null = null;\n  private currentReverse = false;\n  /** Latest invert toggle from the store (flips intensity before the colormap, like OSD). */\n  private invertEnabled = false;\n  /** Physical scale bar overlay for the 2D image (null when 3D or the image has no µm/pixel). */\n  private scaleBar: NapariScaleBar | null = null;\n  /** SVG region-drawing overlay for the 2D image (null until a 2D image is plotted). */\n  private regionOverlay: NapariRegionOverlay | null = null;\n  /** Pixel-tool plumbing: the plot div id, coord transform, and bound tool hosts. */\n  private plotDivId = '';\n  private coordTransform: ICoordinateTransform | null = null;\n  private wandHost: WandToolHost | null = null;\n  private eraserHost: VertexEraserToolHost | null = null;\n  /** Cached CachedImageData built from the last readback (rebuilt when lastPixels changes). */\n  private cachedImage: CachedImageData | null = null;\n  private cachedImageSource: PixelData | null = null;\n  /** Visible world rect captured AT the last readback — must pair with `lastPixels` so the pixel\n   *  tools' ratios/origin match the matrix's camera (using the live rect after a pan/zoom would\n   *  mis-scale the region). */\n  private lastPixelsRect: { x: number; y: number; width: number; height: number } | null = null;\n  /** Image smoothing (bilinear) vs nearest-neighbour (crisp pixels, the default). */\n  private imageSmoothing = false;\n  /** True when the 2D image is rendered via pyramidal TiledSources (descriptor available). */\n  private tiled = false;\n  /** Debounced readback timer + camera-change unsubscribe (keep lastPixels current for tools). */\n  private readbackTimer: ReturnType<typeof setTimeout> | null = null;\n  private cameraReadbackOff: (() => void) | null = null;\n  /** Coarse per-channel luminance sample (keyed by channel index) for the histogram in tiled mode,\n   *  where the layers have no full in-memory pixels. Refreshed on plot + slice change. */\n  private readonly histSamples = new Map<number, Uint8Array>();\n  /** Native-bit-depth histograms from `/histogram`, keyed `${z}|${channel}` (>8-bit images). */\n  private readonly nativeHistograms = new Map<string, IHistogram>();\n\n  private readonly stackLoading$ = new BehaviorSubject<boolean>(false);\n  private readonly stackLoadingProgress$ = new BehaviorSubject<number>(0);\n  private readonly autoscaleEvent$ = new Subject<unknown>();\n  private readonly intensityProfile$ = new Subject<IntensityProfile[]>();\n  private readonly viewportChange$ = new Subject<{\n    x: number;\n    y: number;\n    width: number;\n    height: number;\n  }>();\n\n  constructor(\n    @Inject(TILE_ACCESS_PORT) private readonly tiles: TileAccessPort,\n    store: VisualizerStore,\n    regionStore: RegionStore,\n    private readonly wandTool: WandToolService,\n    private readonly brushTool: BrushToolService,\n    private readonly eraserTool: VertexEraserToolService,\n    private readonly zoomToBoxTool: ZoomToBoxToolService,\n    private readonly samTool: SamToolService,\n    private readonly samPointTool: SamPointToolService,\n    private readonly cellSegmentTool: CellSegmentToolService,\n    @Optional() @Inject(CELL_SEGMENTER) private readonly cellSegmenter: ICellSegmenter | null,\n    private readonly simpleStack: SimpleSliceAccessService,\n    @Inject(VIZ_CONFIG) config: VizConfig,\n    // Optional: only a host that serves spatial-omics data provides it, and\n    // without it the SPATIAL_OMICS plot type is never offered anyway.\n    @Optional() @Inject(SPATIAL_DATA_PORT) private readonly spatialData: SpatialDataPort | null = null,\n    private readonly selectionStore: SpatialSelectionStore | null = null,\n  ) {\n    super(regionStore, store);\n    this.api = config.slideCropServer;\n  }\n\n  /**\n   * Fetch + cache the server pyramid descriptor (`GET /tiles/info`): the REAL per-level tile grid,\n   * tile size, channel metadata and physical pixel size. The backend returns 202 while the source\n   * is still caching, so we poll briefly. Cached per `infoB64`; returns null if it never becomes\n   * ready (callers fall back to a single-tile fetch). This is the authoritative grid — guessing\n   * level dims from `trueImageSize` overshoots the real grid and the server 400s out-of-range tiles.\n   */\n  private async ensureDescriptor(): Promise<TileDescriptor | null> {\n    // Self-contained multi-slice stack (no tile server — e.g. a numbered image\n    // series assembled client-side, each slice a different file): there is no\n    // single server-tiled pyramid to describe. Returning null routes every\n    // caller (2D image, volume, surface) to their stitched/single-fetch\n    // fallback, which — via fetchSlice's own SimpleSliceAccessService branch —\n    // correctly fetches each slice's own URL instead of one fixed file's tile\n    // pyramid.\n    if (this.simpleStack.isSimple(this.loaded?.imageInfo)) return null;\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) return null;\n    if (this.descriptor && this.descriptorKey === infoB64) return this.descriptor;\n    const headers = await this.tiles\n      .getAuthHeaders()\n      .catch(() => ({}) as Record<string, string>);\n    const url = `${this.api}tiles/info?info=${infoB64}`;\n    const deadline = Date.now() + DESCRIPTOR_TIMEOUT_MS;\n    for (;;) {\n      try {\n        const resp = await fetch(url, { headers });\n        if (resp.status === 200) {\n          const body = (await resp.json()) as TileDescriptor;\n          if (body?.levels?.length) {\n            this.descriptor = body;\n            this.descriptorKey = infoB64;\n            return body;\n          }\n        }\n        // 202 (still caching) or empty body → re-poll until the deadline.\n      } catch (err) {\n        console.warn('[napari-js] tiles/info poll retry', err);\n      }\n      if (Date.now() > deadline) {\n        console.warn('[napari-js] tiles/info not ready; falling back to single-tile fetch');\n        return null;\n      }\n      await new Promise((r) => setTimeout(r, 1200));\n    }\n  }\n\n  /**\n   * Fetch a COMPLETE rendered slice as an `ImageBitmap` by stitching the server's REAL tile grid\n   * (from `/tiles/info`) — not just the top-left tile, which only ever showed a large image's\n   * corner. Picks the finest pyramid level whose grid fits `budgetTiles` and whose longest side is\n   * within the GPU texture limit, fetches that grid concurrently, and stitches it into one canvas.\n   *\n   * `channel` selects a single band as grayscale (real levels only); omit for the server composite.\n   * `budgetTiles` caps the grid: the 2D view uses the full budget for detail; the 3D volume passes\n   * 1 for a cheap overview tile per slice (it downsamples to {@link VOLUME_MAX_SLICE}). Falls back\n   * to a single `col=0,row=0` tile when no descriptor is available (small/simple images, volumes).\n   */\n  private async fetchSlice(\n    z: number,\n    channel?: number,\n    budgetTiles: number = MAX_STITCH_TILES,\n    /** When a specific channel has no pyramid level within `budgetTiles`, drop to the server\n     *  COMPOSITE overview instead of stitching the huge per-channel level. Only safe when the caller\n     *  wants a single decimated plane (the surface height): for a multichannel VOLUME every channel\n     *  would then fetch the same composite and the channels would collapse into one, so volume\n     *  assembly leaves this `false` to keep each band distinct. */\n    allowCompositeFallback = false,\n  ): Promise<ImageBitmap> {\n    // Self-contained multi-slice stack (tiled:false): `z` indexes a completely\n    // different file's own preview URL, not an internal slice of one server-\n    // tiled file — resolved and fetched via SimpleSliceAccessService (shared\n    // with OSD; see its docs for why this can't be a bare fetch()) instead of\n    // building a /tile?info=...&z= request against whichever single file\n    // getSelectedInfoB64() points at (which would 400/mismatch for any z\n    // beyond that one file's own extent).\n    const info = this.loaded?.imageInfo;\n    if (this.simpleStack.isSimple(info)) {\n      // Serverless multichannel volume: fetch the requested channel's OWN plane\n      // (channelUrls[z][channel]) so each band stays distinct — the client-side\n      // analog of the server's per-channel /tile?channel=c. Else the z-anchor URL.\n      const chUrls = (info as IImageInfo).channelUrls;\n      const url = channel != null && chUrls?.[z]?.[channel] != null\n        ? chUrls[z][channel]\n        : this.simpleStack.urlFor(info as IImageInfo, z);\n      if (!url) throw new Error(`[napari-js] no URL for slice ${z}`);\n      return this.simpleStack.fetchAsBitmap(url);\n    }\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) throw new Error('[napari-js] no selected image info (getSelectedInfoB64 null)');\n    const headers = await this.tiles\n      .getAuthHeaders()\n      .catch(() => ({}) as Record<string, string>);\n    const desc = await this.ensureDescriptor();\n\n    // The requested band; may be dropped to the composite (undefined) below when the channel has no\n    // pyramid level small enough to stitch within budget.\n    let effectiveChannel = channel;\n    const fetchTile = async (\n      res: number,\n      col: number,\n      row: number,\n      t: number,\n    ): Promise<ImageBitmap> => {\n      const ch = effectiveChannel == null ? '' : `&channel=${effectiveChannel}`;\n      const url = `${this.api}tile?info=${infoB64}&res=${res}&col=${col}&row=${row}&z=${z}&tileSize=${t}${ch}`;\n      const resp = await fetch(url, { headers });\n      if (!resp.ok) {\n        throw new Error(`[napari-js] slice fetch failed: ${resp.status} (${col}/${row} res ${res})`);\n      }\n      return createImageBitmap(await resp.blob());\n    };\n\n    // No descriptor → single top-left tile (legacy fallback; correct for small/simple images).\n    if (!desc || !desc.levels?.length) return fetchTile(0, 0, 0, TILE_SIZE);\n\n    const t = desc.tileSize || TILE_SIZE;\n    // Per-channel tiles exist ONLY at REAL Bio-Formats levels (the front of `levels`); the server\n    // composite exists at every level, including the small overviews.\n    const perChannelLevels = desc.realLevels ?? desc.levels.length;\n    const usable =\n      channel == null ? desc.levels : desc.levels.slice(0, Math.max(1, perChannelLevels));\n\n    // Finest level whose stitched grid fits BOTH the tile budget and the GPU texture limit; if none\n    // fits, the coarsest available (fits=false).\n    const tilesFor = (lvl: TileLevel): number =>\n      Math.max(1, Math.ceil(lvl.width / t)) * Math.max(1, Math.ceil(lvl.height / t));\n    const pick = (levels: TileLevel[]): { lvl: TileLevel; fits: boolean } => {\n      let c = levels[0];\n      for (const lvl of levels) {\n        c = lvl;\n        if (tilesFor(lvl) <= budgetTiles && Math.max(lvl.width, lvl.height) <= MAX_TEXTURE_DIM) {\n          return { lvl, fits: true };\n        }\n      }\n      return { lvl: c, fits: false };\n    };\n\n    let sel = pick(usable);\n    // A specific channel only has tiles at the (few, large) real levels. When none of them fit the\n    // budget — e.g. the coarsest real level is still 14982×18670 → ~1100 full-res tiles — stitching\n    // it per slice floods the server (504s) and stalls the load. The composite pyramid has small\n    // overview levels, so fetch the composite instead and derive luminance from it. Every caller here\n    // (surface height, volume assembly, readback) downscales the plane anyway, so a composite-derived\n    // plane is the right trade for one that actually loads. Only kicks in when the channel can't fit.\n    if (allowCompositeFallback && !sel.fits && channel != null && desc.levels.length > perChannelLevels) {\n      const composite = pick(desc.levels);\n      if (composite.fits || tilesFor(composite.lvl) < tilesFor(sel.lvl)) {\n        effectiveChannel = undefined;\n        sel = composite;\n        console.warn(\n          `[napari-js] channel ${channel} has no pyramid level within the ${budgetTiles}-tile ` +\n            `budget; using the composite overview (res ${sel.lvl.res}, ${sel.lvl.width}×` +\n            `${sel.lvl.height}) for this plane.`,\n        );\n      }\n    }\n    const chosen = sel.lvl;\n    const cols = Math.max(1, Math.ceil(chosen.width / t));\n    const rows = Math.max(1, Math.ceil(chosen.height / t));\n    if (!sel.fits && budgetTiles === MAX_STITCH_TILES) {\n      console.warn(\n        `[napari-js] full resolution exceeds the ${budgetTiles}-tile/${MAX_TEXTURE_DIM}px budget; ` +\n          `displaying overview level res ${chosen.res} (${chosen.width}×${chosen.height}).`,\n      );\n    }\n\n    if (cols === 1 && rows === 1) return fetchTile(chosen.res, 0, 0, t);\n\n    // Stitch into one level-sized canvas. Fetch the grid with BOUNDED concurrency: firing every tile\n    // at once (a big grid = hundreds of requests) overwhelmed the tile server (504s). Edge tiles are\n    // narrower/shorter; drawImage places each at its grid offset so partial tiles line up.\n    const coords: Array<{ col: number; row: number }> = [];\n    for (let row = 0; row < rows; row++) {\n      for (let col = 0; col < cols; col++) coords.push({ col, row });\n    }\n    const tiles: Array<{ col: number; row: number; bmp: ImageBitmap }> = [];\n    const stitchWorker = async (): Promise<void> => {\n      for (;;) {\n        const job = coords.shift();\n        if (!job) return;\n        const bmp = await fetchTile(chosen.res, job.col, job.row, t);\n        tiles.push({ col: job.col, row: job.row, bmp });\n      }\n    };\n    await Promise.all(\n      Array.from({ length: Math.min(TILE_FETCH_CONCURRENCY, coords.length) }, () => stitchWorker()),\n    );\n\n    let canvas: HTMLCanvasElement | OffscreenCanvas;\n    if (typeof OffscreenCanvas !== 'undefined') {\n      canvas = new OffscreenCanvas(chosen.width, chosen.height);\n    } else {\n      canvas = document.createElement('canvas');\n      canvas.width = chosen.width;\n      canvas.height = chosen.height;\n    }\n    const ctx = canvas.getContext('2d') as\n      | CanvasRenderingContext2D\n      | OffscreenCanvasRenderingContext2D\n      | null;\n    if (!ctx) throw new Error('[napari-js] slice stitch: 2D context unavailable');\n    for (const { col, row, bmp } of tiles) {\n      ctx.drawImage(bmp, col * t, row * t);\n      bmp.close?.();\n    }\n\n    // Safety net: if the chosen level still exceeds the GPU texture limit (e.g. a multichannel\n    // image whose coarsest REAL level is huge — overview levels are composite-only), downscale the\n    // stitched canvas to fit so the WebGPU texture upload can't fail.\n    const longest = Math.max(chosen.width, chosen.height);\n    if (longest > MAX_TEXTURE_DIM) {\n      const scale = MAX_TEXTURE_DIM / longest;\n      const outW = Math.max(1, Math.floor(chosen.width * scale));\n      const outH = Math.max(1, Math.floor(chosen.height * scale));\n      console.warn(\n        `[napari-js] stitched level ${chosen.width}×${chosen.height} exceeds the ` +\n          `${MAX_TEXTURE_DIM}px texture limit; downscaling to ${outW}×${outH}.`,\n      );\n      let out: HTMLCanvasElement | OffscreenCanvas;\n      if (typeof OffscreenCanvas !== 'undefined') {\n        out = new OffscreenCanvas(outW, outH);\n      } else {\n        out = document.createElement('canvas');\n        out.width = outW;\n        out.height = outH;\n      }\n      const octx = out.getContext('2d') as\n        | CanvasRenderingContext2D\n        | OffscreenCanvasRenderingContext2D\n        | null;\n      if (!octx) throw new Error('[napari-js] slice downscale: 2D context unavailable');\n      octx.drawImage(canvas as unknown as CanvasImageSource, 0, 0, outW, outH);\n      return createImageBitmap(out as unknown as ImageBitmapSource);\n    }\n    return createImageBitmap(canvas as unknown as ImageBitmapSource);\n  }\n\n  // ── IDataRenderer: load / render / viewport ───────────────────────────────\n  async load(imageInfo: IImageInfo, zIndex: number): Promise<NapariLoaded> {\n    // Keeps SimpleSliceAccessService's blob cache in sync even when the user\n    // switches backends (e.g. OSD Image → napari Volume) on the same file —\n    // whichever backend loads a genuinely different file first evicts it.\n    this.simpleStack.noteActiveFile(imageInfo.fileName);\n    this.loaded = { imageInfo, z: zIndex, filename: imageInfo.fileName };\n    return this.loaded;\n  }\n\n  async plot(\n    plotDiv: string,\n    imageLoaded: unknown,\n    imageInfo: IImageInfo,\n    screenHeight: number,\n    plotType: PlotType,\n    _inPlace?: boolean,\n  ): Promise<boolean> {\n    const host = document.getElementById(plotDiv);\n    if (!host) {\n      console.error(`[napari-js] plot target #${plotDiv} not found`);\n      return false;\n    }\n    this.reset();\n    this.host = host;\n    this.plotDivId = plotDiv;\n    this.currentPlotType = plotType;\n\n    const canvas = document.createElement('canvas');\n    canvas.style.display = 'block';\n    canvas.style.width = '100%';\n    canvas.style.height = screenHeight ? `${screenHeight}px` : '100%';\n    host.appendChild(canvas);\n    this.canvas = canvas;\n\n    const info = (imageLoaded as NapariLoaded)?.imageInfo ?? imageInfo;\n    const z = (imageLoaded as NapariLoaded)?.z ?? 0;\n\n    try {\n      const viewer = new Viewer({\n        canvas,\n        background: { r: 0.07, g: 0.07, b: 0.09, a: 1 },\n        // Set here rather than left to napari-js's own default so the gentler\n        // step applies with the version currently installed. Chosen to match the\n        // OSD backend's step (see OSD_ZOOM_PER_SCROLL): the wheel should feel the\n        // same on an image whichever renderer is drawing it. The step applies per\n        // scroll EVENT, and a trackpad sends a burst of them per swipe, so a step\n        // tuned to a mouse notch runs away under a trackpad.\n        wheelZoomSpeed: NAPARI_WHEEL_ZOOM_SPEED,\n        // The FIRST 3D layer of a scene frames the orbit camera; every later one leaves the\n        // pose alone. A spatial scene is built from several layers and rebuilt constantly —\n        // recolouring by a class, picking a gene, stepping a section — and with napari-js's\n        // previous unconditional framing each of those threw away an orbit the user had set.\n        // The pose it snapped back to depended on WHICH layer was rebuilt, so isolating one\n        // section zoomed to that section's bounds. `resetFit3D()` on a dataset change is what\n        // lets the next scene frame itself.\n        fit3d: 'once',\n        // In the spatial modes a plain click SELECTS the class under the cursor,\n        // so napari's OSD-style click-to-zoom is turned off there: otherwise one\n        // click would both select a class and zoom 2x about the cursor, and the\n        // zoom would then halve the pixel radius the next click hit-tests with.\n        // Zooming is still on the wheel, the zoom buttons and the zoom-box tool.\n        ...(isSpatialOmics(plotType) || isSpatialOmics3d(plotType)\n          ? { clickZoomFactor: 0 }\n          : {}),\n      });\n      this.viewer = viewer;\n      await viewer.ready;\n\n      if (isSpatialOmics3d(plotType)) {\n        await this.mountSpatialOmics3d(viewer, host);\n      } else if (isSpatialOmics(plotType)) {\n        await this.mountSpatialOmics(viewer, host, z);\n      } else if (isNapariScatter(plotType)) {\n        await this.mountScatter(viewer, host, z);\n      } else if (isNapariScatter3d(plotType)) {\n        await this.mountScatter3d(viewer, info);\n      } else if (isNapariSurface(plotType)) {\n        await this.mountSurface(viewer);\n      } else if (isNapari3d(plotType)) {\n        await this.mountVolume(viewer, info, plotType);\n      } else {\n        await this.renderImage(z);\n        this.fitCameraSoon();\n        this.subscribeDisplayState();\n        this.installScaleBar();\n        this.install2dInteraction(viewer, host);\n      }\n      this.scheduleReadback();\n      return true;\n    } catch (err) {\n      console.error('[napari-js] plot failed:', err);\n      return false;\n    }\n  }\n\n  // ── Channels: per-channel composite, LUT, native histograms (jit-ui#102) ──────────────────\n\n  /** The grayscale display colormap from the store selection (+reverse), defaulting to gray.\n   *  Maps the jit-ui store colormap node to a napari `Colormap` via the library's LUT factory;\n   *  the multichannel tint ramps are built inside {@link MultiChannelImageView} from each\n   *  channel's hex colour. */\n  private grayscaleColormap(): Colormap | string {\n    const value = (this.currentColormap as { data?: { value?: unknown } } | null)?.data?.value;\n    const lut = value != null ? buildColormapLut(value, this.currentReverse) : null;\n    if (lut) return colormapFromLut('gray-cmap', lut);\n    return this.currentReverse\n      ? colormapFromLut('gray-rev', [[255, 255, 255], [0, 0, 0]] as Rgb[])\n      : 'gray';\n  }\n\n  /** Fetch a stitched slice and read it back as a single-channel uint8 plane. `channel` selects a\n   *  band (multichannel); omit it for the grayscale composite (all overview levels available, so a\n   *  large image picks a fitting downscaled level rather than only the full-res real level). */\n  private async fetchChannelData(\n    z: number,\n    channel?: number,\n    budgetTiles?: number,\n  ): Promise<{ data: Uint8Array; width: number; height: number }> {\n    const bmp = await this.fetchSlice(z, channel, budgetTiles);\n    return this.bitmapToLuminance(bmp);\n  }\n\n  /** Decode an `ImageBitmap` (server bands are grayscale, R=G=B) to a single-channel uint8 plane.\n   *  `maxSide` caps the longest side (downscaling on the canvas draw) — used to keep pre-loaded\n   *  surface slice planes small. */\n  private bitmapToLuminance(\n    bmp: ImageBitmap,\n    maxSide?: number,\n  ): { data: Uint8Array; width: number; height: number } {\n    const scale = maxSide ? Math.min(1, maxSide / Math.max(bmp.width, bmp.height, 1)) : 1;\n    const w = Math.max(1, Math.round(bmp.width * scale));\n    const h = Math.max(1, Math.round(bmp.height * scale));\n    let canvas: HTMLCanvasElement | OffscreenCanvas;\n    if (typeof OffscreenCanvas !== 'undefined') {\n      canvas = new OffscreenCanvas(w, h);\n    } else {\n      canvas = document.createElement('canvas');\n      canvas.width = w;\n      canvas.height = h;\n    }\n    const ctx = canvas.getContext('2d') as\n      | CanvasRenderingContext2D\n      | OffscreenCanvasRenderingContext2D\n      | null;\n    if (!ctx) throw new Error('[napari-js] channel readback: 2D context unavailable');\n    // Scale the WHOLE bitmap into the (possibly smaller) target canvas — drawing at natural size\n    // would crop to the top-left w×h corner when downscaling a large slice (maxSide < bmp size).\n    ctx.drawImage(bmp, 0, 0, w, h);\n    bmp.close?.();\n    const rgba = ctx.getImageData(0, 0, w, h).data;\n    const data = new Uint8Array(w * h);\n    for (let i = 0; i < w * h; i++) data[i] = rgba[i * 4];\n    return { data, width: w, height: h };\n  }\n\n  /**\n   * Render the 2D image for slice `z`. With a server pyramid descriptor we use a pyramidal\n   * {@link TiledSource} per layer so the view refines to higher resolution on zoom (like OSD) and\n   * sits naturally in full-resolution coordinates; without one we fall back to the single-level\n   * stitch. Three display modes either way: multichannel additive tint, grayscale colormap, RGB.\n   */\n  private async renderImage(z: number, token?: number): Promise<void> {\n    const v = this.viewer;\n    if (!v) return;\n    const desc = await this.ensureDescriptor();\n    if (desc && desc.levels?.length) {\n      if (token != null && token !== this.sliceReq) return;\n      await this.renderImageTiled(z, desc);\n      return;\n    }\n    return this.renderImageStitched(z, token);\n  }\n\n  /** Single-level stitch fallback (no descriptor): the pre-tiling path. */\n  private async renderImageStitched(z: number, token?: number): Promise<void> {\n    const v = this.viewer;\n    if (!v) return;\n    const desc = await this.ensureDescriptor();\n    const states = this.store.currentChannelStates();\n    const channelCount = desc?.channels ?? (states.length || 1);\n    const multichannel = !!desc?.multichannel && channelCount > 1;\n\n    // 1) Fetch all pixel data BEFORE touching the viewer, so a superseded scrub can bail without\n    //    having torn down the visible layers (avoids flicker / out-of-order layer state).\n    let mode: 'grayscale' | 'multichannel' | 'rgb';\n    let planes: Array<{ data: Uint8Array; width: number; height: number }> = [];\n    let bitmap: ImageBitmap | null = null;\n    if (multichannel) {\n      mode = 'multichannel';\n      planes = await Promise.all(\n        Array.from({ length: channelCount }, (_, c) => this.fetchChannelData(z, c)),\n      );\n    } else if (channelCount === 1) {\n      mode = 'grayscale';\n      // Composite fetch (no channel) → all overview levels usable, so a large grayscale image\n      // selects a fitting downscaled level instead of the full-res real level (texture limit).\n      planes = [await this.fetchChannelData(z)];\n    } else {\n      mode = 'rgb';\n      bitmap = await this.fetchSlice(z);\n    }\n\n    // 2) Commit — unless a newer scrub superseded us or the viewer was torn down.\n    if ((token != null && token !== this.sliceReq) || this.viewer !== v) {\n      bitmap?.close?.();\n      return;\n    }\n\n    // The displayed texture may be a downscaled pyramid level; scale the layer into FULL-RESOLUTION\n    // world coordinates (level-0 pixels) so the camera, readback and — critically — pre-saved\n    // regions (stored in full-res coords, e.g. ndpi) all line up regardless of which level is shown.\n    // This mirrors OSD, whose coordinate system is always level 0.\n    const texW = mode === 'rgb' ? (bitmap as ImageBitmap).width : planes[0]?.width ?? 0;\n    const texH = mode === 'rgb' ? (bitmap as ImageBitmap).height : planes[0]?.height ?? 0;\n    const fullW = desc?.width || texW || 1;\n    const fullH = desc?.height || texH || 1;\n    const scale: [number, number] = [texW ? fullW / texW : 1, texH ? fullH / texH : 1];\n\n    this.imageMode = mode;\n    const interpolation: 'linear' | 'nearest' = this.imageSmoothing ? 'linear' : 'nearest';\n    this.channelView = new MultiChannelImageView(v);\n    if (mode === 'multichannel') {\n      const views: ChannelView[] = planes.map((d, c) => {\n        const st = states.find((s) => s.index === c);\n        const color = st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c);\n        return {\n          source: { kind: 'typed', width: d.width, height: d.height, channels: 1, dtype: 'uint8', data: d.data },\n          tint: color,\n          name: st?.name ?? `ch${c}`,\n          contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n          gamma: st?.gamma ?? 1,\n          visible: st?.visible ?? true,\n          invert: this.invertEnabled,\n          scale,\n        };\n      });\n      this.channelView.render('multichannel', views, { interpolation });\n    } else if (mode === 'grayscale') {\n      const d = planes[0];\n      const st = states[0];\n      this.channelView.render(\n        'grayscale',\n        [\n          {\n            source: { kind: 'typed', width: d.width, height: d.height, channels: 1, dtype: 'uint8', data: d.data },\n            colormap: this.grayscaleColormap(),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: st?.gamma ?? 1,\n            invert: this.invertEnabled,\n            scale,\n          },\n        ],\n        { interpolation },\n      );\n    } else {\n      this.channelView.render('rgb', [{ source: bitmap as ImageBitmap, scale }], { interpolation });\n    }\n    this.imageW = fullW;\n    this.imageH = fullH;\n  }\n\n  /**\n   * Render the 2D image with pyramidal {@link TiledSource}s — the view refines to higher resolution\n   * as you zoom in (the visual fetches the level whose texels ≈ screen pixels) and sits in full-res\n   * coordinates so regions align. Same three modes as the stitch path. Per-channel layers use the\n   * REAL pyramid levels (per-channel tiles only exist there); the composite uses all levels.\n   */\n  private async renderImageTiled(z: number, desc: TileDescriptor): Promise<void> {\n    const v = this.viewer;\n    if (!v) return;\n    const states = this.store.currentChannelStates();\n    const channelCount = desc.channels ?? (states.length || 1);\n    const multichannel = !!desc.multichannel && channelCount > 1;\n    const interpolation: 'linear' | 'nearest' = this.imageSmoothing ? 'linear' : 'nearest';\n\n    this.tiled = true;\n    this.channelView = new MultiChannelImageView(v);\n\n    if (multichannel) {\n      this.imageMode = 'multichannel';\n      const views: ChannelView[] = [];\n      for (let c = 0; c < channelCount; c++) {\n        const st = states.find((s) => s.index === c);\n        const color = st?.color ?? desc.channelInfo?.[c]?.color ?? tintFor(c);\n        views.push({\n          source: this.buildTiledSource(desc, c, 1),\n          tint: color,\n          name: st?.name ?? `ch${c}`,\n          contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n          gamma: st?.gamma ?? 1,\n          visible: st?.visible ?? true,\n          invert: this.invertEnabled,\n        });\n      }\n      this.channelView.render('multichannel', views, { interpolation });\n    } else if (channelCount === 1) {\n      this.imageMode = 'grayscale';\n      const st = states[0];\n      this.channelView.render(\n        'grayscale',\n        [\n          {\n            source: this.buildTiledSource(desc, undefined, 1),\n            colormap: this.grayscaleColormap(),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: st?.gamma ?? 1,\n            invert: this.invertEnabled,\n          },\n        ],\n        { interpolation },\n      );\n    } else {\n      this.imageMode = 'rgb';\n      this.channelView.render('rgb', [{ source: this.buildTiledSource(desc, undefined, 4) }], {\n        interpolation,\n      });\n    }\n    this.imageW = desc.width;\n    this.imageH = desc.height;\n    // Await on the initial render so getHistogram/autoContrast have data immediately; slice changes\n    // refresh fire-and-forget (the histogram pane retries).\n    await this.refreshHistogramSamples(z, desc);\n  }\n\n  /** Build a pyramidal TiledSource backed by the server `/tile` endpoint. `channel` selects a band\n   *  (grayscale luminance, real levels only); omit it for the composite (RGBA, all levels). */\n  private buildTiledSource(\n    desc: TileDescriptor,\n    channel: number | undefined,\n    channels: 1 | 4,\n  ): TiledSource {\n    const infoB64 = this.tiles.getSelectedInfoB64() ?? '';\n    // Per-channel tiles exist only at REAL Bio-Formats levels; the composite exists at all levels.\n    const usable =\n      channel == null\n        ? desc.levels\n        : desc.levels.slice(0, Math.max(1, desc.realLevels ?? desc.levels.length));\n    const levelScales = usable.map((l) => desc.width / Math.max(1, l.width)); // level-0 px per level px\n    const tileSize = desc.tileSize || TILE_SIZE;\n    const ch = channel == null ? '' : `&channel=${channel}`;\n    const api = this.api;\n    return {\n      kind: 'tiled',\n      width: desc.width,\n      height: desc.height,\n      tileSize,\n      levels: usable.length,\n      levelScales,\n      depth: Math.max(1, desc.z || 1),\n      channels,\n      dtype: 'uint8',\n      fetchTile: async (key: TileKey): Promise<PixelChunk> => {\n        const res = usable[key.level]?.res ?? key.level;\n        const url = `${api}tile?info=${infoB64}&res=${res}&col=${key.col}&row=${key.row}&z=${key.z}&tileSize=${tileSize}${ch}`;\n        const headers = await this.tiles\n          .getAuthHeaders()\n          .catch(() => ({}) as Record<string, string>);\n        const resp = await fetch(url, { headers });\n        if (!resp.ok) {\n          throw new Error(`[napari-js] tile ${key.level}/${key.col}/${key.row} → ${resp.status}`);\n        }\n        const bmp = await createImageBitmap(await resp.blob());\n        if (channels === 4) return { width: bmp.width, height: bmp.height, data: bmp };\n        return this.bitmapToLuminance(bmp);\n      },\n    };\n  }\n\n  /** (Re)fetch a coarse per-channel luminance sample for the histogram (tiled mode has no full\n   *  in-memory pixels). One cheap overview tile per channel; cached by channel index. */\n  private async refreshHistogramSamples(z: number, desc: TileDescriptor): Promise<void> {\n    this.histSamples.clear();\n    if (this.imageMode === 'rgb') return; // RGB uses the displayed-pixel readback (rgbHistogram)\n    const channelCount = this.imageMode === 'multichannel' ? desc.channels ?? 1 : 1;\n    for (let c = 0; c < channelCount; c++) {\n      try {\n        const ch = this.imageMode === 'multichannel' ? c : undefined;\n        const d = await this.fetchChannelData(z, ch, 1); // budget 1 → coarsest single tile\n        this.histSamples.set(c, d.data);\n      } catch {\n        /* leave this channel's sample unset */\n      }\n    }\n  }\n\n  /** Subscribe channel states + grayscale colormap → live-apply to the rendered layers (no\n   *  re-fetch; only z changes re-fetch). Replaces any prior subscription. */\n  private subscribeDisplayState(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = combineLatest([\n      this.store.getChannelStates(),\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n    ]).subscribe(([channels, colormap, reverse, invert]) => {\n      this.currentColormap = (colormap as ColormapNode) ?? null;\n      this.currentReverse = reverse;\n      this.invertEnabled = invert;\n      this.applyDisplayState(channels);\n    });\n  }\n\n  /** Subscribe the store colormap (+reverse), invert, and channel state → the volume/isosurface\n   *  transfer function: colour (channel tint or selected colormap), the intensity **window\n   *  (min/max → contrastLimits)** and **gamma**, mirroring the grayscale image's display controls\n   *  so the histogram pane drives the 3D render. Replaces any prior subscription. */\n  private subscribeVolumeDisplayState(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = combineLatest([\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n      this.store.getChannelStates(),\n    ]).subscribe(([colormap, reverse, invert, channels]) => {\n      this.currentColormap = (colormap as ColormapNode) ?? null;\n      this.currentReverse = reverse;\n      this.invertEnabled = invert;\n      const view = this.volumeView;\n      if (!view) return;\n      if (this.volumeMultichannel) {\n        // Each channel's layer is tinted by its colour and gets its own window/gamma/visibility.\n        view.layers.forEach((_, c) => {\n          const st = channels.find((s) => s.index === c);\n          view.updateChannel(c, {\n            colormap: this.channelTintColormap(st?.color ?? '#ffffff'),\n            ...(st\n              ? {\n                  contrastLimits: [st.min, st.max] as [number, number],\n                  gamma: st.gamma,\n                  visible: st.visible,\n                }\n              : {}),\n          });\n        });\n      } else {\n        const st = channels[0];\n        view.updateChannel(0, {\n          colormap: this.volumeColormap(st),\n          ...(st ? { contrastLimits: [st.min, st.max] as [number, number], gamma: st.gamma } : {}),\n        });\n      }\n    });\n  }\n\n  /** A channel's tint colormap (black→colour) with reverse-scale / invert applied by flipping. */\n  private channelTintColormap(color: string): Colormap | string {\n    let cmap: Colormap | string = tintColormap(color);\n    if (this.currentReverse) cmap = reverseColormap(cmap);\n    if (this.invertEnabled) cmap = reverseColormap(cmap);\n    return cmap;\n  }\n\n  /**\n   * Colour map for the volume/isosurface. A real colormap selection (viridis/magma/…) wins;\n   * otherwise the channel's colour tints it (so the channel-dialog colour swatch recolors the 3D\n   * render). Reverse-scale and invert each flip the ramp — the `VolumeLayer` has no per-layer\n   * invert, so both are emulated by reversing the colormap.\n   */\n  private volumeColormap(st: IChannelState | undefined): Colormap | string {\n    const node = this.currentColormap as { label?: string; data?: { value?: unknown } } | null;\n    // A colored colormap (viridis/magma/…) drives the volume; the default grayscale family\n    // (gray / Greys / Greys Inv) yields to the channel's colour so the dialog colour swatch\n    // recolors the 3D render.\n    const label = (node?.label ?? '').toLowerCase();\n    const grayFamily = label === '' || label.includes('grey') || label.includes('gray');\n    const value = node?.data?.value;\n    const lut = !grayFamily && value != null ? buildColormapLut(value, false) : null;\n    let cmap: Colormap | string = lut\n      ? colormapFromLut('vol-cmap', lut)\n      : tintColormap(st?.color ?? '#ffffff');\n    // Reverse-scale and invert each flip the ramp (the VolumeLayer has no per-layer invert).\n    if (this.currentReverse) cmap = reverseColormap(cmap);\n    if (this.invertEnabled) cmap = reverseColormap(cmap);\n    return cmap;\n  }\n\n  /** Apply the current channel states / colormap to the live layers (no re-fetch), delegating the\n   *  per-channel layer mutations to the {@link MultiChannelImageView}. */\n  private applyDisplayState(channels: IChannelState[]): void {\n    const view = this.channelView;\n    if (!this.viewer || !view) return;\n    if (this.imageMode === 'multichannel') {\n      view.layers.forEach((_, c) => {\n        const st = channels.find((s) => s.index === c);\n        if (!st) return;\n        view.updateChannel(c, {\n          tint: st.color,\n          contrastLimits: [st.min, st.max],\n          gamma: st.gamma,\n          visible: st.visible,\n          invert: this.invertEnabled,\n        });\n      });\n    } else if (this.imageMode === 'grayscale') {\n      const st = channels[0];\n      view.updateChannel(0, {\n        colormap: this.grayscaleColormap(),\n        invert: this.invertEnabled,\n        ...(st ? { contrastLimits: [st.min, st.max] as [number, number], gamma: st.gamma } : {}),\n      });\n    }\n  }\n\n  /** (Re)install the physical scale bar over the 2D image, sized from the image's µm/pixel\n   *  (`/tiles/info` mppX, falling back to the image metadata). No-op without a physical size. */\n  private installScaleBar(): void {\n    this.scaleBar?.destroy();\n    this.scaleBar = null;\n    const mppX = this.descriptor?.mppX || this.loaded?.imageInfo.imageMeta?.[0]?.mppX || 0;\n    if (this.viewer && this.host && mppX > 0) {\n      this.scaleBar = new NapariScaleBar(this.host, this.viewer.camera, mppX);\n    }\n  }\n\n  /** Convert a napari-js `Histogram` (bin count + min/max) to the pane's `IHistogram` (bin edges). */\n  private toIHistogram(h: { counts: Uint32Array; bins: number; min: number; max: number }): IHistogram {\n    const span = h.max - h.min || 1;\n    const bins = Array.from({ length: h.bins }, (_, i) => h.min + (i * span) / h.bins);\n    const counts = Array.from(h.counts);\n    return { bins, counts, max: counts.reduce((m, c) => (c > m ? c : m), 0) };\n  }\n\n  /**\n   * Mount the 3D volume/isosurface. A multichannel image becomes one additive, tinted\n   * {@link VolumeLayer} per channel (so each channel's colour composites into the render); a\n   * grayscale/composite image uses a single volume. Adds the axes gizmo + labels and wires the\n   * display-state subscription. The caller owns `viewer.ready`.\n   */\n  private async mountVolume(\n    viewer: Viewer,\n    info: IImageInfo | undefined,\n    plotType: PlotType,\n  ): Promise<void> {\n    const token = this.loadToken; // bail before rendering if a Cancel / new plot bumps this\n    const desc = await this.ensureDescriptor();\n    // Serverless multichannel (tiled:false + channelUrls): no tile descriptor, so\n    // derive the channel count from imageMeta and assemble each band from its own\n    // channelUrls[z][c] plane (fetchSlice does the per-channel routing).\n    const simpleMc = this.simpleStack.isSimple(info) && !!info?.channelUrls?.length\n      && (info?.imageMeta?.[0]?.channelCount ?? 1) > 1;\n    const channelCount = simpleMc ? info!.imageMeta![0].channelCount : (desc?.channels ?? 1);\n    const multichannel = simpleMc || (!!desc?.multichannel && channelCount > 1);\n    const res = volumeResolutionFor(this.resolutionScale);\n    const rendering: 'iso' | 'mip' = isNapariIsosurface(plotType) ? 'iso' : 'mip';\n    const states = this.store.currentChannelStates();\n\n    this.volumeChannelData.clear();\n    this.volumeMultichannel = multichannel;\n    this.imageMode = this.volumeMultichannel ? 'multichannel' : 'grayscale';\n    const view = new MultiChannelVolumeView(viewer);\n    this.volumeView = view;\n\n    // Assemble per-channel scalar volumes from the server tiles (jit-specific); the napari-js view\n    // owns the layer orchestration (one additive tinted volume per channel, or a single grayscale\n    // volume). The adapter computes each channel's colormap (incl. invert/reverse flips).\n    let dims: { width: number; height: number; depth: number } | null = null;\n    const channels: VolumeChannel[] = [];\n    this.stackLoading$.next(true);\n    this.stackLoadingProgress$.next(0);\n    try {\n      if (multichannel) {\n        for (let c = 0; c < channelCount; c++) {\n          const vol = await this.assembleVolume(info, res, c);\n          if (!vol) continue;\n          dims = vol;\n          this.volumeChannelData.set(c, vol.data);\n          const st = states.find((s) => s.index === c);\n          const color = st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c);\n          channels.push({\n            data: vol.data,\n            width: vol.width,\n            height: vol.height,\n            depth: vol.depth,\n            colormap: this.channelTintColormap(color),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: st?.gamma ?? 1,\n            visible: st?.visible ?? true,\n          });\n        }\n      } else {\n        const vol = await this.assembleVolume(info, res);\n        if (vol) {\n          dims = vol;\n          this.volumeChannelData.set(0, vol.data);\n          const st = states[0];\n          channels.push({\n            data: vol.data,\n            width: vol.width,\n            height: vol.height,\n            depth: vol.depth,\n            colormap: this.volumeColormap(st),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: st?.gamma ?? 1,\n          });\n        }\n      }\n    } finally {\n      this.stackLoading$.next(false);\n      this.stackLoadingProgress$.next(0);\n    }\n\n    if (!dims || !channels.length || this.loadToken !== token) return; // cancelled → don't render\n\n    // Resolution-invariant world box. Sizing the box by the sampled voxel counts made higher\n    // in-plane resolution grow X/Y while the depth stayed the (constant) slice count — so Z appeared\n    // to shrink at higher resolution. Instead anchor the in-plane long side to a fixed reference and\n    // let Z span the full slice count; the box shape is then identical at every decimate factor. The\n    // per-axis `voxelSize` (napari `scale`) maps the sampled grid onto that fixed world box.\n    // A stack that declares its physical spacing on ALL THREE axes gets its true\n    // extent as the world box — the only way anisotropy survives, and what makes a\n    // resampled 40 x 40 x 200 µm volume read as a brain instead of a cube-aspect\n    // brick. It needs none of the reference-box arithmetic: a physical box is\n    // already independent of the decimate factor.\n    //\n    // Everything else keeps that arithmetic. Sizing the box by the sampled voxel\n    // counts made higher in-plane resolution grow X/Y while the depth stayed the\n    // (constant) slice count — so Z appeared to shrink at higher resolution.\n    // Anchoring the in-plane long side to a fixed reference and letting Z span the\n    // full slice count makes the box shape identical at every decimate factor.\n    const meta = this.loaded?.imageInfo.imageMeta?.[0];\n    const mppXYZ: [number, number, number] | null =\n      meta?.mppX && meta?.mppY && meta?.mppZ ? [meta.mppX, meta.mppY, meta.mppZ] : null;\n    // The image's DECLARED pixel dimensions, which is what mpp is per: the sampled\n    // dims are decimated, so sizing a physical box by them would make the world\n    // box depend on the resolution the user happens to be viewing at.\n    const fullW = this.descriptor?.width ?? meta?.x ?? dims.width;\n    const fullH = this.descriptor?.height ?? meta?.y ?? dims.height;\n    const fullD = meta?.z || this.loaded?.imageInfo.urls?.length || dims.depth;\n    let world: { width: number; height: number; depth: number };\n    if (mppXYZ) {\n      world = {\n        width: fullW * mppXYZ[0],\n        height: fullH * mppXYZ[1],\n        depth: fullD * mppXYZ[2],\n      };\n    } else {\n      const fullLong = Math.max(1, fullW, fullH);\n      world = {\n        width: (fullW * VOLUME_WORLD_INPLANE_REF) / fullLong,\n        height: (fullH * VOLUME_WORLD_INPLANE_REF) / fullLong,\n        depth: fullD,\n      };\n    }\n    // Base box (Z-scale = 1) + the sampled depth drive the live Z-height handle below; the persisted\n    // `volumeZScale` (user drag) applies on top so changing resolution keeps the chosen height.\n    this.volumeWorldBase = world;\n    this.volumeSampledDepth = Math.max(1, dims.depth);\n    const worldZ = world.depth * this.volumeZScale;\n    const voxelSize: [number, number, number] = [\n      world.width / dims.width,\n      world.height / dims.height,\n      worldZ / this.volumeSampledDepth,\n    ];\n    for (const ch of channels) ch.voxelSize = voxelSize;\n\n    view.render(this.volumeMultichannel ? 'multichannel' : 'grayscale', channels, { rendering });\n    this.imageW = dims.width;\n    this.imageH = dims.height;\n    this.volumeDims = dims;\n\n    // 3D coordinate-axes / scale gizmo + labels, sharing the volume's world box so the gizmo tracks\n    // the rendered proportions. Physical scale text still comes from the FULL image extent.\n    this.axesLayer = viewer.addAxes(world.width, world.height, worldZ, { visible: this.axesVisible });\n    if (this.host) {\n      this.axesLabels = new NapariAxesLabels(\n        this.host,\n        viewer.camera3d,\n        this.buildAxesLabels({ width: world.width, height: world.height, depth: worldZ }),\n      );\n      this.axesLabels.setVisible(this.axesVisible);\n      // In-view drag handle at the TOP END OF THE Z AXIS (the box's min-XY corner, where the blue\n      // \"Z\" axis + label live), so it reads as the Z-height control. Floated a little past the axis\n      // tip (×1.12) so the grip clears the \"Z · …\" label. Drag ↕ to restretch Z live.\n      this.zHandle = new NapariVolumeZHandle(this.host, viewer.camera3d, {\n        topAnchor: () => [\n          -this.volumeWorldBase!.width / 2,\n          -this.volumeWorldBase!.height / 2,\n          ((this.volumeWorldBase!.depth * this.volumeZScale) / 2) * 1.12,\n        ],\n        getScale: () => this.volumeZScale,\n        setScale: (s) => this.setVolumeZScale(s),\n      });\n    }\n    this.subscribeVolumeDisplayState();\n  }\n\n  /**\n   * Restretch the volume's Z height live (driven by the in-view {@link NapariVolumeZHandle}). Only\n   * the per-axis `voxelSize` / axes depth change — the voxel textures are untouched — so dragging is\n   * smooth. `factor` is relative to the volume's natural proportions (1). Persists across re-mounts\n   * (resolution changes) so the chosen height sticks.\n   */\n  private setVolumeZScale(factor: number): void {\n    this.volumeZScale = Math.min(10, Math.max(0.1, factor));\n    const base = this.volumeWorldBase;\n    if (!base || !this.volumeView) return;\n    const worldZ = base.depth * this.volumeZScale;\n    const vsZ = worldZ / this.volumeSampledDepth;\n    for (const layer of this.volumeView.layers) {\n      const [sx, sy] = layer.voxelSize;\n      layer.voxelSize = [sx, sy, vsZ];\n    }\n    if (this.axesLayer) this.axesLayer.depth = worldZ;\n    this.axesLabels?.updateAnchors(\n      this.buildAxesLabels({ width: base.width, height: base.height, depth: worldZ }),\n    );\n    this.zHandle?.reposition();\n    this.viewer?.requestRender();\n  }\n\n  /** Build the X/Y/Z axis-end label specs for the 3D gizmo. Anchors are in the volume's centred\n   *  world box (matching the AxesLayer geometry); the scale text reflects the FULL image extent —\n   *  physical µm when µm/pixel is known, else pixel (X/Y) / slice (Z) counts. */\n  private buildAxesLabels(\n    vol: { width: number; height: number; depth: number },\n  ): AxisLabelSpec[] {\n    const hx = vol.width / 2;\n    const hy = vol.height / 2;\n    const hz = vol.depth / 2;\n    // Measured from the IMAGE's own extent, never from the world box: the box is a\n    // shape (and for a physically sized volume it is already in µm, so reading a\n    // pixel count off it and multiplying by mpp would scale the label twice).\n    const { px, mpp } = this.imageExtent();\n    const len = (n: number, um: number): string => (um > 0 ? formatUm(n * um) : `${n} px`);\n    return [\n      { anchor: [hx, -hy, -hz], text: `X · ${len(px[0], mpp[0])}`, color: '#ed4545' },\n      { anchor: [-hx, hy, -hz], text: `Y · ${len(px[1], mpp[1])}`, color: '#4dd959' },\n      // Physical when the stack declares its slice spacing (`mppZ`) — a resampled\n      // volume knows how thick it is; a plain z-stack can only say how many slices.\n      { anchor: [-hx, -hy, hz], text: `Z · ${len(px[2], mpp[2])}`, color: '#668cff' },\n    ];\n  }\n\n  /**\n   * The image's declared extent in pixels/slices, and its physical spacing per\n   * axis in µm (0 = undeclared, and then that axis reads in pixels).\n   *\n   * One place, because the volume world box and the axis labels have to agree\n   * about what the image's real dimensions are — the sampled grid is decimated and\n   * says nothing about either.\n   */\n  private imageExtent(): { px: [number, number, number]; mpp: [number, number, number] } {\n    const meta = this.loaded?.imageInfo.imageMeta?.[0];\n    const dims = this.volumeDims;\n    const mppX = this.descriptor?.mppX || meta?.mppX || 0;\n    return {\n      px: [\n        this.descriptor?.width ?? meta?.x ?? dims?.width ?? 1,\n        this.descriptor?.height ?? meta?.y ?? dims?.height ?? 1,\n        meta?.z || this.loaded?.imageInfo.urls?.length || dims?.depth || 1,\n      ],\n      // A descriptor that reports only mppX is square-pixel by convention, which is\n      // what the 2D scale bar already assumes of it.\n      mpp: [mppX, this.descriptor?.mppY || meta?.mppY || mppX, meta?.mppZ || 0],\n    };\n  }\n\n  /**\n   * Assemble a downsampled uint8 volume (luminance) from the per-slice tile endpoint. Slices are\n   * fetched with bounded concurrency (keeps the connection pool full without flooding it on a deep\n   * stack) and read into the volume as each arrives, driving {@link stackLoadingProgress$} so the\n   * host shows a determinate progress bar instead of a bare spinner.\n   */\n  private async assembleVolume(\n    info: IImageInfo | undefined,\n    opts: { maxSlice?: number; sliceStep?: number } = {},\n    channel?: number,\n  ): Promise<{ data: Uint8Array; width: number; height: number; depth: number } | null> {\n    const token = this.loadToken; // bail if a Cancel / new plot bumps this while we fetch\n    const fullDepth = info?.imageMeta?.[0]?.z || info?.urls?.length || 1;\n    if (fullDepth < 1) {\n      console.warn('[napari-js] no slices to assemble a volume');\n      return null;\n    }\n    const step = Math.max(1, Math.floor(opts.sliceStep ?? 1));\n    const maxSlice = opts.maxSlice ?? VOLUME_MAX_SLICE;\n    // Source-slice indices sampled into the volume (every `step`th plane → low-res is faster).\n    const zIndices: number[] = [];\n    for (let z = 0; z < fullDepth; z += step) zIndices.push(z);\n    const depth = zIndices.length;\n\n    this.stackLoadingProgress$.next(0);\n    try {\n      // Fetch each slice at a pyramid level matching `maxSlice` (budget scales with the decimate\n      // factor), so a higher factor pulls a finer level → more real in-plane detail; then downsample\n      // to `maxSlice`. `channel` selects a band (multichannel volume); omit for the grayscale\n      // composite. The caller owns the stackLoading flag (multichannel assembles channels in turn).\n      const budget = this.tileBudgetFor(maxSlice);\n      const first = await this.fetchSlice(zIndices[0], channel, budget);\n      const scale = Math.min(1, maxSlice / Math.max(first.width, first.height, 1));\n      const width = Math.max(1, Math.round(first.width * scale));\n      const height = Math.max(1, Math.round(first.height * scale));\n      const data = new Uint8Array(width * height * depth);\n\n      let canvas: HTMLCanvasElement | OffscreenCanvas;\n      if (typeof OffscreenCanvas !== 'undefined') {\n        canvas = new OffscreenCanvas(width, height);\n      } else {\n        canvas = document.createElement('canvas');\n        canvas.width = width;\n        canvas.height = height;\n      }\n      const ctx = canvas.getContext('2d') as\n        | CanvasRenderingContext2D\n        | OffscreenCanvasRenderingContext2D\n        | null;\n      if (!ctx) throw new Error('napari-js volume assembly: 2D context unavailable');\n\n      // Read one fetched slice bitmap into the volume plane `z` (luminance). Synchronous between\n      // awaits, so the shared 2D context is safe to reuse across the concurrent fetch workers.\n      let done = 0;\n      const readSlice = (z: number, bmp: ImageBitmap): void => {\n        ctx.clearRect(0, 0, width, height);\n        ctx.drawImage(bmp, 0, 0, width, height);\n        const rgba = ctx.getImageData(0, 0, width, height).data;\n        const base = z * width * height;\n        for (let i = 0; i < width * height; i++) {\n          data[base + i] =\n            (rgba[i * 4] * 0.299 + rgba[i * 4 + 1] * 0.587 + rgba[i * 4 + 2] * 0.114) | 0;\n        }\n        bmp.close?.();\n        done++;\n        this.stackLoadingProgress$.next(Math.round((done / depth) * 100));\n      };\n\n      readSlice(0, first);\n\n      // Remaining planes via a small pool of workers draining a shared queue. Each plane `p`\n      // maps to source slice `zIndices[p]` (subsampled for low-res).\n      const pending: number[] = [];\n      for (let p = 1; p < depth; p++) pending.push(p);\n      const worker = async (): Promise<void> => {\n        for (;;) {\n          const p = pending.shift();\n          if (p === undefined || this.loadToken !== token) return;\n          readSlice(p, await this.fetchSlice(zIndices[p], channel, budget));\n        }\n      };\n      const poolSize = Math.min(VOLUME_FETCH_CONCURRENCY, Math.max(1, depth - 1));\n      await Promise.all(Array.from({ length: poolSize }, () => worker()));\n\n      if (this.loadToken !== token) return null; // cancelled → don't render a partial volume\n      return { data, width, height, depth };\n    } finally {\n      this.stackLoadingProgress$.next(0);\n    }\n  }\n\n  /**\n   * Mount the NAPARI_SCATTER 2D scatter: the slice image with a points layer at each region's\n   * centroid (napari-js analog of Plotly's region-centroid scatter). Rebuilds the points live as\n   * regions change.\n   */\n  private async mountScatter(viewer: Viewer, host: HTMLElement, z: number): Promise<void> {\n    await this.renderImage(z);\n    this.fitCameraSoon();\n    this.subscribeDisplayState();\n    this.installScaleBar();\n    // This mode plots REGION centroids, so without the region tools there is no\n    // way to produce a point — drawing a region now adds one immediately.\n    this.install2dInteraction(viewer, host);\n    this.rebuildScatterPoints();\n    this.scatterRegionSub = this.regionStore\n      .getRegionUpdateEvent()\n      .subscribe(() => this.rebuildScatterPoints());\n    this.scheduleReadback();\n  }\n\n  /** (Re)build the 2D scatter's point layer at the current region centroids. */\n  private rebuildScatterPoints(): void {\n    const v = this.viewer;\n    if (!v) return;\n    if (this.scatter2dPoints) {\n      v.layers.remove(this.scatter2dPoints);\n      this.scatter2dPoints = null;\n    }\n    const centroids = this.regionCentroids();\n    if (centroids.length === 0) return;\n    this.scatter2dPoints = v.addPoints(centroids, {\n      size: 12,\n      faceColor: [1, 0.85, 0.2, 1],\n      borderColor: [0, 0, 0, 1],\n      borderWidth: 2,\n    });\n  }\n\n  /** Region centroids as flat `[x, y, …]` data coords (rectangle / polygon / multipolygon). */\n  private regionCentroids(): Float32Array {\n    const out: number[] = [];\n    const polyCentroid = (xs: number[], ys: number[]): void => {\n      const n = xs.length;\n      if (n === 0) return;\n      let cx = 0;\n      let cy = 0;\n      for (let i = 0; i < n; i++) {\n        cx += xs[i];\n        cy += ys[i];\n      }\n      out.push(cx / n, cy / n);\n    };\n    for (const r of this.regionStore.getRegions()) {\n      const b = r.bounds as\n        | { x: number; y: number; width: number; height: number }\n        | { xpoints: number[]; ypoints: number[] }\n        | { polygons: { xpoints: number[]; ypoints: number[] }[] }\n        | null\n        | undefined;\n      if (!b) continue;\n      if ('width' in b && 'x' in b) {\n        out.push(b.x + b.width / 2, b.y + b.height / 2);\n      } else if ('xpoints' in b) {\n        polyCentroid(b.xpoints, b.ypoints);\n      } else if ('polygons' in b) {\n        for (const p of b.polygons) polyCentroid(p.xpoints, p.ypoints);\n      }\n    }\n    return new Float32Array(out);\n  }\n\n  /**\n   * The interaction stack every 2D mode needs: the region overlay (draw/select/edit), the pixel\n   * tools that read back displayed pixels (wand, brush, vertex eraser, zoom-to-box, SAM/cellpose),\n   * and a camera hook that keeps that readback current as the view pans/zooms and tiled levels\n   * load.\n   *\n   * Extracted because forgetting it is invisible: the toolbar gates its region buttons on 2D-vs-3D\n   * rather than on plot type, so a 2D mode that skips this shows every tool and silently does\n   * nothing. That is exactly what happened to the spatial and region-centroid scatter modes.\n   */\n  private install2dInteraction(viewer: Viewer, host: HTMLElement): void {\n    this.regionOverlay = new NapariRegionOverlay(host, viewer, this.regionStore);\n    this.buildToolHosts();\n    this.cameraReadbackOff = viewer.camera.changed.connect(() => this.armReadback());\n  }\n\n  // ── Spatial omics ────────────────────────────────────────────────────────────────────────\n\n  /** Marker radius (image px) for a dataset that declares none — segmented cells often don't. */\n  private static readonly SPATIAL_FALLBACK_RADIUS = 4;\n  /** Smallest marker DIAMETER, in slice pixels, over a volume-backed dataset. A cell's real\n   *  size is honoured wherever it survives the grid: the ABC atlas serves 5 µm radii on a\n   *  40 µm/px template, so drawing them to scale would put every cell a fifth of a pixel wide\n   *  and the section would come up empty. The point-size control scales up from this floor. */\n  private static readonly SPATIAL_SLICE_MIN_DIAMETER_PX = 1.5;\n  /** Longest side of the gene-map raster, in field pixels. A gene map is a smooth\n   *  field read as territory, so it gains nothing from matching a 2 Gpx slide's\n   *  resolution — and the estimate costs one pass over this many pixels. */\n  private static readonly GENE_MAP_MAX_SIDE = 512;\n  /** Kernel σ in field pixels at smoothing 1: wide enough to read between cells,\n   *  tight enough to keep a nucleus-scale structure distinct. */\n  private static readonly GENE_MAP_SIGMA = 2.5;\n  /** Clusters drawn as density volumes at once. Past a handful, additive translucent\n   *  clouds stop being separable by eye — and each one is a full rasterisation. */\n  private static readonly DENSITY_MAX_CLUSTERS = 6;\n  /** Colour for observations when nothing is selected to colour by: visible, neutral, and\n   *  obviously not encoding anything. */\n  /** How much larger a selected marker is drawn, so a small selection is findable inside a\n   *  3.7M-point cloud rather than merely brighter. */\n  private static readonly SPATIAL_SELECTED_SIZE_SCALE = 1.6;\n\n  private static readonly SPATIAL_NEUTRAL_COLOR: [number, number, number, number] =\n    [0.35, 0.72, 0.95, 0.9];\n\n  /**\n   * Mount the SPATIAL_OMICS view: the tissue image with one marker per observation, coloured by\n   * an annotation column or a gene. The markers rebuild whenever the dataset or the view state\n   * changes, so switching the colour-by column does not remount the scene.\n   *\n   * Sets up the full 2D interaction stack — region overlay, pixel-tool hosts, readback currency —\n   * exactly as the plain image view does. That is NOT optional here: this mode's selection is\n   * driven by drawn ROIs, so without the overlay there is no way to make a selection at all.\n   */\n  private async mountSpatialOmics(viewer: Viewer, host: HTMLElement, z: number): Promise<void> {\n    await this.renderImage(z);\n    // Only fit to the image when this dataset actually has one. Otherwise there is\n    // nothing to fit, `imageW`/`imageH` still hold the LAST image's dimensions, and\n    // this fits to those — and because it defers to a frame, it lands AFTER the points\n    // are added and overwrites the framing they set. That is what left an image-less\n    // dataset as a ten-pixel speck off to one side.\n    if (this.spatialLatest?.[0]?.imageRef) this.fitCameraSoon();\n    this.subscribeDisplayState();\n    this.installScaleBar();\n    this.install2dInteraction(viewer, host);\n    this.installSpatialHover(host);\n    this.subscribeSpatial();\n    this.scheduleReadback();\n  }\n\n  /**\n   * Region drawing for the 3D cloud.\n   *\n   * Reuses {@link NapariRegionOverlay} verbatim by handing it a SCREEN-SPACE viewer: the drawn\n   * shape is a lasso in canvas pixels, so \"world\" is the canvas and both transforms are identity\n   * (bar the client→canvas offset). Every existing tool — rectangle, polygon, freehand — therefore\n   * works in 3D with no new drawing code.\n   *\n   * A screen-space shape stops meaning anything the moment the camera moves, so an orbit clears\n   * the drawn regions. The SELECTION it produced is kept: that is the durable artefact, and the\n   * highlighted points stay highlighted from every angle.\n   */\n  private install3dInteraction(viewer: Viewer, host: HTMLElement): void {\n    const canvasRect = () => this.canvas?.getBoundingClientRect();\n    const screenSpace: OverlayViewer = {\n      canvasToWorld: (clientX: number, clientY: number) => {\n        const r = canvasRect();\n        return r ? [clientX - r.left, clientY - r.top] : [clientX, clientY];\n      },\n      // Already canvas pixels.\n      worldToCanvas: (x: number, y: number) => [x, y],\n      setControlsEnabled: (enabled: boolean) => viewer.setControlsEnabled(enabled),\n      camera: viewer.camera3d,\n    };\n    this.regionOverlay = new NapariRegionOverlay(host, screenSpace, this.regionStore);\n    this.buildToolHosts();\n    this.cameraReadbackOff = viewer.camera3d.changed.connect(() => {\n      // Only while nothing is being drawn — clearing mid-gesture would delete the\n      // shape under the user's cursor.\n      if (this.regionStore.getRegions().length > 0) this.regionStore.setRegions([]);\n    });\n  }\n\n  /** Movement, in screen pixels, under which a press-release is a CLICK and not a\n   *  drag. An orbit or a pan starts the same way, so the two have to be told\n   *  apart by how far the pointer travelled. */\n  private static readonly CLICK_SLOP_PX = 4;\n  /** Longest press-release still treated as a click. A long press with the mouse\n   *  held still is more likely an interrupted drag than a selection. */\n  private static readonly CLICK_MAX_MS = 600;\n  /** Pointer distance, in screen pixels, that still counts as \"on\" a marker.\n   *  Generous relative to a 1.5px disc: the cursor is a blunt instrument, and a\n   *  tooltip you have to hunt for is worse than none. */\n  private static readonly HOVER_RADIUS_PX = 10;\n\n  /**\n   * Cursor tooltip for the spatial views: hover a marker, read its class.\n   *\n   * A 34-entry legend cannot be read back from a dot — several classes get\n   * similar colours, and matching one to a swatch by eye is exactly the task this\n   * removes. It reports whatever the cloud is CURRENTLY coloured by, so it and\n   * the legend can never say different things.\n   *\n   * Listens on the HOST rather than the canvas so it keeps working over the region\n   * overlay (an SVG covering the canvas, which would otherwise swallow every\n   * move), and throttles to one hit-test per animation frame: a pointermove can\n   * fire far more often than that, and each test is a pass over the cloud.\n   */\n  private installSpatialHover(host: HTMLElement): void {\n    this.removeSpatialHover();\n    this.spatialTooltip = new NapariSpatialTooltip(host);\n\n    const onMove = (e: PointerEvent) => {\n      const canvas = this.canvas;\n      if (!canvas) return;\n      const rect = canvas.getBoundingClientRect();\n      this.hoverPointer = {\n        x: e.clientX - rect.left,\n        y: e.clientY - rect.top,\n        clientX: e.clientX,\n        clientY: e.clientY,\n      };\n      if (this.hoverFrame) return;\n      this.hoverFrame = requestAnimationFrame(() => {\n        this.hoverFrame = 0;\n        this.updateHover(host);\n      });\n    };\n    const onLeave = () => {\n      this.hoverPointer = null;\n      this.spatialTooltip?.hide();\n    };\n\n    // A click on a marker selects its class, exactly as clicking that class in the\n    // panel's legend does — including clicking again to clear, so a click is\n    // always reversible. Tracked as down/up rather than bound to `click` so a DRAG\n    // (an orbit in 3D, a pan in 2D) can be told apart from a click: the gesture\n    // has to move less than a few pixels and be over quickly.\n    let down: { x: number; y: number; t: number } | null = null;\n    const onDown = (e: MouseEvent) => {\n      down = { x: e.clientX, y: e.clientY, t: Date.now() };\n    };\n    const onUp = (e: MouseEvent) => {\n      const start = down;\n      down = null;\n      if (!start) return;\n      const moved = Math.hypot(e.clientX - start.x, e.clientY - start.y);\n      if (moved > NapariVisualizerService.CLICK_SLOP_PX) return;\n      if (Date.now() - start.t > NapariVisualizerService.CLICK_MAX_MS) return;\n      // A region tool owns the pointer while it is active, and placing a polygon\n      // vertex is also a click that does not move.\n      if (this.regionOverlay?.toolActive) return;\n      this.selectClassAt(e.clientX, e.clientY);\n    };\n\n    host.addEventListener('pointermove', onMove);\n    host.addEventListener('pointerleave', onLeave);\n    host.addEventListener('pointerdown', onDown);\n    host.addEventListener('pointerup', onUp);\n    this.hoverOff.push(() => host.removeEventListener('pointermove', onMove));\n    this.hoverOff.push(() => host.removeEventListener('pointerleave', onLeave));\n    this.hoverOff.push(() => host.removeEventListener('pointerdown', onDown));\n    this.hoverOff.push(() => host.removeEventListener('pointerup', onUp));\n\n    // In 3D the cached positions are screen pixels, so an orbit invalidates them.\n    const camera = this.viewer?.camera3d;\n    if (camera && isSpatialOmics3d(this.currentPlotType)) {\n      const off = camera.changed.connect(() => {\n        this.spatialSceneRev++;\n      });\n      this.hoverOff.push(off);\n    }\n  }\n\n  private removeSpatialHover(): void {\n    for (const off of this.hoverOff) off();\n    this.hoverOff = [];\n    if (this.hoverFrame) cancelAnimationFrame(this.hoverFrame);\n    this.hoverFrame = 0;\n    this.hoverPointer = null;\n    this.spatialTooltip?.dispose();\n    this.spatialTooltip = null;\n    this.hoverPositions = null;\n    this.hoverPositionsRev = -1;\n    this.hoverIndex = null;\n  }\n\n  /** Hit-test the last pointer position and show or hide the tooltip. */\n  private updateHover(host: HTMLElement): void {\n    const tip = this.spatialTooltip;\n    const pointer = this.hoverPointer;\n    const dataset = this.spatialLatest?.[0];\n    if (!tip || !pointer || !dataset) return;\n\n    const positions = this.hoverPositionsFor(dataset.observations);\n    if (!positions) {\n      tip.hide();\n      return;\n    }\n    const is3d = isSpatialOmics3d(this.currentPlotType);\n    // 3D compares screen pixels directly; 2D holds world positions, so the radius\n    // is converted once instead of projecting the whole cloud.\n    const zoom = is3d ? 1 : (this.viewer?.camera.zoom ?? 1);\n    const radius = NapariVisualizerService.HOVER_RADIUS_PX / (zoom > 0 ? zoom : 1);\n    let x = pointer.x;\n    let y = pointer.y;\n    if (!is3d) {\n      const world = this.viewer?.canvasToWorld(pointer.clientX, pointer.clientY);\n      if (!world) {\n        tip.hide();\n        return;\n      }\n      [x, y] = world;\n    }\n\n    const hit = this.pickObservation(positions, x, y, radius, is3d);\n    const lines = hoverText(this.hoverSource, hit);\n    if (!lines) {\n      tip.hide();\n      return;\n    }\n    const rect = host.getBoundingClientRect();\n    tip.show(lines, pointer.clientX - rect.left, pointer.clientY - rect.top);\n  }\n\n  /**\n   * Select the class of the marker at a client position — the canvas equivalent of\n   * clicking that class in the panel's legend, and the same selection object, so\n   * the two controls cannot produce different results.\n   *\n   * Clicking a class that is already the whole selection CLEARS it, which is what\n   * the legend does. Compared against the selection itself rather than against a\n   * remembered click, so selecting from the legend and then clicking the same\n   * class on the canvas still toggles.\n   */\n  private selectClassAt(clientX: number, clientY: number): void {\n    const source = this.hoverSource;\n    const store = this.selectionStore;\n    const dataset = this.spatialLatest?.[0];\n    // Only a categorical source has classes to select. A gene is continuous:\n    // there is no set of cells that \"is\" a value.\n    if (!store || !dataset || source?.kind !== 'categorical') return;\n\n    const positions = this.hoverPositionsFor(dataset.observations);\n    if (!positions) return;\n    const canvas = this.canvas;\n    if (!canvas) return;\n    const rect = canvas.getBoundingClientRect();\n    const is3d = isSpatialOmics3d(this.currentPlotType);\n    const zoom = is3d ? 1 : (this.viewer?.camera.zoom ?? 1);\n    const radius = NapariVisualizerService.HOVER_RADIUS_PX / (zoom > 0 ? zoom : 1);\n    let x = clientX - rect.left;\n    let y = clientY - rect.top;\n    if (!is3d) {\n      const world = this.viewer?.canvasToWorld(clientX, clientY);\n      if (!world) return;\n      [x, y] = world;\n    }\n\n    const hit = nearestObservation(positions, x, y, radius);\n    if (hit < 0) return;\n    const code = source.codes[hit];\n    // A cell the annotation does not cover has no class to select.\n    if (code === undefined || code === NO_CATEGORY) return;\n\n    const next = selectByCategory(source.codes, code);\n    const current = store.current();\n    if (sameSelection(current, next)) {\n      store.clear();\n      return;\n    }\n    store.set(next);\n  }\n\n  /**\n   * Which observation is under the cursor.\n   *\n   * In 3D this defers to napari-js's {@link nearestProjectedIndex} WITH the depths the\n   * projection produced, so the front-most candidate wins. That matters more than it\n   * sounds: the renderer depth-tests the billboards, and in a 3.7M-point cloud the cursor\n   * covers many of them — picking the one nearest the cursor's centre regularly names a\n   * cell that something else is drawn over, which reads as a wrong tooltip rather than as\n   * a subtlety of picking.\n   *\n   * In 2D the positions are WORLD coordinates on one plane, so there is no depth to break\n   * ties with and the existing nearest-marker rule is the right one.\n   */\n  private pickObservation(\n    positions: Float32Array,\n    x: number,\n    y: number,\n    radius: number,\n    is3d: boolean,\n  ): number {\n    if (!is3d) return nearestObservation(positions, x, y, radius);\n    // The cloud draws a selected marker LARGER, so the pick has to use the same radius the\n    // renderer used — otherwise the highlighted cells, the ones a reader is most likely to\n    // be pointing at, are the hardest to hover.\n    const scale = NapariVisualizerService.SPATIAL_SELECTED_SIZE_SCALE;\n    const mask = this.selectionStore?.current()?.mask;\n    const opts = mask?.length\n      ? { radiusAt: (i: number) => (mask[i] ? radius * scale : radius) }\n      : undefined;\n    // `radius` still bounds which buckets are visited, so it has to be the LARGEST any\n    // point can claim, not the base one.\n    const reach = mask?.length ? radius * scale : radius;\n    if (this.hoverIndex) return this.hoverIndex.pick(x, y, reach, opts);\n    return nearestProjectedIndex(positions, x, y, reach, this.spatialDepths3d, opts);\n  }\n\n  /**\n   * Positions to hit-test against, rebuilt only when the scene or camera moved.\n   *\n   * A pass over 3.7M observations is not something to do per pointermove, and the\n   * cloud does not move between frames unless something says it did.\n   */\n  private hoverPositionsFor(obs: SpatialObservations): Float32Array | null {\n    if (this.hoverPositions && this.hoverPositionsRev === this.spatialSceneRev) {\n      return this.hoverPositions;\n    }\n    const is3d = isSpatialOmics3d(this.currentPlotType);\n    const built = is3d\n      ? this.getSpatialScreenProjection(obs)\n      : this.hoverWorldPositions(obs);\n    this.hoverPositions = built;\n    this.hoverPositionsRev = this.spatialSceneRev;\n    // Built here, in the same lazy slot, so it is paid for on the first hover after the\n    // scene moved and not on every frame of an orbit. Only worth it past the point where\n    // the linear scan stops being free; below that the build costs more than it saves.\n    this.hoverIndex = null;\n    if (is3d && built && this.canvas && built.length / 2 >= SCREEN_INDEX_MIN_POINTS) {\n      const w = this.canvas.clientWidth || this.canvas.width;\n      const h = this.canvas.clientHeight || this.canvas.height;\n      if (w && h) {\n        this.hoverIndex = new ScreenIndex(\n          { screen: built, depth: this.spatialDepths3d ?? new Float32Array(built.length / 2) },\n          w,\n          h,\n          // The largest radius any pick here can claim: the base hover radius, times the\n          // scale a SELECTED marker is drawn at. Stated rather than left to the default,\n          // because it is what decides whether a marker straddling the canvas edge is\n          // found — its centre is off screen while part of it is not.\n          {\n            maxReach: NapariVisualizerService.HOVER_RADIUS_PX\n              * NapariVisualizerService.SPATIAL_SELECTED_SIZE_SCALE,\n          },\n        );\n      }\n    }\n    return built;\n  }\n\n  /**\n   * The 2D markers' WORLD positions, indexed by observation, NaN for any not on\n   * the displayed plane — the same affine and the same subset the marker layer was\n   * built from, so the tooltip cannot point at a cell that is not drawn.\n   */\n  private hoverWorldPositions(obs: SpatialObservations): Float32Array | null {\n    const dataset = this.spatialLatest?.[0];\n    if (!dataset || obs.count === 0) return null;\n    const slab = this.spatialSlab(dataset);\n    const ref = slab?.ref ?? dataset.imageRef;\n    const [sx, sy] = ref?.scale ?? [1, 1];\n    const [tx, ty] = ref?.translate ?? [0, 0];\n    const drawn = slab?.indices ?? null;\n    const out = new Float32Array(obs.count * 2).fill(NaN);\n    const n = drawn ? drawn.length : obs.count;\n    for (let k = 0; k < n; k++) {\n      const i = drawn ? drawn[k] : k;\n      out[i * 2] = obs.x[i] * sx + tx;\n      out[i * 2 + 1] = obs.y[i] * sy + ty;\n    }\n    return out;\n  }\n\n  /**\n   * What the tooltip says, resolved once per colour source rather than per hover.\n   *\n   * Fetched separately from the colouring on purpose: the reference port caches\n   * columns, but a host's need not, and re-fetching a 3.7M-element vector because\n   * the pointer moved would be indefensible either way.\n   */\n  private async resolveHoverSource(\n    dataset: SpatialDataset | null, view: SpatialViewState,\n  ): Promise<void> {\n    const port = this.spatialData;\n    const colorBy = view.colorBy;\n    const key = dataset && colorBy\n      ? `${dataset.id}|${colorBy.kind}:${colorBy.name}`\n      : null;\n    if (key === this.hoverSourceKey) return;\n    // The key is committed only where a value is actually stored. Setting it up\n    // front would mean a resolution that loses the race leaves the key claiming a\n    // source that was never stored — and since every later emission carries the\n    // same key, it would short-circuit here forever and the tooltip would stay\n    // silent for the rest of the session.\n    const token = ++this.hoverSourceToken;\n    // No colour source means nothing is being said about the cells, so there is no\n    // cluster to name and the tooltip stays silent.\n    if (!key || !dataset || !colorBy || !port) {\n      this.hoverSource = null;\n      this.hoverSourceKey = key;\n      return;\n    }\n    try {\n      if (colorBy.kind === 'column') {\n        const column = await port.getColumn(colorBy.name);\n        if (token !== this.hoverSourceToken) return;\n        this.hoverSource = isCategoricalColumn(column)\n          ? {\n            kind: 'categorical',\n            name: colorBy.name,\n            categories: column.meta.categories,\n            codes: column.codes,\n          }\n          : {\n            kind: 'continuous',\n            name: colorBy.name,\n            values: column.values,\n            ...(column.meta.unit ? { unit: column.meta.unit } : {}),\n          };\n        this.hoverSourceKey = key;\n        return;\n      }\n      const values = await port.getFeatureVector(colorBy.name);\n      if (token !== this.hoverSourceToken) return;\n      this.hoverSource = {\n        kind: 'continuous',\n        name: colorBy.name,\n        values,\n        ...(dataset.features?.unit ? { unit: dataset.features.unit } : {}),\n      };\n      this.hoverSourceKey = key;\n    } catch {\n      if (token !== this.hoverSourceToken) return;\n      // The tooltip is an extra; a failed fetch must not disturb the render. The\n      // key is left unset so a later emission retries rather than inheriting a\n      // permanent silence.\n      this.hoverSource = null;\n      this.hoverSourceKey = null;\n    }\n  }\n\n  /**\n   * Project every observation to canvas pixels under the current 3D camera.\n   *\n   * The projection itself is the renderer's: `viewer.projectPoints` owns the camera, the\n   * viewport in CSS pixels, the perspective divide and the y-flip. This used to be fifteen\n   * lines of column-major matrix arithmetic here, duplicating a second copy in\n   * `napari-axes-labels` — and the two had drifted on what to do with a NaN w.\n   *\n   * What is left is the part that is genuinely this adapter's: SCATTERING the drawn subset\n   * back into observation order. The cloud holds only the points of the displayed section,\n   * in its own packing; every consumer indexes by observation. NaN stands for \"not on\n   * screen\", which is also the right answer for an observation whose section is hidden.\n   *\n   * Null when the 3D cloud is not mounted, so the caller falls back to the 2D affine path.\n   */\n  getSpatialScreenProjection(obs: SpatialObservations): Float32Array | null {\n    const viewer = this.viewer;\n    if (!viewer || !this.spatialPositions3d) return null;\n\n    const projected = viewer.projectPoints(this.spatialPositions3d, this.spatialProjection3d);\n    if (!projected) return null;\n    // Reused across camera changes: at 3.7M observations this is a 30 MB allocation that\n    // would otherwise happen on every orbit.\n    this.spatialProjection3d = projected;\n\n    const drawn = this.spatialDrawn3d;\n    const { screen, depth } = projected;\n    const count = screen.length >> 1;\n    const out = new Float32Array(obs.count * 2).fill(NaN);\n    const depths = new Float32Array(obs.count).fill(NaN);\n    for (let k = 0; k < count; k++) {\n      const i = drawn ? drawn[k] : k;\n      if (i >= obs.count) continue;\n      out[i * 2] = screen[k * 2];\n      out[i * 2 + 1] = screen[k * 2 + 1];\n      depths[i] = depth[k];\n    }\n    // Kept beside the screen positions so the hover pick can prefer the FRONT-most point\n    // under the cursor rather than the one nearest its centre — which in a dense cloud is\n    // regularly something the renderer drew another point over.\n    this.spatialDepths3d = depths;\n    return out;\n  }\n\n  /** Rebuild the markers on any dataset or view-state change. */\n  private subscribeSpatial(): void {\n    this.spatialSub?.unsubscribe();\n    const port = this.spatialData;\n    if (!port) return;\n    const selection$ = this.selectionStore?.getSelection$() ?? of(emptySelection());\n    // The display colormap is an input here, not just something read at build\n    // time: `continuousColormap: null` means \"follow the image's colormap\", and a\n    // setting that only takes effect at the next unrelated rebuild is not one.\n    this.spatialSub = combineLatest([\n      port.getDataset$(), this.store.getSpatialView$(), selection$,\n      this.store.getColormap(), this.store.getReverseScale(),\n    ]).subscribe(([dataset, view, selection, colormap, reverse]) => {\n      this.currentColormap = (colormap as ColormapNode) ?? null;\n      this.currentReverse = !!reverse;\n      // Kept so a slice change can redraw the markers for the new plane, which\n      // arrives through setZIndex rather than through any of these streams.\n      this.spatialLatest = [dataset, view, selection];\n      // The markers are about to move or change meaning, so both halves of the\n      // tooltip — where the points are, and what they are — are stale.\n      this.spatialSceneRev++;\n      void this.resolveHoverSource(dataset, view);\n      void (isSpatialOmics3d(this.currentPlotType)\n        ? this.rebuildSpatialPoints3d(dataset, view, selection)\n        : this.rebuildSpatialPoints(dataset, view, selection));\n    });\n  }\n\n  /** (Re)build the observation marker layer for the current dataset + view state. */\n  private async rebuildSpatialPoints(\n    dataset: SpatialDataset | null, view: SpatialViewState,\n    selection: SpatialSelectionMask = emptySelection(),\n  ): Promise<void> {\n    const viewer = this.viewer;\n    if (!viewer) return;\n    const token = ++this.spatialRebuildToken;\n\n    // Resolve colours BEFORE touching the scene: a gene fetch can fail or be\n    // superseded, and dropping the existing layer first would blank the view.\n    let faceColor: ReturnType<typeof toRgbaTuples> | [number, number, number, number];\n    try {\n      faceColor = dataset\n        ? await this.spatialFaceColors(dataset, view, selection)\n        : NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;\n    } catch (err) {\n      console.warn('[napari-js] spatial colouring failed — falling back to a flat colour', err);\n      faceColor = NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;\n    }\n    // A newer rebuild (or a teardown) started while the vector was in flight.\n    if (token !== this.spatialRebuildToken || this.viewer !== viewer) return;\n\n    if (!dataset || dataset.observations.count === 0) {\n      if (this.spatialPoints) {\n        viewer.layers.remove(this.spatialPoints);\n        this.spatialPoints = null;\n        this.spatialLayerKey = null;\n      }\n      if (this.geneMapLayer) {\n        viewer.layers.remove(this.geneMapLayer);\n        this.geneMapLayer = null;\n        this.geneMapKey = null;\n      }\n      return;\n    }\n\n    const obs = dataset.observations;\n    // A dataset whose image IS its volume shows ONE PLANE at a time, so the\n    // markers are the observations in the displayed plane, drawn in that plane's\n    // pixel grid. Without the filter the specimen's whole depth piles onto one\n    // section and reads as a smear; without the affine the coordinates are read\n    // as pixels and land off the slice entirely.\n    const slab = this.spatialSlab(dataset);\n    // The gene map goes UNDER the cells, so it is settled before they are added.\n    await this.ensureGeneMap(viewer, dataset, view, selection, slab);\n    if (token !== this.spatialRebuildToken || this.viewer !== viewer) return;\n    const ref = slab?.ref ?? dataset.imageRef;\n    const base = markerDiameters(obs, NapariVisualizerService.SPATIAL_FALLBACK_RADIUS);\n    const scale = view.pointScale > 0 ? view.pointScale : 1;\n    const floor = slab?.minDiameter ?? 0;\n    const sizeOf = (i: number) =>\n      Math.max(typeof base === 'number' ? base : base[i], floor) * scale;\n    const size: number | Float32Array =\n      typeof base === 'number' && !slab\n        ? Math.max(base, floor) * scale\n        : Float32Array.from(slab?.indices ?? { length: obs.count }, (_v, i) =>\n            sizeOf(slab ? slab.indices[i] : i));\n\n    // napari's image view CLEARS the whole layer list on every render, so the\n    // markers go with it whenever the image is re-rendered — a scrub, a contrast\n    // change. The cached handle is then detached, and mutating it draws nothing:\n    // treat a layer that is no longer in the scene as absent so it gets re-added.\n    if (this.spatialPoints && !viewer.layers.items.includes(this.spatialPoints)) {\n      this.spatialPoints = null;\n      this.spatialLayerKey = null;\n    }\n\n    // A size/colour/opacity/selection change is DISPLAY-only: mutate the layer\n    // rather than dropping and re-adding it. Both setters bump the layer's\n    // dataVersion, which is what makes napari-js rebuild the instance buffer and\n    // redraw — and it avoids rebuilding 84k positions to change one number.\n    // The slice is part of the key: a scrub changes WHICH observations are drawn,\n    // which is geometry, not display.\n    const key = `${dataset.id}:${obs.count}:${slab?.slice ?? ''}`;\n    if (this.spatialPoints && key === this.spatialLayerKey) {\n      this.spatialPoints.size = size;\n      this.spatialPoints.faceColor = this.gatherColors(faceColor, slab?.indices) as never;\n      viewer.requestRender();\n      return;\n    }\n\n    if (this.spatialPoints) {\n      viewer.layers.remove(this.spatialPoints);\n      this.spatialPoints = null;\n    }\n\n    const drawn = slab?.indices;\n    const count = drawn ? drawn.length : obs.count;\n    const positions = new Float32Array(count * 2);\n    for (let i = 0; i < count; i++) {\n      const o = drawn ? drawn[i] : i;\n      positions[i * 2] = obs.x[o];\n      positions[i * 2 + 1] = obs.y[o];\n    }\n    this.spatialLayerKey = key;\n    this.spatialPoints = viewer.addPoints(positions, {\n      name: 'observations',\n      size,\n      faceColor: this.gatherColors(faceColor, drawn),\n      // No border: at Visium spot density an outline per marker reads as noise,\n      // and it costs a second colour array.\n      borderWidth: 0,\n      // The dataset's data->world affine. SpatialData records one per coordinate\n      // system (Visium spot coords are in the FULL-resolution frame while the\n      // served image may be the hires downscale), so without this the markers\n      // land in the right shape at the wrong scale. Defaults to identity when\n      // the coordinates are already in the image's pixel space.\n      scale: ref?.scale ?? [1, 1],\n      translate: ref?.translate ?? [0, 0],\n    });\n    this.frameSpatialPointsOnce(viewer, dataset.id, positions, !!ref);\n    this.hideForeignImage(viewer, !!ref || !!dataset.volume);\n    this.setRegionGridFor(dataset, positions);\n  }\n\n  /**\n   * Tell the region overlay how finely a drawn vertex may be placed.\n   *\n   * Region geometry is stored in whole world units, which is right when the world IS\n   * pixels — a region should align to them. It is wrong for a dataset that registers onto\n   * no image: seqFISH's observations span about 5 x 7 units in total, so whole-unit\n   * vertices leave roughly six by eight placeable positions across the entire sample and\n   * an ROI cannot be drawn at any zoom. Nothing errors; the tool just cannot express the\n   * shape.\n   *\n   * Keyed on whether the dataset brings PIXELS rather than on the extent, because the\n   * extent cannot tell the two apart — 2,000 units is a small slide or a large section\n   * depending only on what the units are, and only the dataset knows.\n   */\n  private setRegionGridFor(dataset: SpatialDataset, positions: Float32Array): void {\n    const overlay = this.regionOverlay;\n    if (!overlay?.setWorldQuantum) return;\n    if (dataset.imageRef || dataset.volume) {\n      overlay.setWorldQuantum(PIXEL_WORLD_QUANTUM);\n      return;\n    }\n    let minX = Infinity; let maxX = -Infinity; let minY = Infinity; let maxY = -Infinity;\n    for (let i = 0; i < positions.length; i += 2) {\n      const x = positions[i];\n      const y = positions[i + 1];\n      if (!Number.isFinite(x) || !Number.isFinite(y)) continue;\n      if (x < minX) minX = x;\n      if (x > maxX) maxX = x;\n      if (y < minY) minY = y;\n      if (y > maxY) maxY = y;\n    }\n    overlay.setWorldQuantum(worldQuantumForExtent(maxX - minX, maxY - minY));\n  }\n\n  /**\n   * Frame the 2D camera on the observations, for a dataset that brings no image.\n   *\n   * The 2D camera is normally fitted to the IMAGE, because the observations are in that\n   * image's pixel space and framing the image frames them too. A dataset with no\n   * reference image has coordinates in its own units instead — seqFISH's span about\n   * 5x7 — so the image framing left over from whatever was on screen before puts the\n   * whole cloud offscreen: measured at 9.7 x 13.4 PIXELS, centred 256px from where the\n   * camera was looking. The points are all there and drawn; they are a speck. Which\n   * looks exactly like the dataset having failed to load.\n   *\n   * Once per dataset, as napari-js's `fit3d: 'once'` does for the cloud: re-colouring,\n   * slicing or picking a gene re-adds this layer, and re-framing on those would move\n   * the camera under the user — the camera tools and the canvas drag are meant to be\n   * the only things that do.\n   */\n  /**\n   * Hide the image layer for a dataset that brings no image of its own.\n   *\n   * The host's viewer keeps whatever image was last loaded, and for a dataset that\n   * registers onto none that picture belongs to something else entirely — the example's\n   * default slide, say. It is not merely irrelevant: the two live in different coordinate\n   * spaces (image pixels against the embedding's own units), so the leftover is magnified\n   * roughly a hundredfold. At the fitted zoom the camera sits inside its corner, where it\n   * reads as blank background, and it appears only once you zoom out far enough to find\n   * it — which is exactly how it gets noticed.\n   *\n   * Hidden rather than removed, and hidden HERE rather than by clearing the host's image\n   * state: that state drives the whole render pipeline, including a Plotly backend whose\n   * fields are declared with definite-assignment assertions, so emptying it throws from\n   * whichever field the next path happens to read. This touches one layer's visibility\n   * and nothing else.\n   */\n  private hideForeignImage(viewer: Viewer, datasetHasPixels: boolean): void {\n    for (const layer of viewer.layers.items) {\n      if (layer.kind !== 'image') continue;\n      // Re-shown when a dataset that owns an image comes back, so switching between\n      // datasets does not leave the tissue permanently hidden.\n      layer.visible = datasetHasPixels;\n    }\n    viewer.requestRender();\n  }\n\n  private frameSpatialPointsOnce(\n    viewer: Viewer, datasetId: string, positions: Float32Array, registered: boolean,\n  ): void {\n    // Gated on whether THIS dataset registers onto an image, not on `imageW`/`imageH`:\n    // those keep the last plotted image's dimensions after the host clears it, so a\n    // stale 512x383 read as \"there is an image\" and skipped the framing entirely.\n    if (registered) return;\n    // Once per dataset, as napari-js's `fit3d: 'once'` does for the cloud: re-colouring, slicing\n    // or picking a gene re-adds this layer, and re-framing on those would move the\n    // camera under the user — the camera tools and the canvas drag are meant to be the\n    // only things that do.\n    if (this.spatial2dFramed?.viewer === viewer\n      && this.spatial2dFramed.datasetId === datasetId) return;\n\n    const fit = framePositions(\n      positions, this.canvas?.clientWidth ?? 0, this.canvas?.clientHeight ?? 0,\n    );\n    // Null means there is nothing to frame on; leave the camera where it is rather\n    // than moving the view for a dataset we cannot fit.\n    if (!fit) return;\n    viewer.camera.set(fit.center, fit.zoom ?? viewer.camera.zoom);\n    this.spatial2dFramed = { viewer, datasetId };\n  }\n\n  /**\n   * The **gene map**: the active gene's expression as a continuous field drawn under\n   * the cells.\n   *\n   * A scatter coloured by a gene says which cells express it; it cannot say where,\n   * because the eye will not integrate thousands of dots into a territory. The field\n   * is a kernel-weighted MEAN per cell (see `spatial-expression.ts`), so a dense\n   * region does not glow merely for being dense, and it is transparent wherever no\n   * cell was measured — an unsampled gap must not read as \"not expressed\".\n   *\n   * It shares the points' LUT, percentile window and log flag, so the layer under\n   * the cells and the cells themselves cannot disagree about what a colour means.\n   *\n   * Estimated on the DISPLAYED image's pixel grid, coarsened so the long side is at\n   * most {@link GENE_MAP_MAX_SIDE}: a smooth field gains nothing from a slide's full\n   * resolution. For a volume-backed dataset that grid is the current slice, and only\n   * that plane's observations are included — the same rule the markers follow.\n   */\n  private async ensureGeneMap(\n    viewer: Viewer, dataset: SpatialDataset, view: SpatialViewState,\n    selection: SpatialSelectionMask,\n    slab: { ref: SpatialImageRef; indices: Uint32Array; slice: number } | null,\n  ): Promise<void> {\n    const gene = view.geneMap && view.colorBy?.kind === 'feature' ? view.colorBy.name : null;\n    const port = this.spatialData;\n    const smoothing = view.geneMapSmoothing > 0 ? view.geneMapSmoothing : 1;\n    const clip = view.percentileClip ?? [0.01, 0.99];\n\n    // Two clocks: the FIELD depends on the gene, the plane and the bandwidth, while\n    // the colours depend on the window, the log flag and the opacity. Recolouring a\n    // cached field is a fraction of estimating one.\n    const fieldKey = gene\n      ? [dataset.id, gene, slab?.slice ?? '', smoothing, this.selectionRev(selection)].join('|')\n      : null;\n    const key = fieldKey\n      ? [\n        fieldKey, clip.join(','), view.logScale ? 'log' : 'lin', view.geneMapOpacity,\n        this.continuousColormapKey(view),\n      ].join('|')\n      : null;\n    if (key === this.geneMapKey) return;\n\n    if (this.geneMapLayer) {\n      viewer.layers.remove(this.geneMapLayer);\n      this.geneMapLayer = null;\n    }\n    // ANY change here changes the order the cells have to sit above — including the\n    // first one, where there is no previous layer to remove — and the layer list is\n    // append-only. So drop the markers unconditionally and let the rebuild below put\n    // them back on top; otherwise the field is appended over the measurement.\n    if (this.spatialPoints) {\n      viewer.layers.remove(this.spatialPoints);\n      this.spatialPoints = null;\n      this.spatialLayerKey = null;\n    }\n    this.geneMapKey = key;\n    if (!key || !gene || !port) {\n      this.geneMapField = null;\n      this.geneMapFieldKey = null;\n      return;\n    }\n\n    // The raster covers the displayed image; without one there is nothing to\n    // overlay and the cloud is the 3D mode's business, not this one's.\n    const imageW = slab ? dataset.volume!.width : this.imageW;\n    const imageH = slab ? dataset.volume!.height : this.imageH;\n    if (!imageW || !imageH) return;\n    const step = Math.max(\n      1,\n      Math.ceil(Math.max(imageW, imageH) / NapariVisualizerService.GENE_MAP_MAX_SIDE),\n    );\n\n    if (fieldKey !== this.geneMapFieldKey) {\n      let values: Float32Array;\n      try {\n        values = await port.getFeatureVector(gene);\n      } catch (err) {\n        console.warn(`[napari-js] gene map: \"${gene}\" unavailable`, err);\n        this.geneMapKey = null;\n        return;\n      }\n      if (this.viewer !== viewer || this.geneMapKey !== key) return;\n      const inSelection = selection.count > 0 ? maskToIndices(selection.mask) : undefined;\n      this.geneMapField = expressionField(dataset.observations, {\n        ref: slab?.ref ?? dataset.imageRef,\n        width: Math.ceil(imageW / step),\n        height: Math.ceil(imageH / step),\n        step,\n        sigma: NapariVisualizerService.GENE_MAP_SIGMA * smoothing,\n        values,\n        // A plane wins over a selection: the 2D view is showing one section, so a\n        // field spanning the specimen's depth would not be the thing on screen.\n        indices: slab?.indices ?? inSelection,\n      });\n      this.geneMapFieldKey = fieldKey;\n    }\n    const field = this.geneMapField;\n    if (!field) return;\n\n    const node = this.currentColormap as { data?: { value?: unknown } } | null;\n    const lut = spatialContinuousLut(\n      node?.data?.value, this.currentReverse, view.continuousColormap,\n    );\n    const [lo, hi] = contrastWindow(field.mean, clip[0], clip[1]);\n    const rgba = colorExpressionField(field, lut, [lo, hi], {\n      log: view.logScale,\n      // The MAP's own opacity: reading a field under the cells means turning the\n      // cells down, which must not take the field with them.\n      opacity: view.geneMapOpacity,\n    });\n    this.geneMapLayer = viewer.addImage(\n      { kind: 'typed', width: field.width, height: field.height, channels: 4, dtype: 'uint8', data: rgba },\n      {\n        name: `gene map · ${gene}`,\n        scale: [step, step],\n        translate: [0, 0],\n        blending: 'translucent',\n      },\n    );\n    viewer.requestRender();\n  }\n\n  /**\n   * The plane a volume-backed dataset is currently showing: its pixel affine, the\n   * observations that fall in it, and the marker floor that grid needs.\n   *\n   * Null for a dataset with a real `imageRef` (its coordinates are already the\n   * image's pixels and every observation belongs to the one section) and for one\n   * with no volume at all — both of which draw exactly as before.\n   */\n  private spatialSlab(dataset: SpatialDataset): {\n    ref: SpatialImageRef; indices: Uint32Array; slice: number; minDiameter: number;\n  } | null {\n    const volume = dataset.volume;\n    if (dataset.imageRef || !volume) return null;\n    const slice = this.loaded?.z ?? 0;\n    return {\n      ref: volumeImageRef(volume, dataset.micronsPerUnit),\n      indices: observationsInSlice(dataset.observations, volume, slice),\n      slice,\n      minDiameter: NapariVisualizerService.SPATIAL_SLICE_MIN_DIAMETER_PX * volume.voxelSize[0],\n    };\n  }\n\n  /** Per-point colours for the drawn subset. A broadcast tuple stays broadcast —\n   *  it is one colour for every point either way. */\n  private gatherColors<T>(colors: T[] | T, indices?: Uint32Array): T[] | T {\n    if (!indices || !Array.isArray(colors)) return colors;\n    const out: T[] = new Array(indices.length);\n    for (let i = 0; i < indices.length; i++) out[i] = colors[indices[i]];\n    return out;\n  }\n\n  /**\n   * Redraw the observation markers over a freshly rendered image.\n   *\n   * Two reasons, both invisible from the spatial store — which is why a scrub or a\n   * re-render never reached the markers on its own:\n   *  - the image render CLEARS the layer list, taking the markers with it;\n   *  - over a volume-backed dataset the displayed plane decides which\n   *    observations belong on screen at all, so the cells have to move with the\n   *    section rather than hang over a different one.\n   *\n   * Uses the latest values the marker subscription saw; a no-op until it has seen\n   * any, in the 3D cloud (no image, no plane), and with no dataset to draw.\n   */\n  private redrawSpatialMarkers(): void {\n    const latest = this.spatialLatest;\n    if (!latest?.[0] || isSpatialOmics3d(this.currentPlotType)) return;\n    void this.rebuildSpatialPoints(...latest);\n  }\n\n  /**\n   * Mount the SPATIAL_OMICS_3D view: observations as a 3D point cloud under the orbit camera.\n   *\n   * Deliberately much thinner than the 2D mount. There is no tissue image to render (a registered\n   * volume like the Allen CCF has no single reference plane), so no scale bar, no readback, and no\n   * 2D interaction stack — the region tools draw in screen space and have no meaning against an\n   * orbiting camera, which is why `Select from ROIs` is hidden in this mode. `addPoints3D` puts\n   * the viewer in 3D and frames the camera on the cloud itself.\n   */\n  private async mountSpatialOmics3d(viewer: Viewer, host: HTMLElement): Promise<void> {\n    this.install3dInteraction(viewer, host);\n    this.installSpatialHover(host);\n    this.subscribeSpatial();\n  }\n\n  /**\n   * Scale bar for the 3D cloud, measured at the ORBIT PIVOT.\n   *\n   * A perspective camera has no single scale — things farther away are smaller — so a bar can\n   * only be true at one depth. The pivot is the honest choice: it is what the camera is framing,\n   * what a zoom moves towards, and where the eye is anyway. napari's own 3D scale bar works the\n   * same way.\n   *\n   * `NapariScaleBar` needs CSS px per world unit, which an orbit camera does not expose, but at\n   * the pivot it is exactly `viewportHeight / (2 * distance * tan(fov / 2))` — the same\n   * relationship `Camera3D.pan` uses to track the cursor. The bar then converts through\n   * `micronsPerUnit`, and draws nothing at all when the dataset does not declare one, because a\n   * bar labelled in microns over unknown units would read as a measurement.\n   */\n  private installSpatial3dScaleBar(viewer: Viewer, dataset: SpatialDataset | null): void {\n    this.scaleBar?.destroy();\n    this.scaleBar = null;\n    const micronsPerUnit = dataset?.micronsPerUnit;\n    if (!this.host || !micronsPerUnit || micronsPerUnit <= 0) return;\n\n    const canvas = this.canvas;\n    const cam = viewer.camera3d;\n    const shim: ScaleBarCamera = {\n      get zoom(): number {\n        const h = canvas?.clientHeight || canvas?.height || 0;\n        const worldPerPx = (2 * cam.distance * Math.tan(cam.fov / 2)) / (h || 1);\n        return worldPerPx > 0 ? 1 / worldPerPx : 0;\n      },\n      changed: cam.changed,\n    };\n    this.scaleBar = new NapariScaleBar(this.host, shim, micronsPerUnit);\n  }\n\n  /** Base marker diameter for the 3D cloud, in SCREEN pixels (the layer's unit). */\n  private static readonly SPATIAL_3D_BASE_SIZE = 3;\n\n  /** (Re)build the 3D point cloud for the current dataset + view state. */\n  private async rebuildSpatialPoints3d(\n    dataset: SpatialDataset | null, view: SpatialViewState,\n    selection: SpatialSelectionMask = emptySelection(),\n  ): Promise<void> {\n    const viewer = this.viewer;\n    if (!viewer) return;\n    const token = ++this.spatialRebuildToken;\n\n    // Resolve the scalar encoding BEFORE touching the scene, for the same reason\n    // the 2D path does: a gene fetch can fail or be superseded, and dropping the\n    // layer first would blank the view.\n    let enc: Spatial3dEncoding | null = null;\n    if (dataset) {\n      try {\n        enc = await this.spatialScalar3d(dataset, view);\n      } catch (err) {\n        console.warn('[napari-js] spatial 3D colouring failed — falling back to a flat colour', err);\n        enc = null;\n      }\n    }\n    if (token !== this.spatialRebuildToken || this.viewer !== viewer) return;\n\n    const obs = dataset?.observations;\n    // No z means nothing to draw in 3D. The plot type is gated on `requiresSpatial3d`\n    // so this should be unreachable from the UI, but a host can set the type directly.\n    if (!dataset || !obs || obs.count === 0 || !obs.z) {\n      this.removeSpatial3dLayers(viewer);\n      return;\n    }\n\n    // Anatomy first: on a scene's FIRST layer napari frames the orbit camera, and\n    // the reference volume is the framing we want — the brain, not the outermost\n    // stray segmentation. Every later add keeps the pose instead (napari-js `fit3d: 'once'`).\n    await this.ensureSpatialVolume(viewer, dataset, view);\n    if (token !== this.spatialRebuildToken || this.viewer !== viewer) return;\n    // Then the cluster density volumes, which can set the centring offset when\n    // there is no reference volume — so before any position is computed from it.\n    await this.ensureDensityVolumes(viewer, dataset, view, selection);\n    if (token !== this.spatialRebuildToken || this.viewer !== viewer) return;\n    // Then the gene map, which shares the reference volume's lattice — so it goes\n    // after anything that can still move the centring offset.\n    await this.ensureGeneMapVolume(viewer, dataset, view, selection);\n    if (token !== this.spatialRebuildToken || this.viewer !== viewer) return;\n    // Scale depends on the dataset's declared unit, so it waits for the dataset\n    // rather than being set up at mount time.\n    if (dataset.id !== this.spatialScaleBarKey) {\n      this.spatialScaleBarKey = dataset.id;\n      this.installSpatial3dScaleBar(viewer, dataset);\n    }\n\n    // The reference volume is hidden, not removed: it also fixes the centring\n    // offset every position is computed from, and re-fetching a 100 MB template\n    // to un-hide it would make a checkbox feel like a load.\n    if (this.spatialVolume) {\n      this.spatialVolume.visible = view.showVolume;\n      this.spatialVolume.opacity = view.volumeOpacity;\n    }\n\n    const scale = view.pointScale > 0 ? view.pointScale : 1;\n    const size = NapariVisualizerService.SPATIAL_3D_BASE_SIZE * scale;\n    const scalars = enc?.values ?? new Float32Array(obs.count);\n    const colormap = enc?.colormap ?? this.spatialFlatColormap();\n    const contrastLimits: [number, number] = enc?.contrastLimits ?? [0, 1];\n\n    // One imaged section, or the whole stack. The subset IS the geometry, so it\n    // belongs in the geometry key rather than being re-derived per frame — and an\n    // out-of-range index is clamped rather than dropping the cloud, because the\n    // section count changes with the dataset while the view state persists.\n    const sections = sectionsOf(obs);\n    const section =\n      view.pointSection != null && sections && sections.length > 0\n        ? sections[Math.max(0, Math.min(sections.length - 1, view.pointSection))]\n        : null;\n    const shown = section != null ? observationsInSection(obs, section) : null;\n    const shownCount = shown ? shown.length : obs.count;\n\n    const key = `${dataset.id}:${obs.count}:${section ?? 'all'}`;\n    // `Points3DLayer.values` is readonly and the layer exposes no dataVersion to\n    // bump, so unlike the 2D path a change of colour SOURCE cannot be mutated in\n    // — the layer has to be rebuilt. Only the size/opacity/colormap knobs are\n    // genuinely display-only. So track the scalars' identity separately from the\n    // geometry's: `colorBy` plus the transforms feeding the encoding.\n    const clip = view.percentileClip ?? [0.01, 0.99];\n    const scalarKey = [\n      key,\n      view.colorBy ? `${view.colorBy.kind}:${view.colorBy.name}` : 'flat',\n      view.logScale ? 'log' : 'lin',\n      clip.join(','),\n    ].join('|');\n\n    if (key !== this.spatialLayerKey3d) {\n      // New geometry: interleave x,y,z (the layer's documented layout, x-fastest)\n      // and cache it, so later colour changes rebuild the layer without walking\n      // the observations again.\n      const [ox, oy, oz] = this.spatialOrigin3d;\n      const positions = new Float32Array(shownCount * 3);\n      for (let k = 0; k < shownCount; k++) {\n        const i = shown ? shown[k] : k;\n        positions[k * 3] = obs.x[i] + ox;\n        positions[k * 3 + 1] = obs.y[i] + oy;\n        positions[k * 3 + 2] = obs.z[i] + oz;\n      }\n      this.spatialPositions3d = positions;\n      this.spatialDrawn3d = shown;\n    }\n\n    // The scalars have to follow the geometry: a per-observation vector against one\n    // section's positions would colour each cell by a stranger's value.\n    const valuesFor = () => (shown ? Float32Array.from(shown, (i) => scalars[i]) : scalars);\n\n    if (!this.spatialPoints3d || key !== this.spatialLayerKey3d) {\n      // New GEOMETRY — a different dataset, or a different section — so a new layer.\n      if (this.spatialPoints3d) viewer.layers.remove(this.spatialPoints3d);\n      this.spatialLayerKey3d = key;\n      this.spatialScalarKey3d = scalarKey;\n      this.spatialPoints3d = viewer.addPoints3D(this.spatialPositions3d!, valuesFor(), {\n        name: 'observations',\n        colormap,\n        contrastLimits,\n        size,\n      });\n    } else {\n      if (scalarKey !== this.spatialScalarKey3d) {\n        // A change of colour SOURCE, which used to mean discarding the layer and building\n        // another — and, because adding a 3D layer reframes, a camera jump to undo as well.\n        // napari-js ≥ 0.14 lets the scalars be replaced in place — the setter bumps the\n        // layer's dataVersion so the visual re-uploads — and the positions have not moved,\n        // so there is nothing for the camera to reframe.\n        this.spatialScalarKey3d = scalarKey;\n        this.spatialPoints3d.values = valuesFor();\n      }\n      this.spatialPoints3d.colormap = colormap;\n      this.spatialPoints3d.contrastLimits = contrastLimits;\n      this.spatialPoints3d.size = size;\n    }\n\n    // Selection is a PER-POINT alpha, in the one layer.\n    //\n    // It used to be a second layer: with a single opacity for the whole cloud, the only way\n    // to highlight a subset was to draw it again on top at full opacity while the parent\n    // dropped to the muted level. That second layer had to be kept in step through every\n    // colormap, window and size change, and the two then depth-sorted against each other as\n    // separate draws. Per-point alphas and sizes give the same reading — muted cloud, bright\n    // selection, slightly larger so a small one is findable inside 3.7M points — in one.\n    const hasSelection = selection.count > 0 && selection.mask.length === obs.count;\n    const cloud = this.spatialPoints3d;\n    if (cloud) {\n      cloud.opacity = view.opacity;\n      if (!hasSelection) {\n        cloud.alphas = null;\n        cloud.sizes = null;\n      } else {\n        const alphas = new Float32Array(shownCount);\n        const sizes = new Float32Array(shownCount);\n        for (let k = 0; k < shownCount; k++) {\n          const i = shown ? shown[k] : k;\n          const picked = !!selection.mask[i];\n          alphas[k] = picked ? 1 : DEFAULT_MUTED_OPACITY;\n          sizes[k] = picked ? NapariVisualizerService.SPATIAL_SELECTED_SIZE_SCALE : 1;\n        }\n        cloud.alphas = alphas;\n        cloud.sizes = sizes;\n      }\n    }\n    // Last, so it also covers a layer this pass just created.\n    if (this.spatialPoints3d) this.spatialPoints3d.visible = view.showPoints;\n    viewer.requestRender();\n  }\n\n  /**\n   * The **3D gene map**: the active gene's expression over the whole sectioned\n   * specimen, as one raymarched volume.\n   *\n   * Two things it can be, and the panel's `Volume rendering` toggle picks which:\n   *\n   *  - **sheets** — exactly the planes that were imaged, each carrying that\n   *    slide's own 2D gene map, with the gaps between sections empty. A stack of\n   *    measured fields, at their true z.\n   *  - **volume** — the same fields smoothed along z, so the planes between the\n   *    sections carry an interpolated value. An estimate, and drawn as a\n   *    translucent cloud for the same reason the density volumes are.\n   *\n   * One `VolumeLayer` rather than a textured quad per section: an `ImageLayer`\n   * renders only at `ndisplay === 2`, so 53 sheets in the orbit view would need a\n   * new layer type upstream — while a scalar volume whose z sampling already IS\n   * the section spacing expresses the sheets exactly, and the same lattice then\n   * gives the interpolated version for free.\n   *\n   * Estimated on the reference volume's own lattice (`densityGrid` at stride 1),\n   * so the field lands voxel-for-voxel on the anatomy and needs no offset — a\n   * `VolumeLayer` has no translate, and napari centres both boxes on the world\n   * origin.\n   */\n  private async ensureGeneMapVolume(\n    viewer: Viewer, dataset: SpatialDataset, view: SpatialViewState,\n    selection: SpatialSelectionMask,\n  ): Promise<void> {\n    const gene = view.geneMap && view.colorBy?.kind === 'feature' ? view.colorBy.name : null;\n    const port = this.spatialData;\n    const smoothing = view.geneMapSmoothing > 0 ? view.geneMapSmoothing : 1;\n    const clip = view.percentileClip ?? [0.01, 0.99];\n    const obs = dataset.observations;\n    // A volume built from ONE section would smear that slide through the whole\n    // depth, so the section restriction only applies to the sheets.\n    const interpolate = !!view.geneMapVolume;\n    const sections = sectionsOf(obs);\n    const section =\n      !interpolate && view.geneMapSection != null && sections && sections.length > 0\n        ? sections[Math.max(0, Math.min(sections.length - 1, view.geneMapSection))]\n        : null;\n\n    const fieldKey = gene\n      ? [\n        dataset.id, gene, smoothing, section ?? 'all', interpolate ? 'vol' : 'sheets',\n        this.selectionRev(selection),\n      ].join('|')\n      : null;\n    const key = fieldKey\n      ? [\n        fieldKey, clip.join(','), view.logScale ? 'log' : 'lin', view.geneMapOpacity,\n        this.continuousColormapKey(view),\n      ].join('|')\n      : null;\n    if (key === this.geneMapVolumeKey) return;\n\n    if (this.geneMapVolumeLayer) {\n      viewer.layers.remove(this.geneMapVolumeLayer);\n      this.geneMapVolumeLayer = null;\n    }\n    this.geneMapVolumeKey = key;\n    if (!key || !gene || !port) {\n      this.geneMapVolumeField = null;\n      this.geneMapVolumeFieldKey = null;\n      return;\n    }\n\n    // Coarsened in-plane but NOT along z: the sheets need one plane per imaged\n    // section, while the field they carry is smooth by construction and gains\n    // nothing from the template's 40 µm detail. At full resolution the estimate is\n    // a 5.7M-voxel pair of blurs on the main thread — seconds of frozen UI for a\n    // checkbox; an eighth of the voxels is an eighth of the work.\n    const grid = densityGrid(dataset, GENE_MAP_VOLUME_STRIDE, 128, 1);\n    if (!grid) return;\n\n    if (fieldKey !== this.geneMapVolumeFieldKey) {\n      let values: Float32Array;\n      try {\n        values = await port.getFeatureVector(gene);\n      } catch (err) {\n        console.warn(`[napari-js] 3D gene map: \"${gene}\" unavailable`, err);\n        this.geneMapVolumeKey = null;\n        return;\n      }\n      if (this.viewer !== viewer || this.geneMapVolumeKey !== key) return;\n      const inSelection = selection.count > 0 ? maskToIndices(selection.mask) : undefined;\n      // In-plane bandwidth is the 2D map's, in this lattice's units, so a sheet\n      // and the 2D view of the same section are the same field. Along z it is the\n      // density path's 1.5 voxels — the smallest σ that bridges one section gap.\n      // In-plane σ is a PHYSICAL bandwidth, anchored to the reference volume's own\n      // voxel — the resolution the 2D map estimates at — so a sheet and the 2D\n      // view of the same section are the same field whatever lattice this is\n      // rasterised on. Along z it is the density path's 1.5 voxels: the smallest σ\n      // that bridges one section gap.\n      const inPlane = dataset.volume?.voxelSize ?? grid.voxelSize;\n      this.geneMapVolumeField = expressionVolume(obs, grid, {\n        sigma: [\n          inPlane[0] * NapariVisualizerService.GENE_MAP_SIGMA * smoothing,\n          inPlane[1] * NapariVisualizerService.GENE_MAP_SIGMA * smoothing,\n          grid.voxelSize[2] * 1.5 * smoothing,\n        ],\n        values,\n        indices: section != null ? observationsInSection(obs, section) : inSelection,\n        interpolate,\n      });\n      this.geneMapVolumeFieldKey = fieldKey;\n    }\n    const field = this.geneMapVolumeField;\n    if (!field) return;\n\n    const [lo, hi] = contrastWindow(field.mean, clip[0], clip[1]);\n    const data = encodeExpressionVolume(field, [lo, hi], { log: view.logScale });\n    const node = this.currentColormap as { data?: { value?: unknown } } | null;\n    const lut = spatialContinuousLut(\n      node?.data?.value, this.currentReverse, view.continuousColormap,\n    );\n    this.geneMapVolumeLayer = viewer.addVolume(\n      data, field.width, field.height, field.depth,\n      {\n        name: `gene map · ${gene}${interpolate ? ' · volume' : ''}`,\n        colormap: colormapFromLut(`gene-map-${gene}`, lut),\n        // The encoding already applied the window, so the layer must not apply a\n        // second one: 0..255 is the whole of what it was given.\n        contrastLimits: [0, 255],\n        rendering: 'translucent',\n        // Additive like the density volumes, and for the same reason: the sheets\n        // have to read THROUGH each other and through the anatomy, which a\n        // translucent blend would occlude one sheet at a time.\n        blending: 'additive',\n        opacity: view.geneMapOpacity,\n        voxelSize: grid.voxelSize,\n      },\n    );\n    viewer.requestRender();\n  }\n\n  /**\n   * Cluster density volumes: each cluster rasterised into a smooth scalar field and\n   * raymarched alongside the cloud, tinted with the cluster's own legend colour.\n   *\n   * This is what makes a serially sectioned dataset readable as an anatomical\n   * distribution. The cloud shows measured cells and nothing else — but at 200 µm\n   * section spacing the eye cannot integrate a stack of discs into a shape, and\n   * every gap reads as absence. A density field is a different object from a cell:\n   * an estimate, defined between the imaged planes, drawn as a translucent cloud so\n   * it cannot be mistaken for measurement. Individual cells are never interpolated —\n   * consecutive sections sample different cells, so there is nothing to interpolate\n   * along.\n   *\n   * One volume per cluster rather than one for everything: additive blending is what\n   * makes two clusters' territories comparable, and a single blended field would\n   * answer no question anyone asks of a taxonomy. Capped at\n   * {@link DENSITY_MAX_CLUSTERS} by cell count.\n   *\n   * Keyed so it rebuilds only when the field would actually differ — the dataset,\n   * the colour column, the bandwidth, or the selection.\n   */\n  private async ensureDensityVolumes(\n    viewer: Viewer, dataset: SpatialDataset, view: SpatialViewState,\n    selection: SpatialSelectionMask,\n  ): Promise<void> {\n    const on = !!view.densityVolume && !!dataset.observations.z;\n    const smoothing = view.densitySmoothing > 0 ? view.densitySmoothing : 1;\n    const column = view.colorBy?.kind === 'column' ? view.colorBy.name : null;\n    // The selection enters the key by IDENTITY, not by count: two different ROIs\n    // holding the same number of cells would otherwise look like the same key and\n    // leave the previous ROI's fields on screen.\n    const key = on\n      ? [dataset.id, column ?? 'all', smoothing, this.selectionRev(selection)].join('|')\n      : null;\n    if (key === this.densityKey) return;\n\n    for (const layer of this.densityLayers) viewer.layers.remove(layer);\n    this.densityLayers = [];\n    this.densityKey = key;\n    if (!key) return;\n\n    const grid = densityGrid(dataset);\n    if (!grid) return;\n    // With no reference volume there is no offset yet, and a VolumeLayer has no\n    // translate — napari centres its box on the world origin. So the POINTS move by\n    // half the density box, exactly as they do for a reference volume, and the\n    // cached geometry is invalidated because that offset just changed.\n    if (!this.spatialVolume) {\n      this.spatialOrigin3d = [\n        -(grid.width * grid.voxelSize[0]) / 2,\n        -(grid.height * grid.voxelSize[1]) / 2,\n        -(grid.depth * grid.voxelSize[2]) / 2,\n      ];\n      this.spatialLayerKey3d = null;\n    }\n\n    let groups: { name: string; color: string; indices?: Uint32Array }[];\n    try {\n      groups = await this.densityGroups(dataset, column, selection);\n    } catch (err) {\n      console.warn('[napari-js] density volumes: column unavailable', err);\n      this.densityKey = null;\n      return;\n    }\n    if (this.viewer !== viewer || this.densityKey !== key) return;\n\n    const sigma = defaultSigma(grid, smoothing);\n    // Additive blending SUMS, so a fixed per-layer opacity blows out to white as\n    // soon as several broad clusters overlap — six subclasses at 0.55 each turned\n    // the brain into one cyan mass. Splitting the budget keeps n fully overlapping\n    // peaks inside the display's range, so overlap reads as overlap; a single\n    // cluster still gets the full 0.55. It only mitigates: a translucent raymarch\n    // integrates along the ray, so clusters that are ubiquitous rather than\n    // regional (the largest subclasses are glia, which are everywhere) still pile\n    // up, and one cluster at a time is the readable way to look at those.\n    const opacity = Math.min(0.55, 0.9 / Math.max(1, groups.length));\n    for (const group of groups) {\n      const data = rasterizeDensity(dataset.observations, grid, { sigma, indices: group.indices });\n      // A cluster with nothing on the grid draws no layer, rather than an empty box.\n      if (!data) continue;\n      if (this.viewer !== viewer || this.densityKey !== key) return;\n      this.densityLayers.push(\n        (\n          viewer.addVolume(data, grid.width, grid.height, grid.depth, {\n            name: `density · ${group.name}`,\n            colormap: this.channelTintColormap(group.color),\n            // Translucent, not MIP: a cluster's interior is the readable part, and MIP\n            // would flatten every cloud to its brightest shell.\n            rendering: 'translucent',\n            opacity,\n            // Additive, so two clusters overlapping read as both being there instead\n            // of the nearer one hiding the other.\n            blending: 'additive',\n            voxelSize: grid.voxelSize,\n          })),\n      );\n    }\n    viewer.requestRender();\n  }\n\n  /**\n   * Identity of the colour scale a continuous spatial layer will draw with, for a\n   * cache key: the explicit choice, or else the display colormap and its reverse\n   * flag, since that is what {@link spatialContinuousLut} falls back to.\n   *\n   * The gene maps cache their coloured output, so without this in the key a change\n   * of colour scale left the field on screen in the previous colours — the markers\n   * recoloured and the map under them did not.\n   */\n  private continuousColormapKey(view: SpatialViewState): string {\n    const node = this.currentColormap as { data?: { value?: unknown } } | null;\n    return [\n      colormapId(view.continuousColormap),\n      colormapId(node?.data?.value),\n      this.currentReverse ? 'rev' : '',\n    ].join(':');\n  }\n\n  /**\n   * A revision number for a selection object.\n   *\n   * The store hands out a NEW mask object per change, so object identity is the\n   * cheap and exact way to tell two selections apart — a fingerprint over 3.7M\n   * mask bytes would be neither. Counting revisions keeps the cache key a short\n   * string.\n   */\n  private selectionRev(selection: SpatialSelectionMask): number {\n    if (selection !== this.lastSelectionSeen) {\n      this.lastSelectionSeen = selection;\n      this.selectionRevision++;\n    }\n    return this.selectionRevision;\n  }\n\n  /**\n   * The clusters to rasterise: the categories of the active categorical colouring,\n   * biggest first and capped, each with its legend colour.\n   *\n   * Restricted to the current selection when there is one, so \"select a region,\n   * check the box\" answers which clusters live there. With no categorical colouring\n   * there is one group — total cell density, which is a real question on its own\n   * (\"where is the tissue dense?\") and the honest thing to show when the view is\n   * not encoding a taxonomy.\n   */\n  private async densityGroups(\n    dataset: SpatialDataset, column: string | null, selection: SpatialSelectionMask,\n  ): Promise<{ name: string; color: string; indices?: Uint32Array }[]> {\n    const n = dataset.observations.count;\n    const inSelection = selection.count > 0 ? selection.mask : null;\n    const port = this.spatialData;\n    const meta = column ? findColumnMeta(dataset, column) : undefined;\n    if (!port || !column || !meta || meta.kind !== 'categorical') {\n      const indices = inSelection ? maskToIndices(inSelection) : undefined;\n      const [r, g, b] = NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;\n      const hex = `#${[r, g, b].map((c) => Math.round(c * 255).toString(16).padStart(2, '0')).join('')}`;\n      return [{ name: inSelection ? 'selected cells' : 'all cells', color: hex, indices }];\n    }\n\n    const loaded = await port.getColumn(column);\n    if (!isCategoricalColumn(loaded)) return [];\n    const colors = resolveCategoryColors(loaded.meta);\n    const counts = new Uint32Array(loaded.meta.categories.length);\n    for (let i = 0; i < n; i++) {\n      if (inSelection && !inSelection[i]) continue;\n      const code = loaded.codes[i];\n      if (code !== NO_CATEGORY && code < counts.length) counts[code]++;\n    }\n    const ranked = Array.from(counts, (count, code) => ({ code, count }))\n      .filter((c) => c.count > 0)\n      .sort((a, b) => b.count - a.count)\n      .slice(0, NapariVisualizerService.DENSITY_MAX_CLUSTERS);\n    if (counts.filter((c) => c > 0).length > ranked.length) {\n      console.info(\n        `[napari-js] ${column}: drawing the ${ranked.length} largest clusters as density ` +\n          'volumes; more than that stop being separable by eye',\n      );\n    }\n    return ranked.map(({ code }) => {\n      const indices = new Uint32Array(counts[code]);\n      let k = 0;\n      for (let i = 0; i < n; i++) {\n        if (inSelection && !inSelection[i]) continue;\n        if (loaded.codes[i] === code) indices[k++] = i;\n      }\n      return {\n        name: loaded.meta.categories[code],\n        color: colors[code] ?? '#888888',\n        indices: indices.subarray(0, k),\n      };\n    });\n  }\n\n  /**\n   * Add (or keep) the dataset's reference volume, and derive the offset that sits the\n   * observations inside it.\n   *\n   * `VolumeLayer` has no translate: napari-js maps the volume's unit cube to a world box\n   * **centred on the origin**, sized `dims x voxelSize`. The observations, by contract, are in\n   * the volume's own frame with its near corner at the coordinate origin. So the two only line\n   * up if the POINTS move — by half the box — which is what {@link spatialOrigin3d} is.\n   *\n   * A failed or absent volume is not fatal: the cloud renders on its own, at its own\n   * coordinates, and the camera frames the points instead.\n   */\n  private async ensureSpatialVolume(\n    viewer: Viewer, dataset: SpatialDataset, view: SpatialViewState,\n  ): Promise<void> {\n    const meta = dataset.volume;\n    const port = this.spatialData;\n    const key = meta ? `${dataset.id}:${meta.width}x${meta.height}x${meta.depth}` : null;\n    if (key && key === this.spatialVolumeKey) return;\n\n    if (this.spatialVolume) {\n      viewer.layers.remove(this.spatialVolume);\n      this.spatialVolume = null;\n      this.spatialVolumeKey = null;\n    }\n    this.spatialOrigin3d = [0, 0, 0];\n    if (!meta || !port?.getVolume) return;\n\n    let voxels: Uint8Array;\n    try {\n      voxels = await port.getVolume();\n    } catch (err) {\n      console.warn('[napari-js] reference volume unavailable — drawing the cloud alone', err);\n      return;\n    }\n    if (this.viewer !== viewer) return;\n\n    const [vx, vy, vz] = meta.voxelSize;\n    this.spatialVolumeKey = key;\n    this.spatialVolume = (\n      viewer.addVolume(voxels, meta.width, meta.height, meta.depth, {\n      name: 'reference volume',\n      colormap: 'gray',\n      // MIP would draw the brightest voxel along each ray, which for an averaged\n      // template means a flat white shell that hides the cloud. Translucent lets\n      // the points read through the tissue, which is the entire point of drawing\n      // them together.\n      rendering: 'translucent',\n      opacity: view.volumeOpacity,\n        voxelSize: [vx, vy, vz],\n      }));\n    // Half the box, negated: the observations' origin is the box's near corner,\n    // and the box is centred on the world origin.\n    this.spatialOrigin3d = [\n      -(meta.width * vx) / 2,\n      -(meta.height * vy) / 2,\n      -(meta.depth * vz) / 2,\n    ];\n    // Force a geometry rebuild: the offset changed, so cached positions are stale.\n    this.spatialLayerKey3d = null;\n  }\n\n  private removeSpatial3dLayers(viewer: Viewer): void {\n    for (const layer of [\n      this.spatialPoints3d, this.spatialVolume,\n      this.geneMapVolumeLayer, ...this.densityLayers,\n    ]) {\n      if (layer) viewer.layers.remove(layer);\n    }\n    this.geneMapVolumeLayer = null;\n    this.geneMapVolumeKey = null;\n    this.geneMapVolumeField = null;\n    this.geneMapVolumeFieldKey = null;\n    this.densityLayers = [];\n    this.densityKey = null;\n    // The scene is gone, so the next 3D layer should frame itself again. That used to be\n    // `spatialFramed = null` next to a hand-rolled save/restore; the renderer owns the\n    // policy now, and this is the same statement addressed to it.\n    viewer.resetFit3D();\n    this.spatial2dFramed = null;\n    this.spatialVolume = null;\n    this.spatialVolumeKey = null;\n    this.spatialOrigin3d = [0, 0, 0];\n    this.spatialPoints3d = null;\n    this.spatialLayerKey3d = null;\n    this.spatialScalarKey3d = null;\n    this.spatialPositions3d = null;\n    this.spatialDrawn3d = null;\n  }\n\n  /** A one-colour colormap, for the \"nothing to colour by\" state. */\n  private spatialFlatColormap(): Colormap {\n    const [r, g, b] = NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;\n    const rgb: Rgb = [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];\n    // Two identical stops: colormapFromLut needs at least two, and equal ends\n    // make every value resolve to the same colour.\n    return colormapFromLut('spatial-flat', [rgb, rgb]);\n  }\n\n  /**\n   * The per-point scalar + colormap + window that colour the 3D cloud.\n   *\n   * Continuous data is the natural fit: values go straight through the active colormap with the\n   * same percentile window the 2D path uses. Categorical data has to be smuggled through the same\n   * scalar channel — see {@link SPATIAL_3D_MAX_CATEGORIES}. Codes map to LUT blocks, and\n   * `contrastLimits` of `[-0.5, K - 0.5]` puts code `i` at the centre of block `i`, which is what\n   * makes the round-trip exact instead of approximately right.\n   */\n  private async spatialScalar3d(\n    dataset: SpatialDataset, view: SpatialViewState,\n  ): Promise<Spatial3dEncoding | null> {\n    const port = this.spatialData;\n    const colorBy = view.colorBy;\n    if (!port || !colorBy) return null;\n\n    if (colorBy.kind === 'column') {\n      const column: SpatialColumn = await port.getColumn(colorBy.name);\n      if (isCategoricalColumn(column)) {\n        return this.encodeSpatial3dCategorical(column.codes, resolveCategoryColors(column.meta));\n      }\n      return this.encodeSpatial3dContinuous(\n        column.values, view, view.logScale,\n      );\n    }\n    const values = await port.getFeatureVector(colorBy.name);\n    return this.encodeSpatial3dContinuous(\n      values, view, view.logScale,\n    );\n  }\n\n  /** Category codes → a stepped LUT, exact for up to {@link SPATIAL_3D_MAX_CATEGORIES}. */\n  private encodeSpatial3dCategorical(codes: Uint16Array, colors: string[]): Spatial3dEncoding | null {\n    // Slot 0 is reserved for \"no category\", so the palette occupies 1..K and the\n    // block count is one more than the category count — which is why the published\n    // ceiling is 95 categories rather than the LUT's 96 distinguishable blocks.\n    if (colors.length > SPATIAL_3D_MAX_CATEGORIES) {\n      console.warn(\n        `[napari-js] ${colors.length} categories exceeds the ${SPATIAL_3D_MAX_CATEGORIES} the 3D `\n        + \"layer's 256-entry LUT can hold distinctly; drawing flat instead of with wrong colours\",\n      );\n      return null;\n    }\n    const k = colors.length + 1;\n    const palette: Rgb[] = [\n      MISSING_COLOR,\n      ...colors.map(parseHex),\n    ];\n    const lut: Rgb[] = new Array(LUT_SIZE);\n    for (let j = 0; j < LUT_SIZE; j++) {\n      lut[j] = palette[Math.min(k - 1, Math.floor((j * k) / LUT_SIZE))];\n    }\n    const values = new Float32Array(codes.length);\n    for (let i = 0; i < codes.length; i++) {\n      values[i] = codes[i] === NO_CATEGORY ? 0 : codes[i] + 1;\n    }\n    return {\n      values,\n      colormap: colormapFromLut('spatial-categories', lut),\n      contrastLimits: [-0.5, k - 0.5],\n    };\n  }\n\n  /** Continuous values → the active colormap over a percentile-clipped window. */\n  private encodeSpatial3dContinuous(\n    source: Float32Array, view: SpatialViewState, log: boolean,\n  ): Spatial3dEncoding {\n    const node = this.currentColormap as { data?: { value?: unknown } } | null;\n    const lut = spatialContinuousLut(\n      node?.data?.value, this.currentReverse, view.continuousColormap,\n    );\n    const [lo, hi] = view.percentileClip ?? [0.01, 0.99];\n    let values = source;\n    if (log) {\n      values = new Float32Array(source.length);\n      for (let i = 0; i < source.length; i++) values[i] = Math.log1p(Math.max(0, source[i]));\n    }\n    const [min, max] = contrastWindow(values, lo, hi);\n    return {\n      values,\n      colormap: colormapFromLut('spatial-continuous', lut),\n      // A degenerate window would divide by zero in the shader's normalisation.\n      contrastLimits: max > min ? [min, max] : [min, min + 1],\n    };\n  }\n\n  /**\n   * Per-observation colours for the current view state, or a single flat colour when nothing is\n   * selected to colour by. Categorical columns use the column's own palette; continuous columns\n   * and gene vectors go through the active colormap with a percentile-clipped window.\n   */\n  private async spatialFaceColors(\n    dataset: SpatialDataset, view: SpatialViewState, selection: SpatialSelectionMask,\n  ): Promise<ReturnType<typeof toRgbaTuples> | [number, number, number, number]> {\n    const port = this.spatialData;\n    const colorBy = view.colorBy;\n    // Everything NOT selected is muted; with nothing selected, nothing is muted\n    // and the whole tissue reads normally (the CosMx highlight-vs-mute rule).\n    const muted = mutedFromSelection(selection);\n\n    if (!port || !colorBy) {\n      const [r, g, b] = NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;\n      // Genuinely uniform: one broadcast tuple, so a flat 84k-observation view\n      // does not allocate 84k of them.\n      if (!muted && view.opacity >= 1) return NapariVisualizerService.SPATIAL_NEUTRAL_COLOR;\n      // Not uniform — the opacity control or a selection varies the alpha, so it\n      // has to be per-point. Returning the constant tuple here is what made the\n      // Opacity slider do nothing in the default state, which is the state anyone\n      // lands in before picking a colour source.\n      const hex = `#${[r, g, b].map((c) => Math.round(c * 255).toString(16).padStart(2, '0')).join('')}`;\n      return toRgbaTuples(encodeCategorical(new Uint16Array(dataset.observations.count), {\n        colors: [hex],\n        opacity: view.opacity,\n        muted,\n      }));\n    }\n\n    if (colorBy.kind === 'column') {\n      const column: SpatialColumn = await port.getColumn(colorBy.name);\n      if (isCategoricalColumn(column)) {\n        return toRgbaTuples(encodeCategorical(column.codes, {\n          colors: resolveCategoryColors(column.meta),\n          opacity: view.opacity,\n          muted,\n        }));\n      }\n      // A continuous column may carry its own log hint (counts); the view's\n      // toggle wins once the user has set it.\n      return toRgbaTuples(this.encodeSpatialContinuous(\n        column.values, view, view.logScale, muted,\n      ));\n    }\n\n    const values = await port.getFeatureVector(colorBy.name);\n    return toRgbaTuples(this.encodeSpatialContinuous(\n      values, view, view.logScale, muted,\n    ));\n  }\n\n  /** Continuous values → RGBA through the active colormap and a clipped window. */\n  private encodeSpatialContinuous(\n    values: Float32Array, view: SpatialViewState, log: boolean,\n    muted: Uint8Array | null = null,\n  ): Float32Array {\n    const node = this.currentColormap as { data?: { value?: unknown } } | null;\n    const lut = spatialContinuousLut(\n      node?.data?.value, this.currentReverse, view.continuousColormap,\n    );\n    const [lo, hi] = view.percentileClip ?? [0.01, 0.99];\n    const [min, max] = contrastWindow(values, lo, hi);\n    return encodeContinuous(values, { lut, min, max, log, opacity: view.opacity, muted });\n  }\n\n  /**\n   * Mount the NAPARI_SCATTER3D 3D scatter: the downsampled voxel grid as a 3D point cloud colored\n   * by intensity (napari-js analog of Plotly's voxel scatter3d). Assembles a coarse volume, then\n   * emits a flat-strided sample of voxels (capped at {@link SCATTER3D_MAX_POINTS}) via `addPoints3D`.\n   */\n  private async mountScatter3d(viewer: Viewer, info: IImageInfo | undefined): Promise<void> {\n    this.imageMode = 'grayscale';\n    this.volumeMultichannel = false;\n    const res = volumeResolutionFor(this.resolutionScale);\n    this.stackLoading$.next(true);\n    this.stackLoadingProgress$.next(0);\n    let vol: { data: Uint8Array; width: number; height: number; depth: number } | null = null;\n    try {\n      vol = await this.assembleVolume(info, {\n        maxSlice: Math.min(res.maxSlice, SCATTER3D_MAX_XY),\n        sliceStep: res.sliceStep,\n      });\n    } finally {\n      this.stackLoading$.next(false);\n      this.stackLoadingProgress$.next(0);\n    }\n    if (!vol || this.viewer !== viewer) return;\n\n    const { data, width, height, depth } = vol;\n    const zScale = Math.max(width, height) / Math.max(1, depth); // ≈ cubic aspect\n    const total = width * height * depth;\n    const stride = Math.max(1, Math.ceil(total / SCATTER3D_MAX_POINTS));\n    const pos: number[] = [];\n    const val: number[] = [];\n    for (let i = 0; i < total; i += stride) {\n      const x = i % width;\n      const y = Math.floor(i / width) % height;\n      const zi = Math.floor(i / (width * height));\n      pos.push(x, y, zi * zScale);\n      val.push(data[i]);\n    }\n\n    const st = this.store.currentChannelStates()[0];\n    this.scatter3dLayer = viewer.addPoints3D(new Float32Array(pos), new Float32Array(val), {\n      colormap: this.volumeColormap(st),\n      contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n      size: 3,\n    });\n    this.imageW = width;\n    this.imageH = height;\n    this.volumeDims = { width, height, depth };\n    // Feed the intensity histogram from the assembled volume (key 0).\n    this.volumeChannelData.clear();\n    this.volumeChannelData.set(0, data);\n    this.subscribeScatter3dDisplayState();\n    this.scheduleReadback();\n  }\n\n  /** Store colormap / reverse / invert / channel window → the 3D scatter's colormap + contrast. */\n  private subscribeScatter3dDisplayState(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = combineLatest([\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n      this.store.getChannelStates(),\n    ]).subscribe(([colormap, reverse, invert, channels]) => {\n      this.currentColormap = (colormap as ColormapNode) ?? null;\n      this.currentReverse = reverse;\n      this.invertEnabled = invert;\n      const layer = this.scatter3dLayer;\n      if (!layer) return;\n      const st = channels[0];\n      layer.colormap = this.volumeColormap(st);\n      if (st) layer.contrastLimits = [st.min, st.max];\n      this.viewer?.requestRender();\n    });\n  }\n\n  /**\n   * Mount the NAPARI_SURFACE height-field surface. A height field is single-scalar, so for a\n   * multichannel image the surface follows ONE band — the first visible channel (fallback 0) —\n   * coloured by that channel's window/colormap (like the Plotly SURFACE, which is grayscale-only).\n   * Pre-loads every slice's height data with a progress bar (as the volume does) so the stack\n   * slider re-slices instantly, then builds the mesh for the current slice. All mesh + GPU work\n   * lives in napari-js (`heightField` + `Viewer.addSurface`); this backend supplies scalar slices.\n   */\n  private async mountSurface(viewer: Viewer): Promise<void> {\n    const desc = await this.ensureDescriptor();\n    const info = this.loaded?.imageInfo;\n    // Serverless multichannel (tiled:false + channelUrls) has no descriptor — detect\n    // it from imageMeta so the Surface still follows one band.\n    const simpleMc = this.simpleStack.isSimple(info) && !!info?.channelUrls?.length\n      && (info?.imageMeta?.[0]?.channelCount ?? 1) > 1;\n    const multichannel = simpleMc || (!!desc?.multichannel && (desc?.channels ?? 1) > 1);\n    this.surfaceMultichannel = multichannel;\n    // A height field is single-scalar → follow the pane-SELECTED channel.\n    this.surfaceChannel = multichannel ? this.store.currentSelectedChannel() : undefined;\n    this.surfaceMaxGrid = surfaceResolutionFor(this.resolutionScale).maxGrid;\n    this.imageMode = 'grayscale';\n    this.volumeMultichannel = false;\n    await this.preloadSurfacePlanes(viewer);\n    if (this.viewer !== viewer) return;\n    await this.buildSurface(viewer, this.loaded?.z ?? 0);\n    this.installSurfaceAxes(viewer);\n    // Subscribe after the first build so display-state edits target a live layer.\n    this.subscribeSurfaceDisplayState();\n  }\n\n  /** Add the 3D axes gizmo + DOM labels around the (origin-centered) surface mesh, matching the\n   *  volume/isosurface. Installed once per mount; the box tracks the mesh bounds, X/Y show the\n   *  physical (or pixel) extent, and Z is the intensity/height axis. */\n  private installSurfaceAxes(viewer: Viewer): void {\n    if (!this.surfaceLayer) return;\n    const b = this.surfaceLayer.bounds();\n    const boxW = Math.max(1, b.max[0] - b.min[0]);\n    const boxH = Math.max(1, b.max[1] - b.min[1]);\n    const boxD = Math.max(1, b.max[2] - b.min[2]);\n    const mppX = this.descriptor?.mppX || this.loaded?.imageInfo.imageMeta?.[0]?.mppX || 0;\n    const voxel = mppX > 0 ? (mppX * (this.descriptor?.width ?? this.imageW)) / Math.max(1, this.imageW) : 1;\n    this.axesLayer = viewer.addAxes(boxW, boxH, boxD, {\n      voxelSize: [voxel, voxel, 1],\n      visible: this.axesVisible,\n    });\n    if (this.host) {\n      this.axesLabels = new NapariAxesLabels(\n        this.host,\n        viewer.camera3d,\n        this.buildSurfaceAxesLabels(boxW, boxH, boxD, mppX),\n      );\n      this.axesLabels.setVisible(this.axesVisible);\n    }\n  }\n\n  /** X/Y/Z end-labels for the surface gizmo: X/Y are the physical (µm) or pixel extent of the FULL\n   *  image; Z is the intensity/height axis. Anchors are in the centered box (matching AxesLayer). */\n  private buildSurfaceAxesLabels(\n    boxW: number,\n    boxH: number,\n    boxD: number,\n    mppX: number,\n  ): AxisLabelSpec[] {\n    const hx = boxW / 2;\n    const hy = boxH / 2;\n    const hz = boxD / 2;\n    const descW = this.descriptor?.width ?? this.imageW;\n    const descH = this.descriptor?.height ?? this.imageH;\n    const len = (px: number): string => (mppX > 0 ? formatUm(px * mppX) : `${px} px`);\n    return [\n      { anchor: [hx, -hy, -hz], text: `X · ${len(descW)}`, color: '#ed4545' },\n      { anchor: [-hx, hy, -hz], text: `Y · ${len(descH)}`, color: '#4dd959' },\n      { anchor: [-hx, -hy, hz], text: 'Z · intensity', color: '#668cff' },\n    ];\n  }\n\n  /**\n   * Pre-fetch every stack slice's luminance plane (decimated to the surface grid) into\n   * {@link surfacePlanes}, driving {@link stackLoadingProgress$} — the same load-with-progress UX\n   * as the volume, but keeping one 2D plane per slice rather than packing a 3D volume. Bounded\n   * concurrency keeps the connection pool busy without flooding it on a deep stack.\n   */\n  private async preloadSurfacePlanes(viewer: Viewer): Promise<void> {\n    const token = this.loadToken; // bail if a Cancel / new plot bumps this while we fetch\n    const info = this.loaded?.imageInfo;\n    const depth = info?.imageMeta?.[0]?.z || info?.urls?.length || 1;\n    const { maxGrid } = surfaceResolutionFor(this.resolutionScale);\n    this.surfacePlanes.clear();\n    this.stackLoading$.next(true);\n    this.stackLoadingProgress$.next(0);\n    try {\n      const pending: number[] = [];\n      for (let z = 0; z < depth; z++) pending.push(z);\n      let done = 0;\n      const worker = async (): Promise<void> => {\n        for (;;) {\n          const z = pending.shift();\n          if (z === undefined || this.viewer !== viewer || this.loadToken !== token) return;\n          try {\n            this.surfacePlanes.set(z, await this.fetchSurfacePlane(z, maxGrid));\n          } catch (err) {\n            console.warn(`[napari-js] surface slice ${z} preload failed`, err);\n          }\n          done++;\n          this.stackLoadingProgress$.next(Math.round((done / depth) * 100));\n        }\n      };\n      const pool = Math.min(VOLUME_FETCH_CONCURRENCY, Math.max(1, depth));\n      await Promise.all(Array.from({ length: pool }, () => worker()));\n    } finally {\n      this.stackLoading$.next(false);\n      this.stackLoadingProgress$.next(0);\n    }\n  }\n\n  /**\n   * Fetch slice `z` as a single WHOLE-image luminance plane (decimated to `maxGrid`). Prefers the\n   * app's complete per-slice image (`smallUrls`/`urls`, exactly like the Plotly surface) so the\n   * surface always covers the FULL slice — the tile-pyramid `fetchSlice` path would fall back to a\n   * single top-left tile (a corner) for self-contained / non-`/tiles/info` images. Falls back to\n   * stitching the tile grid only when no complete-image URL is available.\n   */\n  /** Tile budget to stitch a whole slice at ~`targetPx` resolution from the pyramid: a higher target\n   *  pulls a FINER pyramid level (more real detail). Shared by the surface plane fetch and the volume\n   *  assembly so both scale their in-plane resolution with the decimate factor. */\n  private tileBudgetFor(targetPx: number): number {\n    const tileSize = this.descriptor?.tileSize || TILE_SIZE;\n    return Math.min(\n      MAX_STITCH_TILES,\n      Math.max(1, Math.round((targetPx / tileSize) ** 2 * STITCH_BUDGET_COEFF)),\n    );\n  }\n\n  private async fetchSurfacePlane(\n    z: number,\n    maxGrid: number,\n  ): Promise<{ data: Uint8Array; width: number; height: number }> {\n    const info = this.loaded?.imageInfo;\n    const desc = await this.ensureDescriptor();\n    let plane: { data: Uint8Array; width: number; height: number } | null = null;\n\n    // Preferred: stitch the WHOLE slice from the server pyramid at a resolution driven by the\n    // decimate factor — a higher target grid pulls a FINER pyramid level (more real detail). With a\n    // descriptor, fetchSlice stitches the whole chosen level (never a corner), then we downscale to\n    // the grid. This is what makes \"Full\" actually higher-res than \"½\", not just a fixed preview.\n    if (desc?.levels?.length) {\n      const budget = this.tileBudgetFor(maxGrid);\n      // The surface is a single decimated plane, so the composite fallback is acceptable when the\n      // channel has no small pyramid level (keeps it fast); a multichannel VOLUME must not do this.\n      plane = this.bitmapToLuminance(\n        await this.fetchSlice(z, this.surfaceChannel, budget, true),\n        maxGrid,\n      );\n    }\n\n    // Fallback (no pyramid): the app's COMPLETE per-slice image (urls[z], not the small blurry\n    // thumbnail) — whole slice, avoids a corner tile. Capped at the image's own resolution.\n    if (!plane) {\n      const url = info?.urls?.[z] ?? info?.smallUrls?.[z];\n      if (url) {\n        try {\n          const headers = await this.tiles\n            .getAuthHeaders()\n            .catch(() => ({}) as Record<string, string>);\n          const resp = await fetch(url, { headers });\n          if (resp.ok) {\n            plane = this.bitmapToLuminance(await createImageBitmap(await resp.blob()), maxGrid);\n          }\n        } catch (err) {\n          console.warn(`[napari-js] surface url fetch failed for z=${z}`, err);\n        }\n      }\n    }\n\n    // Last resort (no pyramid and no complete image): a single tile.\n    if (!plane) {\n      plane = this.bitmapToLuminance(\n        await this.fetchSlice(z, this.surfaceChannel, this.tileBudgetFor(maxGrid), true),\n        maxGrid,\n      );\n    }\n    return plane;\n  }\n\n  /** The channel state driving the surface: the chosen band for multichannel (matched by index),\n   *  else the single grayscale channel. */\n  private surfaceState(channels: IChannelState[]): IChannelState | undefined {\n    if (this.surfaceChannel == null) return channels[0];\n    return channels.find((s) => s.index === this.surfaceChannel) ?? channels[0];\n  }\n\n  /**\n   * (Re)build the surface mesh for slice `z` from the pre-loaded plane cache (instant — this is\n   * what the stack slider calls); a slice missing from the cache is fetched on demand. napari-js's\n   * pure `heightField` builds the triangle grid (z = normalized intensity), then `addSurface`\n   * renders it. The slice plane also feeds the intensity histogram (key 0).\n   */\n  private async buildSurface(viewer: Viewer, z: number): Promise<void> {\n    let plane = this.surfacePlanes.get(z);\n    if (!plane) {\n      this.stackLoading$.next(true);\n      try {\n        plane = await this.fetchSurfacePlane(z, this.surfaceMaxGrid);\n        this.surfacePlanes.set(z, plane);\n      } catch (err) {\n        console.error('[napari-js] surface slice fetch failed:', err);\n      } finally {\n        this.stackLoading$.next(false);\n      }\n    }\n    if (!plane || plane.width < 2 || plane.height < 2 || this.viewer !== viewer) return;\n\n    const st = this.surfaceState(this.store.currentChannelStates());\n    const win: [number, number] = [st?.min ?? 0, st?.max ?? 255];\n    this.surfaceWindow = win;\n    // Height AND colour are normalized by the same contrast window, so changing min/max reshapes the\n    // surface (a pixel's height = its intensity within [min,max]). Center it for the axes gizmo. The\n    // plane is already decimated to the grid cap → stride 1.\n    const zScale = SURFACE_Z_ASPECT * Math.max(plane.width, plane.height);\n    const { vertices, faces, values } = heightField(plane.data, plane.width, plane.height, {\n      zScale,\n      zLimits: win,\n      center: true,\n    });\n\n    // Preserve the orbit camera across a re-slice / window rebuild — only the first mount frames, so\n    // stepping the stack or changing the window keeps the current zoom/pan/orientation.\n    const cam = viewer.camera3d;\n    const preserveCamera = this.surfaceLayer != null;\n    const savedTarget = cam.target;\n    const savedDistance = cam.distance;\n    if (this.surfaceLayer) {\n      viewer.layers.remove(this.surfaceLayer);\n      this.surfaceLayer = null;\n    }\n    this.surfaceLayer = viewer.addSurface(vertices, faces, values, {\n      colormap: this.volumeColormap(st),\n      contrastLimits: win,\n      gamma: st?.gamma ?? 1,\n      wireframe: this.surfaceWireframe,\n    });\n    if (preserveCamera) {\n      cam.target = savedTarget;\n      cam.distance = savedDistance;\n    }\n\n    this.imageW = plane.width;\n    this.imageH = plane.height;\n    this.volumeDims = { width: plane.width, height: plane.height, depth: Math.max(1, Math.round(zScale)) };\n    // Reuse the volume intensity-histogram path: the slice's scalar plane is the histogram source.\n    this.volumeChannelData.clear();\n    this.volumeChannelData.set(0, plane.data);\n    this.scheduleReadback();\n  }\n\n  /** Subscribe the store colormap / reverse / invert / channel window → the surface, so histogram\n   *  & channel-dialog edits update it live without a re-fetch. **min/max reshapes the surface's\n   *  height** (a pixel's height = its intensity within [min,max]), so a window change rebuilds the\n   *  mesh geometry (from the cached slice); colour-only edits (colormap/LUT, gamma, reverse, invert)\n   *  just update the layer's uniforms. */\n  private subscribeSurfaceDisplayState(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = combineLatest([\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n      this.store.getChannelStates(),\n      this.store.getSelectedChannel(),\n    ]).subscribe(([colormap, reverse, invert, channels, selected]) => {\n      this.currentColormap = (colormap as ColormapNode) ?? null;\n      this.currentReverse = reverse;\n      this.invertEnabled = invert;\n      const layer = this.surfaceLayer;\n      if (!layer || !this.viewer) return;\n      // Selected channel changed (multichannel): re-fetch THAT band's planes and\n      // rebuild the height-field for the current slice.\n      if (this.surfaceMultichannel && selected !== this.surfaceChannel) {\n        this.surfaceChannel = selected;\n        void (async () => {\n          await this.preloadSurfacePlanes(this.viewer!);\n          if (this.viewer) await this.buildSurface(this.viewer, this.loaded?.z ?? 0);\n        })().catch((err) => console.error('[napari-js] surface channel switch failed:', err));\n        return;\n      }\n      const st = this.surfaceState(channels);\n      const win: [number, number] = [st?.min ?? 0, st?.max ?? 255];\n      const windowChanged =\n        !this.surfaceWindow || win[0] !== this.surfaceWindow[0] || win[1] !== this.surfaceWindow[1];\n      if (windowChanged) {\n        // Height follows the contrast window → rebuild the mesh for the new [min,max] (camera kept).\n        void this.buildSurface(this.viewer, this.loaded?.z ?? 0).catch((err) =>\n          console.error('[napari-js] surface window rebuild failed:', err),\n        );\n        return;\n      }\n      // Colour-only change: update uniforms in place, no geometry rebuild.\n      layer.colormap = this.volumeColormap(st);\n      if (st) {\n        layer.contrastLimits = win;\n        layer.gamma = st.gamma;\n      }\n      this.viewer.requestRender();\n    });\n  }\n\n  private fitCameraSoon(): void {\n    const run = (): void => {\n      if (this.viewer && this.canvas && this.imageW > 0 && this.imageH > 0) {\n        this.viewer.camera.fit(\n          this.imageW,\n          this.imageH,\n          this.canvas.clientWidth || this.imageW,\n          this.canvas.clientHeight || this.imageH,\n        );\n      }\n    };\n    if (typeof requestAnimationFrame === 'function') requestAnimationFrame(run);\n    else run();\n  }\n\n  /** @deprecated Plotly-specific; host re-drives plot() from its image stream. */\n  reloadAndPlot(): void {\n    /* no-op */\n  }\n\n  reset(): void {\n    this.loadToken++; // invalidate any in-flight frame loading from the previous plot\n    this.displaySub?.unsubscribe();\n    this.displaySub = null;\n    this.scaleBar?.destroy();\n    this.scaleBar = null;\n    this.regionOverlay?.destroy();\n    this.regionOverlay = null;\n    this.axesLabels?.destroy();\n    this.axesLabels = null;\n    this.zHandle?.destroy();\n    this.zHandle = null;\n    this.volumeWorldBase = null;\n    this.cachedImage = null;\n    this.cachedImageSource = null;\n    this.lastPixelsRect = null;\n    this.nativeHistograms.clear();\n    this.tiled = false;\n    this.histSamples.clear();\n    if (this.readbackTimer != null) {\n      clearTimeout(this.readbackTimer);\n      this.readbackTimer = null;\n    }\n    this.cameraReadbackOff?.();\n    this.cameraReadbackOff = null;\n    this.channelView = null;\n    this.viewer?.dispose();\n    this.viewer = null;\n    if (this.canvas && this.host?.contains(this.canvas)) this.host.removeChild(this.canvas);\n    this.canvas = null;\n    this.lastPixels = null;\n    this.volumeView = null;\n    this.volumeMultichannel = false;\n    this.surfaceLayer = null;\n    this.surfaceChannel = undefined;\n    this.surfacePlanes.clear();\n    this.surfaceWindow = null;\n    this.scatterRegionSub?.unsubscribe();\n    this.scatterRegionSub = null;\n    this.spatialSub?.unsubscribe();\n    this.spatialSub = null;\n    this.removeSpatialHover();\n    this.hoverSource = null;\n    this.hoverSourceKey = null;\n    this.spatialPoints = null;\n    this.spatialLayerKey = null;\n    this.spatialPoints3d = null;\n    this.spatialLayerKey3d = null;\n    this.spatialScalarKey3d = null;\n    this.spatialVolume = null;\n    this.spatialVolumeKey = null;\n    this.spatialOrigin3d = [0, 0, 0];\n    this.spatialScaleBarKey = null;\n    // Drop the cached interleaved coordinates too: holding 3.7M x 3 floats after\n    // a teardown is ~45MB of retained heap for a scene that no longer exists.\n    this.spatialPositions3d = null;\n    // Invalidate any colour fetch still in flight so it can't attach to the next scene.\n    this.spatialRebuildToken++;\n    this.scatter2dPoints = null;\n    this.scatter3dLayer = null;\n    this.axesLayer = null;\n    this.volumeDims = null;\n    this.volumeChannelData.clear();\n  }\n\n  relayout(_trueImageSize?: number[]): void {\n    this.viewer?.requestRender();\n  }\n\n  /** @deprecated Plotly-specific axis reset. */\n  resetAxes(): void {\n    this.fitCameraSoon();\n  }\n\n  /** @deprecated Plotly-specific autoscale. */\n  autoscale(): void {\n    this.fitCameraSoon();\n    this.autoscaleEvent$.next(undefined);\n  }\n\n  zoomIn(): void {\n    if (this.viewer) this.viewer.camera.zoom = this.viewer.camera.zoom * 1.3;\n  }\n\n  zoomOut(): void {\n    if (this.viewer) this.viewer.camera.zoom = this.viewer.camera.zoom / 1.3;\n  }\n\n  setDragMode(_mode: string | false): void {\n    // No-op: pan and zoom are always the napari camera's default gestures, and pan/zoom gating for\n    // drawing is owned by the region overlay's setMode (setControlsEnabled). Toggling controls here\n    // would fight that — the host calls setDragMode(false) alongside overlay.setMode(<tool>).\n  }\n\n  setNavigatorVisible(_visible: boolean): void {\n    /* napari-js has no minimap; no-op */\n  }\n\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.imageSmoothing = enabled;\n    // Apply live to the rendered image layers; baked into the next render too.\n    this.channelView?.setInterpolation(enabled ? 'linear' : 'nearest');\n  }\n\n  setShowStack(_showstack: boolean): void {\n    /* stack navigated via setZIndex */\n  }\n\n  setZIndex(zIndex: number): void {\n    if (this.loaded) this.loaded.z = zIndex;\n    const v = this.viewer;\n    if (!v) return;\n    // Surface: one slice → one mesh, so re-build the height field for the new slice.\n    if (this.surfaceLayer) {\n      void this.buildSurface(v, zIndex).catch((err) =>\n        console.error('[napari-js] setZIndex surface failed:', err),\n      );\n      return;\n    }\n    // Volume / isosurface: step the volume's z plane in place.\n    if (this.volumeView) {\n      v.dims.z = zIndex;\n      this.scheduleReadback();\n      return;\n    }\n    // Tiled 2D image: just move the dims plane — the tiled visual fetches the new slice's tiles\n    // (cached per z), no layer rebuild. Refresh the coarse histogram sample for the new slice.\n    if (this.tiled) {\n      v.dims.z = zIndex;\n      if (this.descriptor) void this.refreshHistogramSamples(zIndex, this.descriptor);\n      this.redrawSpatialMarkers();\n      this.scheduleReadback();\n      return;\n    }\n    // 2D image (stitch fallback): re-render the slice (re-fetches per-channel / composite). Branch\n    // of a volume layer (not currentPlotType, which could be stale and silently no-op the swap).\n    // The token lets renderImage drop a superseded scrub so a slow older slice can't clobber a newer one.\n    const req = ++this.sliceReq;\n    void this.renderImage(zIndex, req)\n      .then(() => {\n        if (req !== this.sliceReq) return;\n        // AFTER the image, never before: the render clears the layer list, so\n        // markers drawn first are wiped by the very image meant to sit under them.\n        // Over a volume-backed dataset the plane also decides which observations\n        // are drawn at all, so this is what moves the cells with the section.\n        this.redrawSpatialMarkers();\n        this.scheduleReadback();\n      })\n      .catch((err) => console.error('[napari-js] setZIndex slice failed:', err));\n  }\n\n  setStackLoading(stackLoading: boolean): void {\n    this.stackLoading$.next(stackLoading);\n  }\n\n  /** Cancel in-flight frame loading: bump the load generation so the volume-assembly / surface\n   *  preload workers stop fetching more frames, and clear the loading flag + progress. */\n  cancelLoading(): void {\n    this.loadToken++;\n    this.stackLoading$.next(false);\n    this.stackLoadingProgress$.next(0);\n  }\n\n  isStackLoading(): Observable<boolean> {\n    return this.stackLoading$.asObservable();\n  }\n\n  getStackLoadingProgress(): Observable<number> {\n    return this.stackLoadingProgress$.asObservable();\n  }\n\n  getTrueImageSize(): { width: number; height: number } | null {\n    return this.imageW > 0 && this.imageH > 0 ? { width: this.imageW, height: this.imageH } : null;\n  }\n\n  getCurrentImage(): Promise<Image | null> {\n    return Promise.resolve(null);\n  }\n\n  getDisplayedPixelData(): PixelData | null {\n    return this.lastPixels;\n  }\n\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    const v = this.viewer;\n    const size = this.getTrueImageSize();\n    if (!v || !size) return null;\n    const r = v.visibleWorldRect();\n    const x = Math.max(0, r.x);\n    const y = Math.max(0, r.y);\n    return {\n      x,\n      y,\n      width: Math.min(size.width, r.x + r.width) - x,\n      height: Math.min(size.height, r.y + r.height) - y,\n    };\n  }\n\n  downloadImage(): void {\n    void this.exportComposite();\n  }\n\n  setPlotType(plotType: PlotType): void {\n    this.currentPlotType = plotType;\n  }\n\n  /** Map a Plotly-style 3D drag mode onto napari-js's camera drag mode. */\n  setSurfaceDragMode(mode: string): void {\n    if (!this.viewer) return;\n    const m = mode === 'pan' ? 'pan' : mode === 'zoom' ? 'zoom' : 'rotate'; // orbit/turntable → rotate\n    this.viewer.setCameraDragMode(m);\n  }\n\n  /** Re-frame the 3D camera on the current 3D layer. A surface mesh sits in the positive octant\n   *  (not centred), so frame it by its own bounds; a volume/isosurface uses its centred box. */\n  resetSurfaceCamera(): void {\n    if (!this.viewer) return;\n    const meshLayer = this.surfaceLayer ?? this.scatter3dLayer;\n    if (meshLayer) {\n      const b = meshLayer.bounds();\n      this.viewer.camera3d.target = b.center;\n      this.viewer.camera3d.distance = Math.max(b.radius * 2.5, 1e-3);\n      this.viewer.requestRender();\n      return;\n    }\n    const d = this.volumeDims;\n    if (d) this.viewer.camera3d.frame(d.width, d.height, d.depth);\n  }\n\n  getAutoscaleEvent(): Observable<unknown> {\n    return this.autoscaleEvent$.asObservable();\n  }\n\n  getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    // The WebGPU napari-js options, offered alongside (not replacing) the OSD/Plotly types.\n    return [\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_IMAGE]!,\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_SCATTER]!,\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_SURFACE]!,\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_SCATTER3D]!,\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_VOLUME]!,\n      PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_ISOSURFACE]!,\n      // Gated by `requiresSpatialData`, so the selector hides it until a dataset is published.\n      PLOT_TYPE_DESCRIPTORS[PlotType.SPATIAL_OMICS]!,\n    ];\n  }\n\n  /** The napari 3D decimate factor (1 = full … 8 = ⅛). Read by the toolbar to init the control. */\n  getResolutionScale(): number {\n    return this.resolutionScale;\n  }\n\n  /** Set the decimate factor for the napari 3D types. Takes effect on the next (re)load — the host\n   *  re-plots after calling this, since decimation changes the fetched/assembled data. */\n  setResolutionScale(scale: number): void {\n    this.resolutionScale = Math.max(1, Math.round(scale));\n  }\n\n  getIntensityProfile$(): Observable<IntensityProfile[]> {\n    return this.intensityProfile$.asObservable();\n  }\n\n  renderIntensityInset(_divId: string, _profiles: IntensityProfile[]): void {\n    /* Plotly owns the intensity inset */\n  }\n\n  /** Read the displayed composite into `lastPixels` (the pixel-tools' source) + emit the clamped\n   *  visible region. A fresh PixelData object means cachedImageData() rebuilds automatically. */\n  private async runReadback(): Promise<void> {\n    const v = this.viewer;\n    if (!v) return;\n    try {\n      const px = await v.readDisplayedPixels();\n      if (this.viewer !== v) return;\n      const rect = v.visibleWorldRect(); // capture WITH the pixels (same camera)\n      this.lastPixels = px;\n      this.lastPixelsRect = rect;\n      const size = this.getTrueImageSize();\n      if (size && rect) {\n        const x = Math.max(0, Math.min(size.width, rect.x));\n        const y = Math.max(0, Math.min(size.height, rect.y));\n        const width = Math.max(1, Math.min(size.width - x, rect.width));\n        const height = Math.max(1, Math.min(size.height - y, rect.height));\n        this.viewportChange$.next({ x, y, width, height });\n      }\n    } catch {\n      /* readback unavailable */\n    }\n  }\n\n  private scheduleReadback(): void {\n    if (!this.viewer) return;\n    if (typeof requestAnimationFrame === 'function') requestAnimationFrame(() => void this.runReadback());\n    else setTimeout(() => void this.runReadback(), 0);\n  }\n\n  /** Debounced readback — armed on camera changes so `lastPixels` tracks the current view after a\n   *  pan/zoom settles (and after tiled levels finish loading), which the on-canvas pixel tools\n   *  (wand/brush/SAM) read synchronously. Coalesces rapid changes. */\n  private armReadback(delayMs = 250): void {\n    if (this.readbackTimer != null) clearTimeout(this.readbackTimer);\n    this.readbackTimer = setTimeout(() => {\n      this.readbackTimer = null;\n      void this.runReadback();\n    }, delayMs);\n  }\n\n  // ── IRegionStore + classification colours ──────────────────────────────────\n  // Inherited from BaseStoreVisualizer — pure delegations to the shared\n  // RegionStore / VisualizerStore (identical to the OSD backend).\n\n  // ── Pixel tools: reuse the shared, backend-agnostic tool services with a napari host ───────\n\n  /** Build the coordinate transform + tool hosts for the current viewer (called from plot()). The\n   *  pixel tools read displayed pixels synchronously from the last readback and convert pointer\n   *  coords via the napari camera, exactly mirroring the OSD host. */\n  private buildToolHosts(): void {\n    if (!this.viewer) return;\n    this.coordTransform = new NapariCoordinateTransform(\n      this.viewer,\n      () => !!this.viewer && this.imageW > 0,\n    );\n    const regions = this.regionStore;\n    this.wandHost = {\n      getRegions: () => regions.getRegions(),\n      setRegions: (r) => regions.setRegions(r),\n      getCachedImageData: () => this.cachedImageData(),\n      getActiveFrameIndex: () => this.loaded?.z ?? 0,\n      getOverlayContainer: () => this.host,\n      getCoordinateTransform: () => this.coordTransform as ICoordinateTransform,\n      getFileName: () => this.loaded?.filename,\n      getShapeColor: () => regions.getShapeColor(),\n    };\n    this.eraserHost = {\n      getRegions: () => regions.getRegions(),\n      setRegions: (r) => regions.setRegions(r),\n      invalidateWandRegion: () => this.wandTool.clearActiveRegion(),\n      getOverlayContainer: () => this.host,\n      getCoordinateTransform: () => this.coordTransform as ICoordinateTransform,\n      getCachedImageRatio: () => this.cachedImageData()?.ratios[0] ?? 1,\n    };\n  }\n\n  private zoomBoxHost(): ZoomToBoxToolHost {\n    return {\n      getPlotDiv: () => this.plotDivId,\n      pixelToData: (px, py) => {\n        const rect = this.host?.getBoundingClientRect();\n        if (!this.viewer || !rect) return { x: 0, y: 0 };\n        const [x, y] = this.viewer.canvasToWorld(rect.left + px, rect.top + py);\n        return { x, y };\n      },\n      applyZoomToBox: (coords) => this.applyZoomToBox(coords),\n    };\n  }\n\n  /** Zoom/pan the camera to fit a data-space rectangle `[xMin, xMax, yMax, yMin]`. */\n  private applyZoomToBox(coordinates: number[]): void {\n    const v = this.viewer;\n    if (!v || !this.canvas || coordinates.length < 4) return;\n    const [xMin, xMax, yA, yB] = coordinates;\n    const x0 = Math.min(xMin, xMax);\n    const x1 = Math.max(xMin, xMax);\n    const y0 = Math.min(yA, yB);\n    const y1 = Math.max(yA, yB);\n    const w = Math.max(1, x1 - x0);\n    const h = Math.max(1, y1 - y0);\n    const vw = this.canvas.clientWidth || w;\n    const vh = this.canvas.clientHeight || h;\n    v.camera.center = [(x0 + x1) / 2, (y0 + y1) / 2];\n    v.camera.zoom = Math.min(vw / w, vh / h);\n    v.requestRender();\n  }\n\n  /** Build CachedImageData from the most recent readback (RGBA device pixels → [y][x]=[r,g,b]),\n   *  with ratios/origin mapping image coords ↔ readback pixels. Cached until the readback changes. */\n  private cachedImageData(): CachedImageData | null {\n    const px = this.lastPixels;\n    if (!px || !this.viewer) return null;\n    if (this.cachedImage && this.cachedImageSource === px) return this.cachedImage;\n    const w = px.width;\n    const h = px.height;\n    const data = px.data;\n    const matrix: number[][][] = new Array(h);\n    for (let y = 0; y < h; y++) {\n      const row: number[][] = new Array(w);\n      const base = y * w * 4;\n      for (let x = 0; x < w; x++) {\n        const o = base + x * 4;\n        row[x] = [data[o], data[o + 1], data[o + 2]];\n      }\n      matrix[y] = row;\n    }\n    // Use the rect captured WITH this readback (not the live one) so ratios/origin match the\n    // matrix's camera — otherwise a pan/zoom since the readback mis-scales the traced region.\n    const rect = this.lastPixelsRect ?? this.viewer.visibleWorldRect();\n    this.cachedImage = {\n      frames: [matrix],\n      width: w,\n      height: h,\n      ratios: [rect.width / w, rect.height / h],\n      isGrayscale: false,\n      originX: rect.x,\n      originY: rect.y,\n    };\n    this.cachedImageSource = px;\n    return this.cachedImage;\n  }\n\n  // ── IToolController ────────────────────────────────────────────────────────\n  // Control gating: a tool that ACTIVATES disables the camera controls; deactivation is a no-op\n  // because the host always calls the region overlay's setMode FIRST in each toggle (which sets\n  // the baseline enabled/disabled), so re-enabling here would fight a freshly-activated draw mode.\n  setWandMode(active: boolean, options?: IWandOptions): void {\n    if (!this.viewer) return; // no plot yet → nothing to drive\n    if (!active) {\n      this.wandTool.setMode(false);\n      return;\n    }\n    this.viewer?.setControlsEnabled(false);\n    this.cachedImageSource = null;\n    this.armReadback(0);\n    if (this.wandHost) this.wandTool.bindHost(this.wandHost);\n    this.wandTool.setMode(true, (options ?? {}) as unknown as WandOptions);\n  }\n  setWandOptions(options: IWandOptions): void {\n    this.wandTool.setOptions((options ?? {}) as unknown as WandOptions);\n  }\n  clearActiveWandRegion(): void {\n    this.wandTool.clearActiveRegion();\n  }\n  setBrushMode(active: boolean, options?: IBrushOptions): void {\n    if (!this.viewer) return;\n    if (!active) {\n      this.brushTool.setMode(false);\n      return;\n    }\n    this.viewer?.setControlsEnabled(false);\n    this.cachedImageSource = null;\n    this.armReadback(0);\n    if (this.wandHost) this.brushTool.bindHost(this.wandHost);\n    this.brushTool.setMode(true, (options ?? {}) as unknown as BrushOptions);\n  }\n  setBrushOptions(options: IBrushOptions): void {\n    if (options?.size != null) this.brushTool.setSize(options.size);\n  }\n  setVertexEraserMode(active: boolean): void {\n    if (!this.viewer) return;\n    if (active) {\n      this.viewer?.setControlsEnabled(false);\n      this.cachedImageSource = null;\n      if (this.eraserHost) this.eraserTool.bindHost(this.eraserHost);\n    }\n    this.eraserTool.setMode(active);\n  }\n  setVertexEraserRadius(radius: number): void {\n    this.eraserTool.setRadius(radius);\n  }\n  setZoomToBoxMode(active: boolean): void {\n    if (!this.viewer) return;\n    if (active) {\n      this.viewer?.setControlsEnabled(false);\n      this.zoomToBoxTool.bindHost(this.zoomBoxHost());\n    }\n    this.zoomToBoxTool.setMode(active);\n  }\n  // SAM / cellpose — server round-trips that read the drawn rectangles + displayed pixels through\n  // the same wand host (rectangles from the RegionStore, image from the readback).\n  async segmentRectangles(): Promise<number> {\n    if (!this.viewer || !this.wandHost) return 0;\n    await this.runReadback(); // the SAM embedding samples the currently-displayed image\n    this.cachedImageSource = null;\n    this.samTool.bindHost(this.wandHost);\n    return this.samTool.segmentBoxes();\n  }\n  async segmentRectanglesCellpose(): Promise<number> {\n    if (!this.viewer || !this.wandHost || !this.cellSegmenter) return 0;\n    await this.runReadback();\n    this.cachedImageSource = null;\n    this.cellSegmentTool.bindHost(this.wandHost);\n    return this.cellSegmentTool.segmentBoxes(this.cellSegmenter);\n  }\n  setSamModel(id: string): void {\n    this.samTool.setModel(id);\n    this.samPointTool.setModel(id);\n  }\n  setSamPointMode(active: boolean): void {\n    if (!this.viewer) return;\n    if (active) {\n      this.viewer?.setControlsEnabled(false);\n      this.cachedImageSource = null;\n      this.armReadback(0); // refresh the readback the click's embedding will sample\n      if (this.wandHost) this.samPointTool.bindHost(this.wandHost);\n    }\n    this.samPointTool.setMode(active);\n  }\n  commitSamPoints(): void {\n    this.samPointTool.commit();\n  }\n  clearSamPoints(): void {\n    this.samPointTool.clear();\n  }\n\n  // ── IDisplayOptions ───────────────────────────────────────────────────────\n  // Inherited from BaseStoreVisualizer — pure delegations to the shared\n  // VisualizerStore (identical to the OSD backend).\n\n  // ── IIntensitySampling: Plotly owns sampling; emit viewport changes ───────\n  ensureIntensitySampling(_imageInfo: IImageInfo, _zIndex: number): Promise<void> {\n    return Promise.resolve();\n  }\n  refreshIntensitySamplingForRoi(\n    _x: number,\n    _y: number,\n    _width: number,\n    _height: number,\n    _zIndex: number,\n  ): void {}\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return this.viewportChange$.asObservable();\n  }\n\n  // ── IVisualizer composite members ─────────────────────────────────────────\n  getRegionOverlay(): IRegionOverlay | null {\n    return this.regionOverlay;\n  }\n  getIsosurfaceControls(): IIsosurfaceControls | null {\n    if (!this.volumeView) return null;\n    return {\n      setIsoRange: (isoMin: number, isoMax: number): void => {\n        // Apply to every channel's volume layer.\n        for (const layer of this.volumeView?.layers ?? []) {\n          layer.contrastLimits = [isoMin, isoMax];\n          layer.rendering = 'iso';\n          layer.isoThreshold = 0.5;\n        }\n        this.viewer?.requestRender();\n      },\n    };\n  }\n  getIntensityControls(): IIntensityControls | null {\n    return null;\n  }\n  getSurface3dControls(): ISurface3dControls | null {\n    if (!this.volumeView && !this.surfaceLayer && !this.scatter3dLayer) return null;\n    return {\n      setSurfaceDragMode: (mode: string): void => this.setSurfaceDragMode(mode),\n      resetSurfaceCamera: (): void => this.resetSurfaceCamera(),\n      setAxesVisible: (visible: boolean): void => {\n        this.axesVisible = visible;\n        this.axesLabels?.setVisible(visible);\n        if (this.axesLayer) {\n          this.axesLayer.visible = visible;\n          this.viewer?.requestRender();\n        }\n      },\n      axesVisible: (): boolean => this.axesVisible,\n      // Surface wireframe (napari-js surface only) — a live layer property, no rebuild needed.\n      setWireframe: (on: boolean): void => {\n        this.surfaceWireframe = on;\n        if (this.surfaceLayer) {\n          this.surfaceLayer.wireframe = on;\n          this.viewer?.requestRender();\n        }\n      },\n      wireframe: (): boolean => this.surfaceWireframe,\n    };\n  }\n  getHistogram(channelIndex: number, bins: number): IHistogram | null {\n    const v = this.viewer;\n    if (!v) return null;\n    // Volume / isosurface: intensity histogram of the assembled (downsampled) uint8 volume for the\n    // requested channel (multichannel) or the single grayscale volume (key 0).\n    if (this.volumeChannelData.size) {\n      const data = this.volumeChannelData.get(channelIndex) ?? this.volumeChannelData.get(0);\n      return data ? this.toIHistogram(histogramScalar(data, bins, 0, 255)) : null;\n    }\n    // Tiled mode has no full in-memory pixels → use the coarse per-channel sample (RGB: readback).\n    if (this.tiled) {\n      if (this.imageMode === 'rgb') return this.rgbHistogram(channelIndex, bins);\n      const sample = this.histSamples.get(this.imageMode === 'grayscale' ? 0 : channelIndex);\n      return sample ? this.toIHistogram(histogramScalar(sample, bins, 0, 255)) : null;\n    }\n    // Grayscale/multichannel (stitch): native per-channel histogram straight from the in-memory\n    // scalar layer (no GPU readback). RGB: bin the displayed pixels' R/G/B byte (8-bit client path).\n    const layer = this.channelView?.layers[this.imageMode === 'grayscale' ? 0 : channelIndex];\n    if (layer) {\n      const h = v.layerHistogram(layer, bins);\n      if (h) return this.toIHistogram(h);\n    }\n    if (this.imageMode === 'rgb') return this.rgbHistogram(channelIndex, bins);\n    return null;\n  }\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    // >8-bit channels: fetch the true native distribution from the server (the displayed pixels\n    // are 8-bit, so the client histogram would be clipped). 8-bit channels use the client path.\n    const bitDepth = this.descriptor?.channelInfo?.[channelIndex]?.bitDepth ?? 8;\n    if (bitDepth > 8) {\n      const z = this.loaded?.z ?? 0;\n      const key = `${z}|${channelIndex}`;\n      const cached = this.nativeHistograms.get(key);\n      if (cached) return of(cached);\n      return from(this.fetchNativeHistogram(channelIndex, bins, z, key));\n    }\n    return of(this.getHistogram(channelIndex, bins));\n  }\n\n  /** Fetch + cache one channel's native-bit-depth histogram from `GET /histogram` (>8-bit). */\n  private async fetchNativeHistogram(\n    channel: number,\n    bins: number,\n    z: number,\n    key: string,\n  ): Promise<IHistogram | null> {\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) return null;\n    const headers = await this.tiles\n      .getAuthHeaders()\n      .catch(() => ({}) as Record<string, string>);\n    const url = `${this.api}histogram?info=${infoB64}&channel=${channel}&z=${z}&bins=${bins}`;\n    try {\n      const resp = await fetch(url, { headers });\n      if (!resp.ok) return null; // 202 (still caching) or transient → null; the pane retries\n      const hi = (await resp.json()) as {\n        bitDepth: number;\n        rangeMin: number;\n        rangeMax: number;\n        observedMin: number;\n        observedMax: number;\n        binWidth: number;\n        counts: number[];\n      };\n      if (!hi?.counts) return null;\n      const out: IHistogram = {\n        bins: hi.counts.map((_, i) => hi.rangeMin + i * hi.binWidth),\n        counts: hi.counts,\n        max: hi.counts.reduce((m, c) => (c > m ? c : m), 0),\n        bitDepth: hi.bitDepth,\n        rangeMin: hi.rangeMin,\n        rangeMax: hi.rangeMax,\n        observedMin: hi.observedMin,\n        observedMax: hi.observedMax,\n      };\n      this.nativeHistograms.set(key, out);\n      return out;\n    } catch (err) {\n      console.warn('[napari-js] native histogram fetch failed', err);\n      return null;\n    }\n  }\n\n  /** Per-channel histogram of the displayed RGB composite (R/G/B byte), from the last readback. */\n  private rgbHistogram(channelIndex: number, bins: number): IHistogram | null {\n    const px = this.lastPixels;\n    if (!px) return null;\n    const band = Math.max(0, Math.min(2, channelIndex));\n    const n = Math.max(1, Math.min(256, Math.floor(bins) || 256));\n    const counts = new Array(n).fill(0);\n    const data = px.data;\n    for (let i = 0; i < data.length; i += 4) {\n      if (data[i + 3] === 0) continue; // skip transparent padding\n      counts[Math.min(n - 1, (data[i + band] * n) >> 8)]++;\n    }\n    const binsArr = Array.from({ length: n }, (_, i) => (i * 256) / n);\n    return { bins: binsArr, counts, max: counts.reduce((m, c) => (c > m ? c : m), 0) };\n  }\n  exportComposite(): void {\n    const v = this.viewer;\n    if (!v) return;\n    void v.screenshot().then((blob) => {\n      const url = URL.createObjectURL(blob);\n      const a = document.createElement('a');\n      a.href = url;\n      a.download = 'napari-js.png';\n      a.click();\n      URL.revokeObjectURL(url);\n    });\n  }\n  /** Native-bit-depth (16/32-bit) multi-band TIFF export via the server `/export/tiff` endpoint —\n   *  the displayed PNG is an 8-bit figure, this preserves the true pixel values. Visible channels\n   *  only (omitted when all are visible → server default). Mirrors the OSD backend. */\n  async exportData(): Promise<void> {\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) return;\n    const states = this.store.currentChannelStates();\n    const visible = states.filter((c) => c.visible).map((c) => c.index);\n    const chParam =\n      visible.length && visible.length < states.length ? `&channels=${visible.join(',')}` : '';\n    const z = this.loaded?.z ?? 0;\n    const url = `${this.api}export/tiff?info=${infoB64}&z=${z}${chParam}`;\n    const stem = (this.loaded?.filename || 'image').replace(/\\.[^.]+$/, '');\n    const headers = await this.tiles\n      .getAuthHeaders()\n      .catch(() => ({}) as Record<string, string>);\n    try {\n      const resp = await fetch(url, { headers });\n      if (resp.status === 202) {\n        console.warn('[napari-js] 16-bit export: file still caching — try again shortly.');\n        return;\n      }\n      if (!resp.ok) throw new Error(`status ${resp.status}`);\n      saveAs(await resp.blob(), `${stem}_16bit.ome.tif`);\n    } catch (err) {\n      console.warn('[napari-js] 16-bit TIFF export failed', err);\n    }\n  }\n  unsubscribe(): void {\n    this.reset();\n  }\n}\n"]}