@jax-data-science/sci-image-visualizer 0.1.0

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

@@ -0,0 +1,2283 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+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 { buildColormapLut } from '../../contracts/colormap-lut';
+import { PlotType, PLOT_TYPE_DESCRIPTORS, isNapari3d, isNapariIsosurface, isNapariSurface, isNapariScatter, isNapariScatter3d, 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';
+import { BaseStoreVisualizer } from '../base-store-visualizer';
+import { SimpleSliceAccessService } from '../simple-slice-access.service';
+import { VisualizerStore } from '../../store/visualizer-store.service';
+import { RegionStore } from '../../store/region-store.service';
+import { NapariScaleBar, formatUm } from './napari-scale-bar';
+import { NapariRegionOverlay } from './napari-region-overlay';
+import { NapariAxesLabels } from './napari-axes-labels';
+import { NapariVolumeZHandle } from './napari-volume-z-handle';
+import { WandToolService } from '../../toolbar/wand/wand-tool.service';
+import { BrushToolService } from '../../toolbar/brush/brush-tool.service';
+import { VertexEraserToolService, } from '../../toolbar/vertex-eraser/vertex-eraser-tool.service';
+import { ZoomToBoxToolService, } from '../../toolbar/zoom-to-box/zoom-to-box-tool.service';
+import { SamToolService } from '../../toolbar/segmentation/sam-tool.service';
+import { SamPointToolService } from '../../toolbar/segmentation/sam-point-tool.service';
+import { CellSegmentToolService } from '../../toolbar/segmentation/cell-segment-tool.service';
+import { CELL_SEGMENTER } from '../../contracts/cell-segmenter.contract';
+import * as i0 from "@angular/core";
+import * as i1 from "../../store/visualizer-store.service";
+import * as i2 from "../../store/region-store.service";
+import * as i3 from "../../toolbar/wand/wand-tool.service";
+import * as i4 from "../../toolbar/brush/brush-tool.service";
+import * as i5 from "../../toolbar/vertex-eraser/vertex-eraser-tool.service";
+import * as i6 from "../../toolbar/zoom-to-box/zoom-to-box-tool.service";
+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";
+/** ICoordinateTransform over the napari camera: pointer client coords ↔ image/world coords. */
+class NapariCoordinateTransform {
+    constructor(viewer, ready) {
+        this.viewer = viewer;
+        this.ready = ready;
+    }
+    clientToData(clientX, clientY) {
+        const [x, y] = this.viewer.canvasToWorld(clientX, clientY);
+        return { x, y };
+    }
+    dataLengthToScreen(dataLength) {
+        return dataLength * this.viewer.camera.zoom; // CSS px per world unit
+    }
+    isReady() {
+        return this.ready();
+    }
+}
+const VOLUME_MAX_SLICE = 1024; // "Full" in-plane cap; the default ¼ load uses 256
+/** Reference in-plane world size (long side) for the volume/axes box, in arbitrary world units.
+ *  The box is anchored to this reference regardless of the chosen decimate factor, so changing the
+ *  resolution changes DETAIL, not the volume's proportions (Z no longer appears to shrink when the
+ *  in-plane sampling grows). Set to the DEFAULT decimate's in-plane cap so the default view is
+ *  unchanged; higher/lower resolutions keep that same shape. See {@link mountVolume}. */
+const VOLUME_WORLD_INPLANE_REF = VOLUME_MAX_SLICE / NAPARI_DEFAULT_DECIMATE;
+/** Max concurrent slice fetches when assembling a volume — keeps the connection pool busy
+ *  without flooding it (browsers cap ~6/host) on a deep stack. */
+const VOLUME_FETCH_CONCURRENCY = 8;
+/** Volume/isosurface sampling for a decimate factor `scale` (1 = Full 1024, 2 = ½ 512, 4 = ¼ 256
+ *  default, 8 = ⅛ 128): the in-plane cap halves each step; slices stay un-subsampled until ⅛, then
+ *  subsample. */
+function volumeResolutionFor(scale) {
+    const s = Math.max(1, Math.round(scale));
+    return {
+        maxSlice: Math.max(8, Math.round(VOLUME_MAX_SLICE / s)),
+        sliceStep: Math.max(1, Math.floor(s / 4)),
+    };
+}
+/** Fully-normalized intensity height as a fraction of the in-plane extent — matches the Plotly
+ *  SURFACE z-aspect (~0.4) so the relief isn't exaggerated. */
+const SURFACE_Z_ASPECT = 0.4;
+/** "Full" mesh grid cap; the decimate factor divides it (default ¼ → 220, ½ → 440, Full → 880). */
+const SURFACE_MAX_GRID = 880;
+/** Coefficient scaling the pyramid tile budget with the target resolution — a higher target pulls a
+ *  finer pyramid level (more real detail). Shared by the surface plane fetch + volume assembly. */
+const STITCH_BUDGET_COEFF = 16;
+/** Surface mesh target grid for a decimate factor `scale`: the grid cap shrinks by `scale` (every
+ *  slice is kept — the z-slider needs them all). The source is fetched at a matching resolution. */
+function surfaceResolutionFor(scale) {
+    const s = Math.max(1, Math.round(scale));
+    return { maxGrid: Math.max(16, Math.round(SURFACE_MAX_GRID / s)) };
+}
+/** 3D scatter: in-plane cap for the assembled voxel grid, and the max number of points emitted
+ *  (the grid is flat-strided down to this) — keeps the billboard count interactive. */
+const SCATTER3D_MAX_XY = 64;
+const SCATTER3D_MAX_POINTS = 150000;
+const TILE_SIZE = 512; // server tile edge (matches the OSD backend)
+/** Max tiles stitched for one displayed slice (512px tiles → up to ~6144² at full res). Beyond
+ *  this we step to a coarser pyramid level so a large image stays tractable. */
+const MAX_STITCH_TILES = 144;
+/** WebGPU default `maxTextureDimension2D` — a stitched slice's longest side must fit a texture. */
+const MAX_TEXTURE_DIM = 8192;
+/** Concurrent tile requests per stitched slice. Firing a whole grid at once (hundreds of requests
+ *  for a large level) overwhelmed the tile server (504s); a small pool keeps the pipe full without
+ *  flooding it — and slice-level workers already run several stitches in parallel on top of this. */
+const TILE_FETCH_CONCURRENCY = 6;
+/** How long to poll `/tiles/info` (202 while the server caches the source) before falling back to
+ *  a single tile. Generous like the OSD backend — a cold whole-slide can take minutes to cache. */
+const DESCRIPTOR_TIMEOUT_MS = 120000;
+/** Default per-channel tints (Fiji-style) when the store/descriptor offers no colour. */
+const DEFAULT_TINTS = ['#ff0000', '#00ff00', '#0000ff', '#ffff00', '#ff00ff', '#00ffff', '#ffffff'];
+/** Default tint for a channel index, cycling the Fiji palette. */
+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) {
+        super(regionStore, store);
+        this.tiles = tiles;
+        this.wandTool = wandTool;
+        this.brushTool = brushTool;
+        this.eraserTool = eraserTool;
+        this.zoomToBoxTool = zoomToBoxTool;
+        this.samTool = samTool;
+        this.samPointTool = samPointTool;
+        this.cellSegmentTool = cellSegmentTool;
+        this.cellSegmenter = cellSegmenter;
+        this.simpleStack = simpleStack;
+        this.capabilities = capabilitiesOf([
+            ViewerFeature.ImageDisplay,
+            ViewerFeature.StackSlider,
+            ViewerFeature.PixelReadback,
+            ViewerFeature.Surface3D,
+            ViewerFeature.Isosurface,
+        ]);
+        this.viewer = null;
+        this.canvas = null;
+        this.host = null;
+        this.loaded = null;
+        this.lastPixels = null;
+        this.currentPlotType = PlotType.NAPARI_IMAGE;
+        /** napari-js high-level view owning the 3D volume layers (one additive tinted layer per channel
+         *  for multichannel, or a single grayscale volume). Null in 2D. */
+        this.volumeView = null;
+        /** True when the volume is composited from per-channel layers (vs a single grayscale volume). */
+        this.volumeMultichannel = false;
+        /** napari-js height-field surface mesh (NAPARI_SURFACE plot type; null otherwise). Built from a
+         *  single grayscale slice by {@link buildSurface} via napari-js's `heightField` + `addSurface`. */
+        this.surfaceLayer = null;
+        /** Which band the surface samples (a channel index for multichannel, else the composite). */
+        this.surfaceChannel = undefined;
+        /** Pre-loaded per-slice luminance planes (already decimated to the surface grid), keyed by z,
+         *  so the stack slider rebuilds the surface instantly. Filled by {@link preloadSurfacePlanes}. */
+        this.surfacePlanes = new Map();
+        /** In-plane grid cap for the active surface load (full grid ÷ the decimate factor). */
+        this.surfaceMaxGrid = SURFACE_MAX_GRID;
+        /** Contrast window [min,max] the current surface mesh was built with. A change reshapes the
+         *  mesh (pixel height = intensity within [min,max]), so it triggers a geometry rebuild. */
+        this.surfaceWindow = null;
+        /** Persisted wireframe choice for the surface (re-applied when a new surface mounts). */
+        this.surfaceWireframe = false;
+        /** napari-js 2D scatter points (region centroids) + its region-change subscription. */
+        this.scatter2dPoints = null;
+        this.scatterRegionSub = null;
+        /** napari-js 3D scatter (voxel point cloud). */
+        this.scatter3dLayer = null;
+        /** 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. */
+        this.loadToken = 0;
+        /** Decimate factor for the napari 3D types (1 = Full, 2 = ½ default, 4 = ¼, 8 = ⅛). Applied when a
+         *  volume/isosurface/surface (re)loads; changing it needs a re-plot (it changes fetched data). */
+        this.resolutionScale = NAPARI_DEFAULT_DECIMATE;
+        /** 3D coordinate-axes / scale gizmo for the volume/isosurface view (null in 2D). */
+        this.axesLayer = null;
+        /** DOM X/Y/Z + scale labels tracking the 3D axes gizmo (null in 2D). */
+        this.axesLabels = null;
+        /** Draggable Z-height grip over the volume (null unless a volume/isosurface is mounted). */
+        this.zHandle = null;
+        /** User Z-height factor for the volume (1 = the volume's natural proportions); driven by the
+         *  in-view drag handle. Reset per mount. */
+        this.volumeZScale = 1;
+        /** Volume world box at `volumeZScale = 1` (base) + the sampled voxel depth — enough to recompute
+         *  the Z-axis voxel scale, axes depth, and overlay anchors as the handle stretches Z. */
+        this.volumeWorldBase = null;
+        this.volumeSampledDepth = 1;
+        /** Persisted axes on/off choice, re-applied when a new volume mounts. Defaults on. */
+        this.axesVisible = true;
+        this.volumeDims = null;
+        /** Assembled uint8 volume data per channel (key = channel index), kept for the volume intensity
+         *  histogram. Key 0 holds the grayscale/composite volume in the single-channel case. */
+        this.volumeChannelData = new Map();
+        this.imageW = 0;
+        this.imageH = 0;
+        /** Monotonic slice-request id so a slow out-of-order slice fetch can't clobber a newer one. */
+        this.sliceReq = 0;
+        /** Cached `/tiles/info` pyramid descriptor + the infoB64 it was fetched for. */
+        this.descriptor = null;
+        this.descriptorKey = null;
+        /** How the current 2D image is composited (drives histogram + state application). */
+        this.imageMode = 'rgb';
+        /** napari-js high-level view that owns the per-channel layer set (build + live display
+         *  updates) for the current {@link imageMode}. Rebuilt on each (re)render. */
+        this.channelView = null;
+        /** Live subscription applying channel-state / colormap changes to the layers. */
+        this.displaySub = null;
+        /** Latest grayscale colormap selection from the store (applied to the single gray layer). */
+        this.currentColormap = null;
+        this.currentReverse = false;
+        /** Latest invert toggle from the store (flips intensity before the colormap, like OSD). */
+        this.invertEnabled = false;
+        /** Physical scale bar overlay for the 2D image (null when 3D or the image has no µm/pixel). */
+        this.scaleBar = null;
+        /** SVG region-drawing overlay for the 2D image (null until a 2D image is plotted). */
+        this.regionOverlay = null;
+        /** Pixel-tool plumbing: the plot div id, coord transform, and bound tool hosts. */
+        this.plotDivId = '';
+        this.coordTransform = null;
+        this.wandHost = null;
+        this.eraserHost = null;
+        /** Cached CachedImageData built from the last readback (rebuilt when lastPixels changes). */
+        this.cachedImage = null;
+        this.cachedImageSource = null;
+        /** Visible world rect captured AT the last readback — must pair with `lastPixels` so the pixel
+         *  tools' ratios/origin match the matrix's camera (using the live rect after a pan/zoom would
+         *  mis-scale the region). */
+        this.lastPixelsRect = null;
+        /** Image smoothing (bilinear) vs nearest-neighbour (crisp pixels, the default). */
+        this.imageSmoothing = false;
+        /** True when the 2D image is rendered via pyramidal TiledSources (descriptor available). */
+        this.tiled = false;
+        /** Debounced readback timer + camera-change unsubscribe (keep lastPixels current for tools). */
+        this.readbackTimer = null;
+        this.cameraReadbackOff = null;
+        /** Coarse per-channel luminance sample (keyed by channel index) for the histogram in tiled mode,
+         *  where the layers have no full in-memory pixels. Refreshed on plot + slice change. */
+        this.histSamples = new Map();
+        /** Native-bit-depth histograms from `/histogram`, keyed `${z}|${channel}` (>8-bit images). */
+        this.nativeHistograms = new Map();
+        this.stackLoading$ = new BehaviorSubject(false);
+        this.stackLoadingProgress$ = new BehaviorSubject(0);
+        this.autoscaleEvent$ = new Subject();
+        this.intensityProfile$ = new Subject();
+        this.viewportChange$ = new Subject();
+        this.api = config.slideCropServer;
+    }
+    /**
+     * Fetch + cache the server pyramid descriptor (`GET /tiles/info`): the REAL per-level tile grid,
+     * tile size, channel metadata and physical pixel size. The backend returns 202 while the source
+     * is still caching, so we poll briefly. Cached per `infoB64`; returns null if it never becomes
+     * ready (callers fall back to a single-tile fetch). This is the authoritative grid — guessing
+     * level dims from `trueImageSize` overshoots the real grid and the server 400s out-of-range tiles.
+     */
+    async ensureDescriptor() {
+        // Self-contained multi-slice stack (no tile server — e.g. a numbered image
+        // series assembled client-side, each slice a different file): there is no
+        // single server-tiled pyramid to describe. Returning null routes every
+        // caller (2D image, volume, surface) to their stitched/single-fetch
+        // fallback, which — via fetchSlice's own SimpleSliceAccessService branch —
+        // correctly fetches each slice's own URL instead of one fixed file's tile
+        // pyramid.
+        if (this.simpleStack.isSimple(this.loaded?.imageInfo))
+            return null;
+        const infoB64 = this.tiles.getSelectedInfoB64();
+        if (!infoB64)
+            return null;
+        if (this.descriptor && this.descriptorKey === infoB64)
+            return this.descriptor;
+        const headers = await this.tiles
+            .getAuthHeaders()
+            .catch(() => ({}));
+        const url = `${this.api}tiles/info?info=${infoB64}`;
+        const deadline = Date.now() + DESCRIPTOR_TIMEOUT_MS;
+        for (;;) {
+            try {
+                const resp = await fetch(url, { headers });
+                if (resp.status === 200) {
+                    const body = (await resp.json());
+                    if (body?.levels?.length) {
+                        this.descriptor = body;
+                        this.descriptorKey = infoB64;
+                        return body;
+                    }
+                }
+                // 202 (still caching) or empty body → re-poll until the deadline.
+            }
+            catch (err) {
+                console.warn('[napari-js] tiles/info poll retry', err);
+            }
+            if (Date.now() > deadline) {
+                console.warn('[napari-js] tiles/info not ready; falling back to single-tile fetch');
+                return null;
+            }
+            await new Promise((r) => setTimeout(r, 1200));
+        }
+    }
+    /**
+     * Fetch a COMPLETE rendered slice as an `ImageBitmap` by stitching the server's REAL tile grid
+     * (from `/tiles/info`) — not just the top-left tile, which only ever showed a large image's
+     * corner. Picks the finest pyramid level whose grid fits `budgetTiles` and whose longest side is
+     * within the GPU texture limit, fetches that grid concurrently, and stitches it into one canvas.
+     *
+     * `channel` selects a single band as grayscale (real levels only); omit for the server composite.
+     * `budgetTiles` caps the grid: the 2D view uses the full budget for detail; the 3D volume passes
+     * 1 for a cheap overview tile per slice (it downsamples to {@link VOLUME_MAX_SLICE}). Falls back
+     * to a single `col=0,row=0` tile when no descriptor is available (small/simple images, volumes).
+     */
+    async fetchSlice(z, channel, budgetTiles = MAX_STITCH_TILES, 
+    /** When a specific channel has no pyramid level within `budgetTiles`, drop to the server
+     *  COMPOSITE overview instead of stitching the huge per-channel level. Only safe when the caller
+     *  wants a single decimated plane (the surface height): for a multichannel VOLUME every channel
+     *  would then fetch the same composite and the channels would collapse into one, so volume
+     *  assembly leaves this `false` to keep each band distinct. */
+    allowCompositeFallback = false) {
+        // Self-contained multi-slice stack (tiled:false): `z` indexes a completely
+        // different file's own preview URL, not an internal slice of one server-
+        // tiled file — resolved and fetched via SimpleSliceAccessService (shared
+        // with OSD; see its docs for why this can't be a bare fetch()) instead of
+        // building a /tile?info=...&z= request against whichever single file
+        // getSelectedInfoB64() points at (which would 400/mismatch for any z
+        // beyond that one file's own extent).
+        const info = this.loaded?.imageInfo;
+        if (this.simpleStack.isSimple(info)) {
+            const url = this.simpleStack.urlFor(info, z);
+            if (!url)
+                throw new Error(`[napari-js] no URL for slice ${z}`);
+            return this.simpleStack.fetchAsBitmap(url);
+        }
+        const infoB64 = this.tiles.getSelectedInfoB64();
+        if (!infoB64)
+            throw new Error('[napari-js] no selected image info (getSelectedInfoB64 null)');
+        const headers = await this.tiles
+            .getAuthHeaders()
+            .catch(() => ({}));
+        const desc = await this.ensureDescriptor();
+        // The requested band; may be dropped to the composite (undefined) below when the channel has no
+        // pyramid level small enough to stitch within budget.
+        let effectiveChannel = channel;
+        const fetchTile = async (res, col, row, t) => {
+            const ch = effectiveChannel == null ? '' : `&channel=${effectiveChannel}`;
+            const url = `${this.api}tile?info=${infoB64}&res=${res}&col=${col}&row=${row}&z=${z}&tileSize=${t}${ch}`;
+            const resp = await fetch(url, { headers });
+            if (!resp.ok) {
+                throw new Error(`[napari-js] slice fetch failed: ${resp.status} (${col}/${row} res ${res})`);
+            }
+            return createImageBitmap(await resp.blob());
+        };
+        // No descriptor → single top-left tile (legacy fallback; correct for small/simple images).
+        if (!desc || !desc.levels?.length)
+            return fetchTile(0, 0, 0, TILE_SIZE);
+        const t = desc.tileSize || TILE_SIZE;
+        // Per-channel tiles exist ONLY at REAL Bio-Formats levels (the front of `levels`); the server
+        // composite exists at every level, including the small overviews.
+        const perChannelLevels = desc.realLevels ?? desc.levels.length;
+        const usable = channel == null ? desc.levels : desc.levels.slice(0, Math.max(1, perChannelLevels));
+        // Finest level whose stitched grid fits BOTH the tile budget and the GPU texture limit; if none
+        // fits, the coarsest available (fits=false).
+        const tilesFor = (lvl) => Math.max(1, Math.ceil(lvl.width / t)) * Math.max(1, Math.ceil(lvl.height / t));
+        const pick = (levels) => {
+            let c = levels[0];
+            for (const lvl of levels) {
+                c = lvl;
+                if (tilesFor(lvl) <= budgetTiles && Math.max(lvl.width, lvl.height) <= MAX_TEXTURE_DIM) {
+                    return { lvl, fits: true };
+                }
+            }
+            return { lvl: c, fits: false };
+        };
+        let sel = pick(usable);
+        // A specific channel only has tiles at the (few, large) real levels. When none of them fit the
+        // budget — e.g. the coarsest real level is still 14982×18670 → ~1100 full-res tiles — stitching
+        // it per slice floods the server (504s) and stalls the load. The composite pyramid has small
+        // overview levels, so fetch the composite instead and derive luminance from it. Every caller here
+        // (surface height, volume assembly, readback) downscales the plane anyway, so a composite-derived
+        // plane is the right trade for one that actually loads. Only kicks in when the channel can't fit.
+        if (allowCompositeFallback && !sel.fits && channel != null && desc.levels.length > perChannelLevels) {
+            const composite = pick(desc.levels);
+            if (composite.fits || tilesFor(composite.lvl) < tilesFor(sel.lvl)) {
+                effectiveChannel = undefined;
+                sel = composite;
+                console.warn(`[napari-js] channel ${channel} has no pyramid level within the ${budgetTiles}-tile ` +
+                    `budget; using the composite overview (res ${sel.lvl.res}, ${sel.lvl.width}×` +
+                    `${sel.lvl.height}) for this plane.`);
+            }
+        }
+        const chosen = sel.lvl;
+        const cols = Math.max(1, Math.ceil(chosen.width / t));
+        const rows = Math.max(1, Math.ceil(chosen.height / t));
+        if (!sel.fits && budgetTiles === MAX_STITCH_TILES) {
+            console.warn(`[napari-js] full resolution exceeds the ${budgetTiles}-tile/${MAX_TEXTURE_DIM}px budget; ` +
+                `displaying overview level res ${chosen.res} (${chosen.width}×${chosen.height}).`);
+        }
+        if (cols === 1 && rows === 1)
+            return fetchTile(chosen.res, 0, 0, t);
+        // Stitch into one level-sized canvas. Fetch the grid with BOUNDED concurrency: firing every tile
+        // at once (a big grid = hundreds of requests) overwhelmed the tile server (504s). Edge tiles are
+        // narrower/shorter; drawImage places each at its grid offset so partial tiles line up.
+        const coords = [];
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++)
+                coords.push({ col, row });
+        }
+        const tiles = [];
+        const stitchWorker = async () => {
+            for (;;) {
+                const job = coords.shift();
+                if (!job)
+                    return;
+                const bmp = await fetchTile(chosen.res, job.col, job.row, t);
+                tiles.push({ col: job.col, row: job.row, bmp });
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(TILE_FETCH_CONCURRENCY, coords.length) }, () => stitchWorker()));
+        let canvas;
+        if (typeof OffscreenCanvas !== 'undefined') {
+            canvas = new OffscreenCanvas(chosen.width, chosen.height);
+        }
+        else {
+            canvas = document.createElement('canvas');
+            canvas.width = chosen.width;
+            canvas.height = chosen.height;
+        }
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            throw new Error('[napari-js] slice stitch: 2D context unavailable');
+        for (const { col, row, bmp } of tiles) {
+            ctx.drawImage(bmp, col * t, row * t);
+            bmp.close?.();
+        }
+        // Safety net: if the chosen level still exceeds the GPU texture limit (e.g. a multichannel
+        // image whose coarsest REAL level is huge — overview levels are composite-only), downscale the
+        // stitched canvas to fit so the WebGPU texture upload can't fail.
+        const longest = Math.max(chosen.width, chosen.height);
+        if (longest > MAX_TEXTURE_DIM) {
+            const scale = MAX_TEXTURE_DIM / longest;
+            const outW = Math.max(1, Math.floor(chosen.width * scale));
+            const outH = Math.max(1, Math.floor(chosen.height * scale));
+            console.warn(`[napari-js] stitched level ${chosen.width}×${chosen.height} exceeds the ` +
+                `${MAX_TEXTURE_DIM}px texture limit; downscaling to ${outW}×${outH}.`);
+            let out;
+            if (typeof OffscreenCanvas !== 'undefined') {
+                out = new OffscreenCanvas(outW, outH);
+            }
+            else {
+                out = document.createElement('canvas');
+                out.width = outW;
+                out.height = outH;
+            }
+            const octx = out.getContext('2d');
+            if (!octx)
+                throw new Error('[napari-js] slice downscale: 2D context unavailable');
+            octx.drawImage(canvas, 0, 0, outW, outH);
+            return createImageBitmap(out);
+        }
+        return createImageBitmap(canvas);
+    }
+    // ── IDataRenderer: load / render / viewport ───────────────────────────────
+    async load(imageInfo, zIndex) {
+        // Keeps SimpleSliceAccessService's blob cache in sync even when the user
+        // switches backends (e.g. OSD Image → napari Volume) on the same file —
+        // whichever backend loads a genuinely different file first evicts it.
+        this.simpleStack.noteActiveFile(imageInfo.fileName);
+        this.loaded = { imageInfo, z: zIndex, filename: imageInfo.fileName };
+        return this.loaded;
+    }
+    async plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, _inPlace) {
+        const host = document.getElementById(plotDiv);
+        if (!host) {
+            console.error(`[napari-js] plot target #${plotDiv} not found`);
+            return false;
+        }
+        this.reset();
+        this.host = host;
+        this.plotDivId = plotDiv;
+        this.currentPlotType = plotType;
+        const canvas = document.createElement('canvas');
+        canvas.style.display = 'block';
+        canvas.style.width = '100%';
+        canvas.style.height = screenHeight ? `${screenHeight}px` : '100%';
+        host.appendChild(canvas);
+        this.canvas = canvas;
+        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 } });
+            this.viewer = viewer;
+            await viewer.ready;
+            if (isNapariScatter(plotType)) {
+                await this.mountScatter(viewer, z);
+            }
+            else if (isNapariScatter3d(plotType)) {
+                await this.mountScatter3d(viewer, info);
+            }
+            else if (isNapariSurface(plotType)) {
+                await this.mountSurface(viewer);
+            }
+            else if (isNapari3d(plotType)) {
+                await this.mountVolume(viewer, info, plotType);
+            }
+            else {
+                await this.renderImage(z);
+                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.scheduleReadback();
+            return true;
+        }
+        catch (err) {
+            console.error('[napari-js] plot failed:', err);
+            return false;
+        }
+    }
+    // ── Channels: per-channel composite, LUT, native histograms (jit-ui#102) ──────────────────
+    /** The grayscale display colormap from the store selection (+reverse), defaulting to gray.
+     *  Maps the jit-ui store colormap node to a napari `Colormap` via the library's LUT factory;
+     *  the multichannel tint ramps are built inside {@link MultiChannelImageView} from each
+     *  channel's hex colour. */
+    grayscaleColormap() {
+        const value = this.currentColormap?.data?.value;
+        const lut = value != null ? buildColormapLut(value, this.currentReverse) : null;
+        if (lut)
+            return colormapFromLut('gray-cmap', lut);
+        return this.currentReverse
+            ? colormapFromLut('gray-rev', [[255, 255, 255], [0, 0, 0]])
+            : 'gray';
+    }
+    /** Fetch a stitched slice and read it back as a single-channel uint8 plane. `channel` selects a
+     *  band (multichannel); omit it for the grayscale composite (all overview levels available, so a
+     *  large image picks a fitting downscaled level rather than only the full-res real level). */
+    async fetchChannelData(z, channel, budgetTiles) {
+        const bmp = await this.fetchSlice(z, channel, budgetTiles);
+        return this.bitmapToLuminance(bmp);
+    }
+    /** Decode an `ImageBitmap` (server bands are grayscale, R=G=B) to a single-channel uint8 plane.
+     *  `maxSide` caps the longest side (downscaling on the canvas draw) — used to keep pre-loaded
+     *  surface slice planes small. */
+    bitmapToLuminance(bmp, maxSide) {
+        const scale = maxSide ? Math.min(1, maxSide / Math.max(bmp.width, bmp.height, 1)) : 1;
+        const w = Math.max(1, Math.round(bmp.width * scale));
+        const h = Math.max(1, Math.round(bmp.height * scale));
+        let canvas;
+        if (typeof OffscreenCanvas !== 'undefined') {
+            canvas = new OffscreenCanvas(w, h);
+        }
+        else {
+            canvas = document.createElement('canvas');
+            canvas.width = w;
+            canvas.height = h;
+        }
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            throw new Error('[napari-js] channel readback: 2D context unavailable');
+        // Scale the WHOLE bitmap into the (possibly smaller) target canvas — drawing at natural size
+        // would crop to the top-left w×h corner when downscaling a large slice (maxSide < bmp size).
+        ctx.drawImage(bmp, 0, 0, w, h);
+        bmp.close?.();
+        const rgba = ctx.getImageData(0, 0, w, h).data;
+        const data = new Uint8Array(w * h);
+        for (let i = 0; i < w * h; i++)
+            data[i] = rgba[i * 4];
+        return { data, width: w, height: h };
+    }
+    /**
+     * Render the 2D image for slice `z`. With a server pyramid descriptor we use a pyramidal
+     * {@link TiledSource} per layer so the view refines to higher resolution on zoom (like OSD) and
+     * sits naturally in full-resolution coordinates; without one we fall back to the single-level
+     * stitch. Three display modes either way: multichannel additive tint, grayscale colormap, RGB.
+     */
+    async renderImage(z, token) {
+        const v = this.viewer;
+        if (!v)
+            return;
+        const desc = await this.ensureDescriptor();
+        if (desc && desc.levels?.length) {
+            if (token != null && token !== this.sliceReq)
+                return;
+            await this.renderImageTiled(z, desc);
+            return;
+        }
+        return this.renderImageStitched(z, token);
+    }
+    /** Single-level stitch fallback (no descriptor): the pre-tiling path. */
+    async renderImageStitched(z, token) {
+        const v = this.viewer;
+        if (!v)
+            return;
+        const desc = await this.ensureDescriptor();
+        const states = this.store.currentChannelStates();
+        const channelCount = desc?.channels ?? (states.length || 1);
+        const multichannel = !!desc?.multichannel && channelCount > 1;
+        // 1) Fetch all pixel data BEFORE touching the viewer, so a superseded scrub can bail without
+        //    having torn down the visible layers (avoids flicker / out-of-order layer state).
+        let mode;
+        let planes = [];
+        let bitmap = null;
+        if (multichannel) {
+            mode = 'multichannel';
+            planes = await Promise.all(Array.from({ length: channelCount }, (_, c) => this.fetchChannelData(z, c)));
+        }
+        else if (channelCount === 1) {
+            mode = 'grayscale';
+            // Composite fetch (no channel) → all overview levels usable, so a large grayscale image
+            // selects a fitting downscaled level instead of the full-res real level (texture limit).
+            planes = [await this.fetchChannelData(z)];
+        }
+        else {
+            mode = 'rgb';
+            bitmap = await this.fetchSlice(z);
+        }
+        // 2) Commit — unless a newer scrub superseded us or the viewer was torn down.
+        if ((token != null && token !== this.sliceReq) || this.viewer !== v) {
+            bitmap?.close?.();
+            return;
+        }
+        // The displayed texture may be a downscaled pyramid level; scale the layer into FULL-RESOLUTION
+        // world coordinates (level-0 pixels) so the camera, readback and — critically — pre-saved
+        // regions (stored in full-res coords, e.g. ndpi) all line up regardless of which level is shown.
+        // This mirrors OSD, whose coordinate system is always level 0.
+        const texW = mode === 'rgb' ? bitmap.width : planes[0]?.width ?? 0;
+        const texH = mode === 'rgb' ? bitmap.height : planes[0]?.height ?? 0;
+        const fullW = desc?.width || texW || 1;
+        const fullH = desc?.height || texH || 1;
+        const scale = [texW ? fullW / texW : 1, texH ? fullH / texH : 1];
+        this.imageMode = mode;
+        const interpolation = this.imageSmoothing ? 'linear' : 'nearest';
+        this.channelView = new MultiChannelImageView(v);
+        if (mode === 'multichannel') {
+            const views = planes.map((d, c) => {
+                const st = states.find((s) => s.index === c);
+                const color = st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c);
+                return {
+                    source: { kind: 'typed', width: d.width, height: d.height, channels: 1, dtype: 'uint8', data: d.data },
+                    tint: color,
+                    name: st?.name ?? `ch${c}`,
+                    contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+                    gamma: st?.gamma ?? 1,
+                    visible: st?.visible ?? true,
+                    invert: this.invertEnabled,
+                    scale,
+                };
+            });
+            this.channelView.render('multichannel', views, { interpolation });
+        }
+        else if (mode === 'grayscale') {
+            const d = planes[0];
+            const st = states[0];
+            this.channelView.render('grayscale', [
+                {
+                    source: { kind: 'typed', width: d.width, height: d.height, channels: 1, dtype: 'uint8', data: d.data },
+                    colormap: this.grayscaleColormap(),
+                    contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+                    gamma: st?.gamma ?? 1,
+                    invert: this.invertEnabled,
+                    scale,
+                },
+            ], { interpolation });
+        }
+        else {
+            this.channelView.render('rgb', [{ source: bitmap, scale }], { interpolation });
+        }
+        this.imageW = fullW;
+        this.imageH = fullH;
+    }
+    /**
+     * Render the 2D image with pyramidal {@link TiledSource}s — the view refines to higher resolution
+     * as you zoom in (the visual fetches the level whose texels ≈ screen pixels) and sits in full-res
+     * coordinates so regions align. Same three modes as the stitch path. Per-channel layers use the
+     * REAL pyramid levels (per-channel tiles only exist there); the composite uses all levels.
+     */
+    async renderImageTiled(z, desc) {
+        const v = this.viewer;
+        if (!v)
+            return;
+        const states = this.store.currentChannelStates();
+        const channelCount = desc.channels ?? (states.length || 1);
+        const multichannel = !!desc.multichannel && channelCount > 1;
+        const interpolation = this.imageSmoothing ? 'linear' : 'nearest';
+        this.tiled = true;
+        this.channelView = new MultiChannelImageView(v);
+        if (multichannel) {
+            this.imageMode = 'multichannel';
+            const views = [];
+            for (let c = 0; c < channelCount; c++) {
+                const st = states.find((s) => s.index === c);
+                const color = st?.color ?? desc.channelInfo?.[c]?.color ?? tintFor(c);
+                views.push({
+                    source: this.buildTiledSource(desc, c, 1),
+                    tint: color,
+                    name: st?.name ?? `ch${c}`,
+                    contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+                    gamma: st?.gamma ?? 1,
+                    visible: st?.visible ?? true,
+                    invert: this.invertEnabled,
+                });
+            }
+            this.channelView.render('multichannel', views, { interpolation });
+        }
+        else if (channelCount === 1) {
+            this.imageMode = 'grayscale';
+            const st = states[0];
+            this.channelView.render('grayscale', [
+                {
+                    source: this.buildTiledSource(desc, undefined, 1),
+                    colormap: this.grayscaleColormap(),
+                    contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+                    gamma: st?.gamma ?? 1,
+                    invert: this.invertEnabled,
+                },
+            ], { interpolation });
+        }
+        else {
+            this.imageMode = 'rgb';
+            this.channelView.render('rgb', [{ source: this.buildTiledSource(desc, undefined, 4) }], {
+                interpolation,
+            });
+        }
+        this.imageW = desc.width;
+        this.imageH = desc.height;
+        // Await on the initial render so getHistogram/autoContrast have data immediately; slice changes
+        // refresh fire-and-forget (the histogram pane retries).
+        await this.refreshHistogramSamples(z, desc);
+    }
+    /** Build a pyramidal TiledSource backed by the server `/tile` endpoint. `channel` selects a band
+     *  (grayscale luminance, real levels only); omit it for the composite (RGBA, all levels). */
+    buildTiledSource(desc, channel, channels) {
+        const infoB64 = this.tiles.getSelectedInfoB64() ?? '';
+        // Per-channel tiles exist only at REAL Bio-Formats levels; the composite exists at all levels.
+        const usable = channel == null
+            ? desc.levels
+            : desc.levels.slice(0, Math.max(1, desc.realLevels ?? desc.levels.length));
+        const levelScales = usable.map((l) => desc.width / Math.max(1, l.width)); // level-0 px per level px
+        const tileSize = desc.tileSize || TILE_SIZE;
+        const ch = channel == null ? '' : `&channel=${channel}`;
+        const api = this.api;
+        return {
+            kind: 'tiled',
+            width: desc.width,
+            height: desc.height,
+            tileSize,
+            levels: usable.length,
+            levelScales,
+            depth: Math.max(1, desc.z || 1),
+            channels,
+            dtype: 'uint8',
+            fetchTile: async (key) => {
+                const res = usable[key.level]?.res ?? key.level;
+                const url = `${api}tile?info=${infoB64}&res=${res}&col=${key.col}&row=${key.row}&z=${key.z}&tileSize=${tileSize}${ch}`;
+                const headers = await this.tiles
+                    .getAuthHeaders()
+                    .catch(() => ({}));
+                const resp = await fetch(url, { headers });
+                if (!resp.ok) {
+                    throw new Error(`[napari-js] tile ${key.level}/${key.col}/${key.row} → ${resp.status}`);
+                }
+                const bmp = await createImageBitmap(await resp.blob());
+                if (channels === 4)
+                    return { width: bmp.width, height: bmp.height, data: bmp };
+                return this.bitmapToLuminance(bmp);
+            },
+        };
+    }
+    /** (Re)fetch a coarse per-channel luminance sample for the histogram (tiled mode has no full
+     *  in-memory pixels). One cheap overview tile per channel; cached by channel index. */
+    async refreshHistogramSamples(z, desc) {
+        this.histSamples.clear();
+        if (this.imageMode === 'rgb')
+            return; // RGB uses the displayed-pixel readback (rgbHistogram)
+        const channelCount = this.imageMode === 'multichannel' ? desc.channels ?? 1 : 1;
+        for (let c = 0; c < channelCount; c++) {
+            try {
+                const ch = this.imageMode === 'multichannel' ? c : undefined;
+                const d = await this.fetchChannelData(z, ch, 1); // budget 1 → coarsest single tile
+                this.histSamples.set(c, d.data);
+            }
+            catch {
+                /* leave this channel's sample unset */
+            }
+        }
+    }
+    /** Subscribe channel states + grayscale colormap → live-apply to the rendered layers (no
+     *  re-fetch; only z changes re-fetch). Replaces any prior subscription. */
+    subscribeDisplayState() {
+        this.displaySub?.unsubscribe();
+        this.displaySub = combineLatest([
+            this.store.getChannelStates(),
+            this.store.getColormap(),
+            this.store.getReverseScale(),
+            this.store.getInvert(),
+        ]).subscribe(([channels, colormap, reverse, invert]) => {
+            this.currentColormap = colormap ?? null;
+            this.currentReverse = reverse;
+            this.invertEnabled = invert;
+            this.applyDisplayState(channels);
+        });
+    }
+    /** Subscribe the store colormap (+reverse), invert, and channel state → the volume/isosurface
+     *  transfer function: colour (channel tint or selected colormap), the intensity **window
+     *  (min/max → contrastLimits)** and **gamma**, mirroring the grayscale image's display controls
+     *  so the histogram pane drives the 3D render. Replaces any prior subscription. */
+    subscribeVolumeDisplayState() {
+        this.displaySub?.unsubscribe();
+        this.displaySub = combineLatest([
+            this.store.getColormap(),
+            this.store.getReverseScale(),
+            this.store.getInvert(),
+            this.store.getChannelStates(),
+        ]).subscribe(([colormap, reverse, invert, channels]) => {
+            this.currentColormap = colormap ?? null;
+            this.currentReverse = reverse;
+            this.invertEnabled = invert;
+            const view = this.volumeView;
+            if (!view)
+                return;
+            if (this.volumeMultichannel) {
+                // Each channel's layer is tinted by its colour and gets its own window/gamma/visibility.
+                view.layers.forEach((_, c) => {
+                    const st = channels.find((s) => s.index === c);
+                    view.updateChannel(c, {
+                        colormap: this.channelTintColormap(st?.color ?? '#ffffff'),
+                        ...(st
+                            ? {
+                                contrastLimits: [st.min, st.max],
+                                gamma: st.gamma,
+                                visible: st.visible,
+                            }
+                            : {}),
+                    });
+                });
+            }
+            else {
+                const st = channels[0];
+                view.updateChannel(0, {
+                    colormap: this.volumeColormap(st),
+                    ...(st ? { contrastLimits: [st.min, st.max], gamma: st.gamma } : {}),
+                });
+            }
+        });
+    }
+    /** A channel's tint colormap (black→colour) with reverse-scale / invert applied by flipping. */
+    channelTintColormap(color) {
+        let cmap = tintColormap(color);
+        if (this.currentReverse)
+            cmap = reverseColormap(cmap);
+        if (this.invertEnabled)
+            cmap = reverseColormap(cmap);
+        return cmap;
+    }
+    /**
+     * Colour map for the volume/isosurface. A real colormap selection (viridis/magma/…) wins;
+     * otherwise the channel's colour tints it (so the channel-dialog colour swatch recolors the 3D
+     * render). Reverse-scale and invert each flip the ramp — the `VolumeLayer` has no per-layer
+     * invert, so both are emulated by reversing the colormap.
+     */
+    volumeColormap(st) {
+        const node = this.currentColormap;
+        // A colored colormap (viridis/magma/…) drives the volume; the default grayscale family
+        // (gray / Greys / Greys Inv) yields to the channel's colour so the dialog colour swatch
+        // recolors the 3D render.
+        const label = (node?.label ?? '').toLowerCase();
+        const grayFamily = label === '' || label.includes('grey') || label.includes('gray');
+        const value = node?.data?.value;
+        const lut = !grayFamily && value != null ? buildColormapLut(value, false) : null;
+        let cmap = lut
+            ? colormapFromLut('vol-cmap', lut)
+            : tintColormap(st?.color ?? '#ffffff');
+        // Reverse-scale and invert each flip the ramp (the VolumeLayer has no per-layer invert).
+        if (this.currentReverse)
+            cmap = reverseColormap(cmap);
+        if (this.invertEnabled)
+            cmap = reverseColormap(cmap);
+        return cmap;
+    }
+    /** Apply the current channel states / colormap to the live layers (no re-fetch), delegating the
+     *  per-channel layer mutations to the {@link MultiChannelImageView}. */
+    applyDisplayState(channels) {
+        const view = this.channelView;
+        if (!this.viewer || !view)
+            return;
+        if (this.imageMode === 'multichannel') {
+            view.layers.forEach((_, c) => {
+                const st = channels.find((s) => s.index === c);
+                if (!st)
+                    return;
+                view.updateChannel(c, {
+                    tint: st.color,
+                    contrastLimits: [st.min, st.max],
+                    gamma: st.gamma,
+                    visible: st.visible,
+                    invert: this.invertEnabled,
+                });
+            });
+        }
+        else if (this.imageMode === 'grayscale') {
+            const st = channels[0];
+            view.updateChannel(0, {
+                colormap: this.grayscaleColormap(),
+                invert: this.invertEnabled,
+                ...(st ? { contrastLimits: [st.min, st.max], gamma: st.gamma } : {}),
+            });
+        }
+    }
+    /** (Re)install the physical scale bar over the 2D image, sized from the image's µm/pixel
+     *  (`/tiles/info` mppX, falling back to the image metadata). No-op without a physical size. */
+    installScaleBar() {
+        this.scaleBar?.destroy();
+        this.scaleBar = null;
+        const mppX = this.descriptor?.mppX || this.loaded?.imageInfo.imageMeta?.[0]?.mppX || 0;
+        if (this.viewer && this.host && mppX > 0) {
+            this.scaleBar = new NapariScaleBar(this.host, this.viewer.camera, mppX);
+        }
+    }
+    /** Convert a napari-js `Histogram` (bin count + min/max) to the pane's `IHistogram` (bin edges). */
+    toIHistogram(h) {
+        const span = h.max - h.min || 1;
+        const bins = Array.from({ length: h.bins }, (_, i) => h.min + (i * span) / h.bins);
+        const counts = Array.from(h.counts);
+        return { bins, counts, max: counts.reduce((m, c) => (c > m ? c : m), 0) };
+    }
+    /**
+     * Mount the 3D volume/isosurface. A multichannel image becomes one additive, tinted
+     * {@link VolumeLayer} per channel (so each channel's colour composites into the render); a
+     * grayscale/composite image uses a single volume. Adds the axes gizmo + labels and wires the
+     * display-state subscription. The caller owns `viewer.ready`.
+     */
+    async mountVolume(viewer, info, plotType) {
+        const token = this.loadToken; // bail before rendering if a Cancel / new plot bumps this
+        const desc = await this.ensureDescriptor();
+        const channelCount = desc?.channels ?? 1;
+        const multichannel = !!desc?.multichannel && channelCount > 1;
+        const res = volumeResolutionFor(this.resolutionScale);
+        const rendering = isNapariIsosurface(plotType) ? 'iso' : 'mip';
+        const states = this.store.currentChannelStates();
+        this.volumeChannelData.clear();
+        this.volumeMultichannel = multichannel;
+        this.imageMode = multichannel ? '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
+        // owns the layer orchestration (one additive tinted volume per channel, or a single grayscale
+        // volume). The adapter computes each channel's colormap (incl. invert/reverse flips).
+        let dims = null;
+        const channels = [];
+        this.stackLoading$.next(true);
+        this.stackLoadingProgress$.next(0);
+        try {
+            if (multichannel) {
+                for (let c = 0; c < channelCount; c++) {
+                    const vol = await this.assembleVolume(info, res, c);
+                    if (!vol)
+                        continue;
+                    dims = vol;
+                    this.volumeChannelData.set(c, vol.data);
+                    const st = states.find((s) => s.index === c);
+                    const color = st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c);
+                    channels.push({
+                        data: vol.data,
+                        width: vol.width,
+                        height: vol.height,
+                        depth: vol.depth,
+                        colormap: this.channelTintColormap(color),
+                        contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+                        gamma: st?.gamma ?? 1,
+                        visible: st?.visible ?? true,
+                    });
+                }
+            }
+            else {
+                const vol = await this.assembleVolume(info, res);
+                if (vol) {
+                    dims = vol;
+                    this.volumeChannelData.set(0, vol.data);
+                    const st = states[0];
+                    channels.push({
+                        data: vol.data,
+                        width: vol.width,
+                        height: vol.height,
+                        depth: vol.depth,
+                        colormap: this.volumeColormap(st),
+                        contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+                        gamma: st?.gamma ?? 1,
+                    });
+                }
+            }
+        }
+        finally {
+            this.stackLoading$.next(false);
+            this.stackLoadingProgress$.next(0);
+        }
+        if (!dims || !channels.length || this.loadToken !== token)
+            return; // cancelled → don't render
+        // Resolution-invariant world box. 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. 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,
+        };
+        // 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;
+        this.volumeSampledDepth = Math.max(1, dims.depth);
+        const worldZ = world.depth * this.volumeZScale;
+        const voxelSize = [
+            world.width / dims.width,
+            world.height / dims.height,
+            worldZ / this.volumeSampledDepth,
+        ];
+        for (const ch of channels)
+            ch.voxelSize = voxelSize;
+        view.render(multichannel ? '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.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
+            // tip (×1.12) so the grip clears the "Z · …" label. Drag ↕ to restretch Z live.
+            this.zHandle = new NapariVolumeZHandle(this.host, viewer.camera3d, {
+                topAnchor: () => [
+                    -this.volumeWorldBase.width / 2,
+                    -this.volumeWorldBase.height / 2,
+                    ((this.volumeWorldBase.depth * this.volumeZScale) / 2) * 1.12,
+                ],
+                getScale: () => this.volumeZScale,
+                setScale: (s) => this.setVolumeZScale(s),
+            });
+        }
+        this.subscribeVolumeDisplayState();
+    }
+    /**
+     * Restretch the volume's Z height live (driven by the in-view {@link NapariVolumeZHandle}). Only
+     * the per-axis `voxelSize` / axes depth change — the voxel textures are untouched — so dragging is
+     * smooth. `factor` is relative to the volume's natural proportions (1). Persists across re-mounts
+     * (resolution changes) so the chosen height sticks.
+     */
+    setVolumeZScale(factor) {
+        this.volumeZScale = Math.min(10, Math.max(0.1, factor));
+        const base = this.volumeWorldBase;
+        if (!base || !this.volumeView)
+            return;
+        const worldZ = base.depth * this.volumeZScale;
+        const vsZ = worldZ / this.volumeSampledDepth;
+        for (const layer of this.volumeView.layers) {
+            const [sx, sy] = layer.voxelSize;
+            layer.voxelSize = [sx, sy, vsZ];
+        }
+        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.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) {
+        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`);
+        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' },
+        ];
+    }
+    /**
+     * 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
+     * stack) and read into the volume as each arrives, driving {@link stackLoadingProgress$} so the
+     * host shows a determinate progress bar instead of a bare spinner.
+     */
+    async assembleVolume(info, opts = {}, channel) {
+        const token = this.loadToken; // bail if a Cancel / new plot bumps this while we fetch
+        const fullDepth = info?.imageMeta?.[0]?.z || info?.urls?.length || 1;
+        if (fullDepth < 1) {
+            console.warn('[napari-js] no slices to assemble a volume');
+            return null;
+        }
+        const step = Math.max(1, Math.floor(opts.sliceStep ?? 1));
+        const maxSlice = opts.maxSlice ?? VOLUME_MAX_SLICE;
+        // Source-slice indices sampled into the volume (every `step`th plane → low-res is faster).
+        const zIndices = [];
+        for (let z = 0; z < fullDepth; z += step)
+            zIndices.push(z);
+        const depth = zIndices.length;
+        this.stackLoadingProgress$.next(0);
+        try {
+            // Fetch each slice at a pyramid level matching `maxSlice` (budget scales with the decimate
+            // factor), so a higher factor pulls a finer level → more real in-plane detail; then downsample
+            // to `maxSlice`. `channel` selects a band (multichannel volume); omit for the grayscale
+            // composite. The caller owns the stackLoading flag (multichannel assembles channels in turn).
+            const budget = this.tileBudgetFor(maxSlice);
+            const first = await this.fetchSlice(zIndices[0], channel, budget);
+            const scale = Math.min(1, maxSlice / Math.max(first.width, first.height, 1));
+            const width = Math.max(1, Math.round(first.width * scale));
+            const height = Math.max(1, Math.round(first.height * scale));
+            const data = new Uint8Array(width * height * depth);
+            let canvas;
+            if (typeof OffscreenCanvas !== 'undefined') {
+                canvas = new OffscreenCanvas(width, height);
+            }
+            else {
+                canvas = document.createElement('canvas');
+                canvas.width = width;
+                canvas.height = height;
+            }
+            const ctx = canvas.getContext('2d');
+            if (!ctx)
+                throw new Error('napari-js volume assembly: 2D context unavailable');
+            // Read one fetched slice bitmap into the volume plane `z` (luminance). Synchronous between
+            // awaits, so the shared 2D context is safe to reuse across the concurrent fetch workers.
+            let done = 0;
+            const readSlice = (z, bmp) => {
+                ctx.clearRect(0, 0, width, height);
+                ctx.drawImage(bmp, 0, 0, width, height);
+                const rgba = ctx.getImageData(0, 0, width, height).data;
+                const base = z * width * height;
+                for (let i = 0; i < width * height; i++) {
+                    data[base + i] =
+                        (rgba[i * 4] * 0.299 + rgba[i * 4 + 1] * 0.587 + rgba[i * 4 + 2] * 0.114) | 0;
+                }
+                bmp.close?.();
+                done++;
+                this.stackLoadingProgress$.next(Math.round((done / depth) * 100));
+            };
+            readSlice(0, first);
+            // Remaining planes via a small pool of workers draining a shared queue. Each plane `p`
+            // maps to source slice `zIndices[p]` (subsampled for low-res).
+            const pending = [];
+            for (let p = 1; p < depth; p++)
+                pending.push(p);
+            const worker = async () => {
+                for (;;) {
+                    const p = pending.shift();
+                    if (p === undefined || this.loadToken !== token)
+                        return;
+                    readSlice(p, await this.fetchSlice(zIndices[p], channel, budget));
+                }
+            };
+            const poolSize = Math.min(VOLUME_FETCH_CONCURRENCY, Math.max(1, depth - 1));
+            await Promise.all(Array.from({ length: poolSize }, () => worker()));
+            if (this.loadToken !== token)
+                return null; // cancelled → don't render a partial volume
+            return { data, width, height, depth };
+        }
+        finally {
+            this.stackLoadingProgress$.next(0);
+        }
+    }
+    /**
+     * Mount the NAPARI_SCATTER 2D scatter: the slice image with a points layer at each region's
+     * centroid (napari-js analog of Plotly's region-centroid scatter). Rebuilds the points live as
+     * regions change.
+     */
+    async mountScatter(viewer, z) {
+        await this.renderImage(z);
+        this.fitCameraSoon();
+        this.subscribeDisplayState();
+        this.installScaleBar();
+        this.rebuildScatterPoints();
+        this.scatterRegionSub = this.regionStore
+            .getRegionUpdateEvent()
+            .subscribe(() => this.rebuildScatterPoints());
+        this.scheduleReadback();
+    }
+    /** (Re)build the 2D scatter's point layer at the current region centroids. */
+    rebuildScatterPoints() {
+        const v = this.viewer;
+        if (!v)
+            return;
+        if (this.scatter2dPoints) {
+            v.layers.remove(this.scatter2dPoints);
+            this.scatter2dPoints = null;
+        }
+        const centroids = this.regionCentroids();
+        if (centroids.length === 0)
+            return;
+        this.scatter2dPoints = v.addPoints(centroids, {
+            size: 12,
+            faceColor: [1, 0.85, 0.2, 1],
+            borderColor: [0, 0, 0, 1],
+            borderWidth: 2,
+        });
+    }
+    /** Region centroids as flat `[x, y, …]` data coords (rectangle / polygon / multipolygon). */
+    regionCentroids() {
+        const out = [];
+        const polyCentroid = (xs, ys) => {
+            const n = xs.length;
+            if (n === 0)
+                return;
+            let cx = 0;
+            let cy = 0;
+            for (let i = 0; i < n; i++) {
+                cx += xs[i];
+                cy += ys[i];
+            }
+            out.push(cx / n, cy / n);
+        };
+        for (const r of this.regionStore.getRegions()) {
+            const b = r.bounds;
+            if (!b)
+                continue;
+            if ('width' in b && 'x' in b) {
+                out.push(b.x + b.width / 2, b.y + b.height / 2);
+            }
+            else if ('xpoints' in b) {
+                polyCentroid(b.xpoints, b.ypoints);
+            }
+            else if ('polygons' in b) {
+                for (const p of b.polygons)
+                    polyCentroid(p.xpoints, p.ypoints);
+            }
+        }
+        return new Float32Array(out);
+    }
+    /**
+     * 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
+     * emits a flat-strided sample of voxels (capped at {@link SCATTER3D_MAX_POINTS}) via `addPoints3D`.
+     */
+    async mountScatter3d(viewer, info) {
+        this.imageMode = 'grayscale';
+        this.volumeMultichannel = false;
+        const res = volumeResolutionFor(this.resolutionScale);
+        this.stackLoading$.next(true);
+        this.stackLoadingProgress$.next(0);
+        let vol = null;
+        try {
+            vol = await this.assembleVolume(info, {
+                maxSlice: Math.min(res.maxSlice, SCATTER3D_MAX_XY),
+                sliceStep: res.sliceStep,
+            });
+        }
+        finally {
+            this.stackLoading$.next(false);
+            this.stackLoadingProgress$.next(0);
+        }
+        if (!vol || this.viewer !== viewer)
+            return;
+        const { data, width, height, depth } = vol;
+        const zScale = Math.max(width, height) / Math.max(1, depth); // ≈ cubic aspect
+        const total = width * height * depth;
+        const stride = Math.max(1, Math.ceil(total / SCATTER3D_MAX_POINTS));
+        const pos = [];
+        const val = [];
+        for (let i = 0; i < total; i += stride) {
+            const x = i % width;
+            const y = Math.floor(i / width) % height;
+            const zi = Math.floor(i / (width * height));
+            pos.push(x, y, zi * zScale);
+            val.push(data[i]);
+        }
+        const st = this.store.currentChannelStates()[0];
+        this.scatter3dLayer = viewer.addPoints3D(new Float32Array(pos), new Float32Array(val), {
+            colormap: this.volumeColormap(st),
+            contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+            size: 3,
+        });
+        this.imageW = width;
+        this.imageH = height;
+        this.volumeDims = { width, height, depth };
+        // Feed the intensity histogram from the assembled volume (key 0).
+        this.volumeChannelData.clear();
+        this.volumeChannelData.set(0, data);
+        this.subscribeScatter3dDisplayState();
+        this.scheduleReadback();
+    }
+    /** Store colormap / reverse / invert / channel window → the 3D scatter's colormap + contrast. */
+    subscribeScatter3dDisplayState() {
+        this.displaySub?.unsubscribe();
+        this.displaySub = combineLatest([
+            this.store.getColormap(),
+            this.store.getReverseScale(),
+            this.store.getInvert(),
+            this.store.getChannelStates(),
+        ]).subscribe(([colormap, reverse, invert, channels]) => {
+            this.currentColormap = colormap ?? null;
+            this.currentReverse = reverse;
+            this.invertEnabled = invert;
+            const layer = this.scatter3dLayer;
+            if (!layer)
+                return;
+            const st = channels[0];
+            layer.colormap = this.volumeColormap(st);
+            if (st)
+                layer.contrastLimits = [st.min, st.max];
+            this.viewer?.requestRender();
+        });
+    }
+    /**
+     * Mount the NAPARI_SURFACE height-field surface. A height field is single-scalar, so for a
+     * multichannel image the surface follows ONE band — the first visible channel (fallback 0) —
+     * coloured by that channel's window/colormap (like the Plotly SURFACE, which is grayscale-only).
+     * Pre-loads every slice's height data with a progress bar (as the volume does) so the stack
+     * slider re-slices instantly, then builds the mesh for the current slice. All mesh + GPU work
+     * lives in napari-js (`heightField` + `Viewer.addSurface`); this backend supplies scalar slices.
+     */
+    async mountSurface(viewer) {
+        const desc = await this.ensureDescriptor();
+        const multichannel = !!desc?.multichannel && (desc?.channels ?? 1) > 1;
+        const states = this.store.currentChannelStates();
+        this.surfaceChannel = multichannel ? states.find((s) => s.visible)?.index ?? 0 : undefined;
+        this.surfaceMaxGrid = surfaceResolutionFor(this.resolutionScale).maxGrid;
+        this.imageMode = 'grayscale';
+        this.volumeMultichannel = false;
+        await this.preloadSurfacePlanes(viewer);
+        if (this.viewer !== viewer)
+            return;
+        await this.buildSurface(viewer, this.loaded?.z ?? 0);
+        this.installSurfaceAxes(viewer);
+        // Subscribe after the first build so display-state edits target a live layer.
+        this.subscribeSurfaceDisplayState();
+    }
+    /** Add the 3D axes gizmo + DOM labels around the (origin-centered) surface mesh, matching the
+     *  volume/isosurface. Installed once per mount; the box tracks the mesh bounds, X/Y show the
+     *  physical (or pixel) extent, and Z is the intensity/height axis. */
+    installSurfaceAxes(viewer) {
+        if (!this.surfaceLayer)
+            return;
+        const b = this.surfaceLayer.bounds();
+        const boxW = Math.max(1, b.max[0] - b.min[0]);
+        const boxH = Math.max(1, b.max[1] - b.min[1]);
+        const boxD = Math.max(1, b.max[2] - b.min[2]);
+        const mppX = this.descriptor?.mppX || this.loaded?.imageInfo.imageMeta?.[0]?.mppX || 0;
+        const voxel = mppX > 0 ? (mppX * (this.descriptor?.width ?? this.imageW)) / Math.max(1, this.imageW) : 1;
+        this.axesLayer = viewer.addAxes(boxW, boxH, boxD, {
+            voxelSize: [voxel, voxel, 1],
+            visible: this.axesVisible,
+        });
+        if (this.host) {
+            this.axesLabels = new NapariAxesLabels(this.host, viewer.camera3d, this.buildSurfaceAxesLabels(boxW, boxH, boxD, mppX));
+            this.axesLabels.setVisible(this.axesVisible);
+        }
+    }
+    /** X/Y/Z end-labels for the surface gizmo: X/Y are the physical (µm) or pixel extent of the FULL
+     *  image; Z is the intensity/height axis. Anchors are in the centered box (matching AxesLayer). */
+    buildSurfaceAxesLabels(boxW, boxH, boxD, mppX) {
+        const hx = boxW / 2;
+        const hy = boxH / 2;
+        const hz = boxD / 2;
+        const descW = this.descriptor?.width ?? this.imageW;
+        const descH = this.descriptor?.height ?? this.imageH;
+        const len = (px) => (mppX > 0 ? formatUm(px * mppX) : `${px} 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 · intensity', color: '#668cff' },
+        ];
+    }
+    /**
+     * Pre-fetch every stack slice's luminance plane (decimated to the surface grid) into
+     * {@link surfacePlanes}, driving {@link stackLoadingProgress$} — the same load-with-progress UX
+     * as the volume, but keeping one 2D plane per slice rather than packing a 3D volume. Bounded
+     * concurrency keeps the connection pool busy without flooding it on a deep stack.
+     */
+    async preloadSurfacePlanes(viewer) {
+        const token = this.loadToken; // bail if a Cancel / new plot bumps this while we fetch
+        const info = this.loaded?.imageInfo;
+        const depth = info?.imageMeta?.[0]?.z || info?.urls?.length || 1;
+        const { maxGrid } = surfaceResolutionFor(this.resolutionScale);
+        this.surfacePlanes.clear();
+        this.stackLoading$.next(true);
+        this.stackLoadingProgress$.next(0);
+        try {
+            const pending = [];
+            for (let z = 0; z < depth; z++)
+                pending.push(z);
+            let done = 0;
+            const worker = async () => {
+                for (;;) {
+                    const z = pending.shift();
+                    if (z === undefined || this.viewer !== viewer || this.loadToken !== token)
+                        return;
+                    try {
+                        this.surfacePlanes.set(z, await this.fetchSurfacePlane(z, maxGrid));
+                    }
+                    catch (err) {
+                        console.warn(`[napari-js] surface slice ${z} preload failed`, err);
+                    }
+                    done++;
+                    this.stackLoadingProgress$.next(Math.round((done / depth) * 100));
+                }
+            };
+            const pool = Math.min(VOLUME_FETCH_CONCURRENCY, Math.max(1, depth));
+            await Promise.all(Array.from({ length: pool }, () => worker()));
+        }
+        finally {
+            this.stackLoading$.next(false);
+            this.stackLoadingProgress$.next(0);
+        }
+    }
+    /**
+     * Fetch slice `z` as a single WHOLE-image luminance plane (decimated to `maxGrid`). Prefers the
+     * app's complete per-slice image (`smallUrls`/`urls`, exactly like the Plotly surface) so the
+     * surface always covers the FULL slice — the tile-pyramid `fetchSlice` path would fall back to a
+     * single top-left tile (a corner) for self-contained / non-`/tiles/info` images. Falls back to
+     * stitching the tile grid only when no complete-image URL is available.
+     */
+    /** Tile budget to stitch a whole slice at ~`targetPx` resolution from the pyramid: a higher target
+     *  pulls a FINER pyramid level (more real detail). Shared by the surface plane fetch and the volume
+     *  assembly so both scale their in-plane resolution with the decimate factor. */
+    tileBudgetFor(targetPx) {
+        const tileSize = this.descriptor?.tileSize || TILE_SIZE;
+        return Math.min(MAX_STITCH_TILES, Math.max(1, Math.round((targetPx / tileSize) ** 2 * STITCH_BUDGET_COEFF)));
+    }
+    async fetchSurfacePlane(z, maxGrid) {
+        const info = this.loaded?.imageInfo;
+        const desc = await this.ensureDescriptor();
+        let plane = null;
+        // Preferred: stitch the WHOLE slice from the server pyramid at a resolution driven by the
+        // decimate factor — a higher target grid pulls a FINER pyramid level (more real detail). With a
+        // descriptor, fetchSlice stitches the whole chosen level (never a corner), then we downscale to
+        // the grid. This is what makes "Full" actually higher-res than "½", not just a fixed preview.
+        if (desc?.levels?.length) {
+            const budget = this.tileBudgetFor(maxGrid);
+            // The surface is a single decimated plane, so the composite fallback is acceptable when the
+            // channel has no small pyramid level (keeps it fast); a multichannel VOLUME must not do this.
+            plane = this.bitmapToLuminance(await this.fetchSlice(z, this.surfaceChannel, budget, true), maxGrid);
+        }
+        // Fallback (no pyramid): the app's COMPLETE per-slice image (urls[z], not the small blurry
+        // thumbnail) — whole slice, avoids a corner tile. Capped at the image's own resolution.
+        if (!plane) {
+            const url = info?.urls?.[z] ?? info?.smallUrls?.[z];
+            if (url) {
+                try {
+                    const headers = await this.tiles
+                        .getAuthHeaders()
+                        .catch(() => ({}));
+                    const resp = await fetch(url, { headers });
+                    if (resp.ok) {
+                        plane = this.bitmapToLuminance(await createImageBitmap(await resp.blob()), maxGrid);
+                    }
+                }
+                catch (err) {
+                    console.warn(`[napari-js] surface url fetch failed for z=${z}`, err);
+                }
+            }
+        }
+        // Last resort (no pyramid and no complete image): a single tile.
+        if (!plane) {
+            plane = this.bitmapToLuminance(await this.fetchSlice(z, this.surfaceChannel, this.tileBudgetFor(maxGrid), true), maxGrid);
+        }
+        return plane;
+    }
+    /** The channel state driving the surface: the chosen band for multichannel (matched by index),
+     *  else the single grayscale channel. */
+    surfaceState(channels) {
+        if (this.surfaceChannel == null)
+            return channels[0];
+        return channels.find((s) => s.index === this.surfaceChannel) ?? channels[0];
+    }
+    /**
+     * (Re)build the surface mesh for slice `z` from the pre-loaded plane cache (instant — this is
+     * what the stack slider calls); a slice missing from the cache is fetched on demand. napari-js's
+     * pure `heightField` builds the triangle grid (z = normalized intensity), then `addSurface`
+     * renders it. The slice plane also feeds the intensity histogram (key 0).
+     */
+    async buildSurface(viewer, z) {
+        let plane = this.surfacePlanes.get(z);
+        if (!plane) {
+            this.stackLoading$.next(true);
+            try {
+                plane = await this.fetchSurfacePlane(z, this.surfaceMaxGrid);
+                this.surfacePlanes.set(z, plane);
+            }
+            catch (err) {
+                console.error('[napari-js] surface slice fetch failed:', err);
+            }
+            finally {
+                this.stackLoading$.next(false);
+            }
+        }
+        if (!plane || plane.width < 2 || plane.height < 2 || this.viewer !== viewer)
+            return;
+        const st = this.surfaceState(this.store.currentChannelStates());
+        const win = [st?.min ?? 0, st?.max ?? 255];
+        this.surfaceWindow = win;
+        // Height AND colour are normalized by the same contrast window, so changing min/max reshapes the
+        // surface (a pixel's height = its intensity within [min,max]). Center it for the axes gizmo. The
+        // plane is already decimated to the grid cap → stride 1.
+        const zScale = SURFACE_Z_ASPECT * Math.max(plane.width, plane.height);
+        const { vertices, faces, values } = heightField(plane.data, plane.width, plane.height, {
+            zScale,
+            zLimits: win,
+            center: true,
+        });
+        // Preserve the orbit camera across a re-slice / window rebuild — only the first mount frames, so
+        // stepping the stack or changing the window keeps the current zoom/pan/orientation.
+        const cam = viewer.camera3d;
+        const preserveCamera = this.surfaceLayer != null;
+        const savedTarget = cam.target;
+        const savedDistance = cam.distance;
+        if (this.surfaceLayer) {
+            viewer.layers.remove(this.surfaceLayer);
+            this.surfaceLayer = null;
+        }
+        this.surfaceLayer = viewer.addSurface(vertices, faces, values, {
+            colormap: this.volumeColormap(st),
+            contrastLimits: win,
+            gamma: st?.gamma ?? 1,
+            wireframe: this.surfaceWireframe,
+        });
+        if (preserveCamera) {
+            cam.target = savedTarget;
+            cam.distance = savedDistance;
+        }
+        this.imageW = plane.width;
+        this.imageH = plane.height;
+        this.volumeDims = { width: plane.width, height: plane.height, depth: Math.max(1, Math.round(zScale)) };
+        // Reuse the volume intensity-histogram path: the slice's scalar plane is the histogram source.
+        this.volumeChannelData.clear();
+        this.volumeChannelData.set(0, plane.data);
+        this.scheduleReadback();
+    }
+    /** Subscribe the store colormap / reverse / invert / channel window → the surface, so histogram
+     *  & channel-dialog edits update it live without a re-fetch. **min/max reshapes the surface's
+     *  height** (a pixel's height = its intensity within [min,max]), so a window change rebuilds the
+     *  mesh geometry (from the cached slice); colour-only edits (colormap/LUT, gamma, reverse, invert)
+     *  just update the layer's uniforms. */
+    subscribeSurfaceDisplayState() {
+        this.displaySub?.unsubscribe();
+        this.displaySub = combineLatest([
+            this.store.getColormap(),
+            this.store.getReverseScale(),
+            this.store.getInvert(),
+            this.store.getChannelStates(),
+        ]).subscribe(([colormap, reverse, invert, channels]) => {
+            this.currentColormap = colormap ?? null;
+            this.currentReverse = reverse;
+            this.invertEnabled = invert;
+            const layer = this.surfaceLayer;
+            if (!layer || !this.viewer)
+                return;
+            const st = this.surfaceState(channels);
+            const win = [st?.min ?? 0, st?.max ?? 255];
+            const windowChanged = !this.surfaceWindow || win[0] !== this.surfaceWindow[0] || win[1] !== this.surfaceWindow[1];
+            if (windowChanged) {
+                // Height follows the contrast window → rebuild the mesh for the new [min,max] (camera kept).
+                void this.buildSurface(this.viewer, this.loaded?.z ?? 0).catch((err) => console.error('[napari-js] surface window rebuild failed:', err));
+                return;
+            }
+            // Colour-only change: update uniforms in place, no geometry rebuild.
+            layer.colormap = this.volumeColormap(st);
+            if (st) {
+                layer.contrastLimits = win;
+                layer.gamma = st.gamma;
+            }
+            this.viewer.requestRender();
+        });
+    }
+    fitCameraSoon() {
+        const run = () => {
+            if (this.viewer && this.canvas && this.imageW > 0 && this.imageH > 0) {
+                this.viewer.camera.fit(this.imageW, this.imageH, this.canvas.clientWidth || this.imageW, this.canvas.clientHeight || this.imageH);
+            }
+        };
+        if (typeof requestAnimationFrame === 'function')
+            requestAnimationFrame(run);
+        else
+            run();
+    }
+    /** @deprecated Plotly-specific; host re-drives plot() from its image stream. */
+    reloadAndPlot() {
+        /* no-op */
+    }
+    reset() {
+        this.loadToken++; // invalidate any in-flight frame loading from the previous plot
+        this.displaySub?.unsubscribe();
+        this.displaySub = null;
+        this.scaleBar?.destroy();
+        this.scaleBar = null;
+        this.regionOverlay?.destroy();
+        this.regionOverlay = null;
+        this.axesLabels?.destroy();
+        this.axesLabels = null;
+        this.zHandle?.destroy();
+        this.zHandle = null;
+        this.volumeWorldBase = null;
+        this.cachedImage = null;
+        this.cachedImageSource = null;
+        this.lastPixelsRect = null;
+        this.nativeHistograms.clear();
+        this.tiled = false;
+        this.histSamples.clear();
+        if (this.readbackTimer != null) {
+            clearTimeout(this.readbackTimer);
+            this.readbackTimer = null;
+        }
+        this.cameraReadbackOff?.();
+        this.cameraReadbackOff = null;
+        this.channelView = null;
+        this.viewer?.dispose();
+        this.viewer = null;
+        if (this.canvas && this.host?.contains(this.canvas))
+            this.host.removeChild(this.canvas);
+        this.canvas = null;
+        this.lastPixels = null;
+        this.volumeView = null;
+        this.volumeMultichannel = false;
+        this.surfaceLayer = null;
+        this.surfaceChannel = undefined;
+        this.surfacePlanes.clear();
+        this.surfaceWindow = null;
+        this.scatterRegionSub?.unsubscribe();
+        this.scatterRegionSub = null;
+        this.scatter2dPoints = null;
+        this.scatter3dLayer = null;
+        this.axesLayer = null;
+        this.volumeDims = null;
+        this.volumeChannelData.clear();
+    }
+    relayout(_trueImageSize) {
+        this.viewer?.requestRender();
+    }
+    /** @deprecated Plotly-specific axis reset. */
+    resetAxes() {
+        this.fitCameraSoon();
+    }
+    /** @deprecated Plotly-specific autoscale. */
+    autoscale() {
+        this.fitCameraSoon();
+        this.autoscaleEvent$.next(undefined);
+    }
+    zoomIn() {
+        if (this.viewer)
+            this.viewer.camera.zoom = this.viewer.camera.zoom * 1.3;
+    }
+    zoomOut() {
+        if (this.viewer)
+            this.viewer.camera.zoom = this.viewer.camera.zoom / 1.3;
+    }
+    setDragMode(_mode) {
+        // No-op: pan and zoom are always the napari camera's default gestures, and pan/zoom gating for
+        // drawing is owned by the region overlay's setMode (setControlsEnabled). Toggling controls here
+        // would fight that — the host calls setDragMode(false) alongside overlay.setMode(<tool>).
+    }
+    setNavigatorVisible(_visible) {
+        /* napari-js has no minimap; no-op */
+    }
+    setImageSmoothingEnabled(enabled) {
+        this.imageSmoothing = enabled;
+        // Apply live to the rendered image layers; baked into the next render too.
+        this.channelView?.setInterpolation(enabled ? 'linear' : 'nearest');
+    }
+    setShowStack(_showstack) {
+        /* stack navigated via setZIndex */
+    }
+    setZIndex(zIndex) {
+        if (this.loaded)
+            this.loaded.z = zIndex;
+        const v = this.viewer;
+        if (!v)
+            return;
+        // Surface: one slice → one mesh, so re-build the height field for the new slice.
+        if (this.surfaceLayer) {
+            void this.buildSurface(v, zIndex).catch((err) => console.error('[napari-js] setZIndex surface failed:', err));
+            return;
+        }
+        // Volume / isosurface: step the volume's z plane in place.
+        if (this.volumeView) {
+            v.dims.z = zIndex;
+            this.scheduleReadback();
+            return;
+        }
+        // Tiled 2D image: just move the dims plane — the tiled visual fetches the new slice's tiles
+        // (cached per z), no layer rebuild. Refresh the coarse histogram sample for the new slice.
+        if (this.tiled) {
+            v.dims.z = zIndex;
+            if (this.descriptor)
+                void this.refreshHistogramSamples(zIndex, this.descriptor);
+            this.scheduleReadback();
+            return;
+        }
+        // 2D image (stitch fallback): re-render the slice (re-fetches per-channel / composite). Branch
+        // of a volume layer (not currentPlotType, which could be stale and silently no-op the swap).
+        // The token lets renderImage drop a superseded scrub so a slow older slice can't clobber a newer one.
+        const req = ++this.sliceReq;
+        void this.renderImage(zIndex, req)
+            .then(() => {
+            if (req === this.sliceReq)
+                this.scheduleReadback();
+        })
+            .catch((err) => console.error('[napari-js] setZIndex slice failed:', err));
+    }
+    setStackLoading(stackLoading) {
+        this.stackLoading$.next(stackLoading);
+    }
+    /** Cancel in-flight frame loading: bump the load generation so the volume-assembly / surface
+     *  preload workers stop fetching more frames, and clear the loading flag + progress. */
+    cancelLoading() {
+        this.loadToken++;
+        this.stackLoading$.next(false);
+        this.stackLoadingProgress$.next(0);
+    }
+    isStackLoading() {
+        return this.stackLoading$.asObservable();
+    }
+    getStackLoadingProgress() {
+        return this.stackLoadingProgress$.asObservable();
+    }
+    getTrueImageSize() {
+        return this.imageW > 0 && this.imageH > 0 ? { width: this.imageW, height: this.imageH } : null;
+    }
+    getCurrentImage() {
+        return Promise.resolve(null);
+    }
+    getDisplayedPixelData() {
+        return this.lastPixels;
+    }
+    getDisplayedSourceRect() {
+        const v = this.viewer;
+        const size = this.getTrueImageSize();
+        if (!v || !size)
+            return null;
+        const r = v.visibleWorldRect();
+        const x = Math.max(0, r.x);
+        const y = Math.max(0, r.y);
+        return {
+            x,
+            y,
+            width: Math.min(size.width, r.x + r.width) - x,
+            height: Math.min(size.height, r.y + r.height) - y,
+        };
+    }
+    downloadImage() {
+        void this.exportComposite();
+    }
+    setPlotType(plotType) {
+        this.currentPlotType = plotType;
+    }
+    /** Map a Plotly-style 3D drag mode onto napari-js's camera drag mode. */
+    setSurfaceDragMode(mode) {
+        if (!this.viewer)
+            return;
+        const m = mode === 'pan' ? 'pan' : mode === 'zoom' ? 'zoom' : 'rotate'; // orbit/turntable → rotate
+        this.viewer.setCameraDragMode(m);
+    }
+    /** Re-frame the 3D camera on the current 3D layer. A surface mesh sits in the positive octant
+     *  (not centred), so frame it by its own bounds; a volume/isosurface uses its centred box. */
+    resetSurfaceCamera() {
+        if (!this.viewer)
+            return;
+        const meshLayer = this.surfaceLayer ?? this.scatter3dLayer;
+        if (meshLayer) {
+            const b = meshLayer.bounds();
+            this.viewer.camera3d.target = b.center;
+            this.viewer.camera3d.distance = Math.max(b.radius * 2.5, 1e-3);
+            this.viewer.requestRender();
+            return;
+        }
+        const d = this.volumeDims;
+        if (d)
+            this.viewer.camera3d.frame(d.width, d.height, d.depth);
+    }
+    getAutoscaleEvent() {
+        return this.autoscaleEvent$.asObservable();
+    }
+    getPlotTypeDescriptors() {
+        // The WebGPU napari-js options, offered alongside (not replacing) the OSD/Plotly types.
+        return [
+            PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_IMAGE],
+            PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_SCATTER],
+            PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_SURFACE],
+            PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_SCATTER3D],
+            PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_VOLUME],
+            PLOT_TYPE_DESCRIPTORS[PlotType.NAPARI_ISOSURFACE],
+        ];
+    }
+    /** The napari 3D decimate factor (1 = full … 8 = ⅛). Read by the toolbar to init the control. */
+    getResolutionScale() {
+        return this.resolutionScale;
+    }
+    /** Set the decimate factor for the napari 3D types. Takes effect on the next (re)load — the host
+     *  re-plots after calling this, since decimation changes the fetched/assembled data. */
+    setResolutionScale(scale) {
+        this.resolutionScale = Math.max(1, Math.round(scale));
+    }
+    getIntensityProfile$() {
+        return this.intensityProfile$.asObservable();
+    }
+    renderIntensityInset(_divId, _profiles) {
+        /* Plotly owns the intensity inset */
+    }
+    /** Read the displayed composite into `lastPixels` (the pixel-tools' source) + emit the clamped
+     *  visible region. A fresh PixelData object means cachedImageData() rebuilds automatically. */
+    async runReadback() {
+        const v = this.viewer;
+        if (!v)
+            return;
+        try {
+            const px = await v.readDisplayedPixels();
+            if (this.viewer !== v)
+                return;
+            const rect = v.visibleWorldRect(); // capture WITH the pixels (same camera)
+            this.lastPixels = px;
+            this.lastPixelsRect = rect;
+            const size = this.getTrueImageSize();
+            if (size && rect) {
+                const x = Math.max(0, Math.min(size.width, rect.x));
+                const y = Math.max(0, Math.min(size.height, rect.y));
+                const width = Math.max(1, Math.min(size.width - x, rect.width));
+                const height = Math.max(1, Math.min(size.height - y, rect.height));
+                this.viewportChange$.next({ x, y, width, height });
+            }
+        }
+        catch {
+            /* readback unavailable */
+        }
+    }
+    scheduleReadback() {
+        if (!this.viewer)
+            return;
+        if (typeof requestAnimationFrame === 'function')
+            requestAnimationFrame(() => void this.runReadback());
+        else
+            setTimeout(() => void this.runReadback(), 0);
+    }
+    /** Debounced readback — armed on camera changes so `lastPixels` tracks the current view after a
+     *  pan/zoom settles (and after tiled levels finish loading), which the on-canvas pixel tools
+     *  (wand/brush/SAM) read synchronously. Coalesces rapid changes. */
+    armReadback(delayMs = 250) {
+        if (this.readbackTimer != null)
+            clearTimeout(this.readbackTimer);
+        this.readbackTimer = setTimeout(() => {
+            this.readbackTimer = null;
+            void this.runReadback();
+        }, delayMs);
+    }
+    // ── IRegionStore + classification colours ──────────────────────────────────
+    // Inherited from BaseStoreVisualizer — pure delegations to the shared
+    // RegionStore / VisualizerStore (identical to the OSD backend).
+    // ── Pixel tools: reuse the shared, backend-agnostic tool services with a napari host ───────
+    /** Build the coordinate transform + tool hosts for the current viewer (called from plot()). The
+     *  pixel tools read displayed pixels synchronously from the last readback and convert pointer
+     *  coords via the napari camera, exactly mirroring the OSD host. */
+    buildToolHosts() {
+        if (!this.viewer)
+            return;
+        this.coordTransform = new NapariCoordinateTransform(this.viewer, () => !!this.viewer && this.imageW > 0);
+        const regions = this.regionStore;
+        this.wandHost = {
+            getRegions: () => regions.getRegions(),
+            setRegions: (r) => regions.setRegions(r),
+            getCachedImageData: () => this.cachedImageData(),
+            getActiveFrameIndex: () => this.loaded?.z ?? 0,
+            getOverlayContainer: () => this.host,
+            getCoordinateTransform: () => this.coordTransform,
+            getFileName: () => this.loaded?.filename,
+            getShapeColor: () => regions.getShapeColor(),
+        };
+        this.eraserHost = {
+            getRegions: () => regions.getRegions(),
+            setRegions: (r) => regions.setRegions(r),
+            invalidateWandRegion: () => this.wandTool.clearActiveRegion(),
+            getOverlayContainer: () => this.host,
+            getCoordinateTransform: () => this.coordTransform,
+            getCachedImageRatio: () => this.cachedImageData()?.ratios[0] ?? 1,
+        };
+    }
+    zoomBoxHost() {
+        return {
+            getPlotDiv: () => this.plotDivId,
+            pixelToData: (px, py) => {
+                const rect = this.host?.getBoundingClientRect();
+                if (!this.viewer || !rect)
+                    return { x: 0, y: 0 };
+                const [x, y] = this.viewer.canvasToWorld(rect.left + px, rect.top + py);
+                return { x, y };
+            },
+            applyZoomToBox: (coords) => this.applyZoomToBox(coords),
+        };
+    }
+    /** Zoom/pan the camera to fit a data-space rectangle `[xMin, xMax, yMax, yMin]`. */
+    applyZoomToBox(coordinates) {
+        const v = this.viewer;
+        if (!v || !this.canvas || coordinates.length < 4)
+            return;
+        const [xMin, xMax, yA, yB] = coordinates;
+        const x0 = Math.min(xMin, xMax);
+        const x1 = Math.max(xMin, xMax);
+        const y0 = Math.min(yA, yB);
+        const y1 = Math.max(yA, yB);
+        const w = Math.max(1, x1 - x0);
+        const h = Math.max(1, y1 - y0);
+        const vw = this.canvas.clientWidth || w;
+        const vh = this.canvas.clientHeight || h;
+        v.camera.center = [(x0 + x1) / 2, (y0 + y1) / 2];
+        v.camera.zoom = Math.min(vw / w, vh / h);
+        v.requestRender();
+    }
+    /** Build CachedImageData from the most recent readback (RGBA device pixels → [y][x]=[r,g,b]),
+     *  with ratios/origin mapping image coords ↔ readback pixels. Cached until the readback changes. */
+    cachedImageData() {
+        const px = this.lastPixels;
+        if (!px || !this.viewer)
+            return null;
+        if (this.cachedImage && this.cachedImageSource === px)
+            return this.cachedImage;
+        const w = px.width;
+        const h = px.height;
+        const data = px.data;
+        const matrix = new Array(h);
+        for (let y = 0; y < h; y++) {
+            const row = new Array(w);
+            const base = y * w * 4;
+            for (let x = 0; x < w; x++) {
+                const o = base + x * 4;
+                row[x] = [data[o], data[o + 1], data[o + 2]];
+            }
+            matrix[y] = row;
+        }
+        // Use the rect captured WITH this readback (not the live one) so ratios/origin match the
+        // matrix's camera — otherwise a pan/zoom since the readback mis-scales the traced region.
+        const rect = this.lastPixelsRect ?? this.viewer.visibleWorldRect();
+        this.cachedImage = {
+            frames: [matrix],
+            width: w,
+            height: h,
+            ratios: [rect.width / w, rect.height / h],
+            isGrayscale: false,
+            originX: rect.x,
+            originY: rect.y,
+        };
+        this.cachedImageSource = px;
+        return this.cachedImage;
+    }
+    // ── IToolController ────────────────────────────────────────────────────────
+    // Control gating: a tool that ACTIVATES disables the camera controls; deactivation is a no-op
+    // because the host always calls the region overlay's setMode FIRST in each toggle (which sets
+    // the baseline enabled/disabled), so re-enabling here would fight a freshly-activated draw mode.
+    setWandMode(active, options) {
+        if (!this.viewer)
+            return; // no plot yet → nothing to drive
+        if (!active) {
+            this.wandTool.setMode(false);
+            return;
+        }
+        this.viewer?.setControlsEnabled(false);
+        this.cachedImageSource = null;
+        this.armReadback(0);
+        if (this.wandHost)
+            this.wandTool.bindHost(this.wandHost);
+        this.wandTool.setMode(true, (options ?? {}));
+    }
+    setWandOptions(options) {
+        this.wandTool.setOptions((options ?? {}));
+    }
+    clearActiveWandRegion() {
+        this.wandTool.clearActiveRegion();
+    }
+    setBrushMode(active, options) {
+        if (!this.viewer)
+            return;
+        if (!active) {
+            this.brushTool.setMode(false);
+            return;
+        }
+        this.viewer?.setControlsEnabled(false);
+        this.cachedImageSource = null;
+        this.armReadback(0);
+        if (this.wandHost)
+            this.brushTool.bindHost(this.wandHost);
+        this.brushTool.setMode(true, (options ?? {}));
+    }
+    setBrushOptions(options) {
+        if (options?.size != null)
+            this.brushTool.setSize(options.size);
+    }
+    setVertexEraserMode(active) {
+        if (!this.viewer)
+            return;
+        if (active) {
+            this.viewer?.setControlsEnabled(false);
+            this.cachedImageSource = null;
+            if (this.eraserHost)
+                this.eraserTool.bindHost(this.eraserHost);
+        }
+        this.eraserTool.setMode(active);
+    }
+    setVertexEraserRadius(radius) {
+        this.eraserTool.setRadius(radius);
+    }
+    setZoomToBoxMode(active) {
+        if (!this.viewer)
+            return;
+        if (active) {
+            this.viewer?.setControlsEnabled(false);
+            this.zoomToBoxTool.bindHost(this.zoomBoxHost());
+        }
+        this.zoomToBoxTool.setMode(active);
+    }
+    // SAM / cellpose — server round-trips that read the drawn rectangles + displayed pixels through
+    // the same wand host (rectangles from the RegionStore, image from the readback).
+    async segmentRectangles() {
+        if (!this.viewer || !this.wandHost)
+            return 0;
+        await this.runReadback(); // the SAM embedding samples the currently-displayed image
+        this.cachedImageSource = null;
+        this.samTool.bindHost(this.wandHost);
+        return this.samTool.segmentBoxes();
+    }
+    async segmentRectanglesCellpose() {
+        if (!this.viewer || !this.wandHost || !this.cellSegmenter)
+            return 0;
+        await this.runReadback();
+        this.cachedImageSource = null;
+        this.cellSegmentTool.bindHost(this.wandHost);
+        return this.cellSegmentTool.segmentBoxes(this.cellSegmenter);
+    }
+    setSamModel(id) {
+        this.samTool.setModel(id);
+        this.samPointTool.setModel(id);
+    }
+    setSamPointMode(active) {
+        if (!this.viewer)
+            return;
+        if (active) {
+            this.viewer?.setControlsEnabled(false);
+            this.cachedImageSource = null;
+            this.armReadback(0); // refresh the readback the click's embedding will sample
+            if (this.wandHost)
+                this.samPointTool.bindHost(this.wandHost);
+        }
+        this.samPointTool.setMode(active);
+    }
+    commitSamPoints() {
+        this.samPointTool.commit();
+    }
+    clearSamPoints() {
+        this.samPointTool.clear();
+    }
+    // ── IDisplayOptions ───────────────────────────────────────────────────────
+    // Inherited from BaseStoreVisualizer — pure delegations to the shared
+    // VisualizerStore (identical to the OSD backend).
+    // ── IIntensitySampling: Plotly owns sampling; emit viewport changes ───────
+    ensureIntensitySampling(_imageInfo, _zIndex) {
+        return Promise.resolve();
+    }
+    refreshIntensitySamplingForRoi(_x, _y, _width, _height, _zIndex) { }
+    getViewportChange$() {
+        return this.viewportChange$.asObservable();
+    }
+    // ── IVisualizer composite members ─────────────────────────────────────────
+    getRegionOverlay() {
+        return this.regionOverlay;
+    }
+    getIsosurfaceControls() {
+        if (!this.volumeView)
+            return null;
+        return {
+            setIsoRange: (isoMin, isoMax) => {
+                // Apply to every channel's volume layer.
+                for (const layer of this.volumeView?.layers ?? []) {
+                    layer.contrastLimits = [isoMin, isoMax];
+                    layer.rendering = 'iso';
+                    layer.isoThreshold = 0.5;
+                }
+                this.viewer?.requestRender();
+            },
+        };
+    }
+    getIntensityControls() {
+        return null;
+    }
+    getSurface3dControls() {
+        if (!this.volumeView && !this.surfaceLayer && !this.scatter3dLayer)
+            return null;
+        return {
+            setSurfaceDragMode: (mode) => this.setSurfaceDragMode(mode),
+            resetSurfaceCamera: () => this.resetSurfaceCamera(),
+            setAxesVisible: (visible) => {
+                this.axesVisible = visible;
+                this.axesLabels?.setVisible(visible);
+                if (this.axesLayer) {
+                    this.axesLayer.visible = visible;
+                    this.viewer?.requestRender();
+                }
+            },
+            axesVisible: () => this.axesVisible,
+            // Surface wireframe (napari-js surface only) — a live layer property, no rebuild needed.
+            setWireframe: (on) => {
+                this.surfaceWireframe = on;
+                if (this.surfaceLayer) {
+                    this.surfaceLayer.wireframe = on;
+                    this.viewer?.requestRender();
+                }
+            },
+            wireframe: () => this.surfaceWireframe,
+        };
+    }
+    getHistogram(channelIndex, bins) {
+        const v = this.viewer;
+        if (!v)
+            return null;
+        // Volume / isosurface: intensity histogram of the assembled (downsampled) uint8 volume for the
+        // requested channel (multichannel) or the single grayscale volume (key 0).
+        if (this.volumeChannelData.size) {
+            const data = this.volumeChannelData.get(channelIndex) ?? this.volumeChannelData.get(0);
+            return data ? this.toIHistogram(histogramScalar(data, bins, 0, 255)) : null;
+        }
+        // Tiled mode has no full in-memory pixels → use the coarse per-channel sample (RGB: readback).
+        if (this.tiled) {
+            if (this.imageMode === 'rgb')
+                return this.rgbHistogram(channelIndex, bins);
+            const sample = this.histSamples.get(this.imageMode === 'grayscale' ? 0 : channelIndex);
+            return sample ? this.toIHistogram(histogramScalar(sample, bins, 0, 255)) : null;
+        }
+        // Grayscale/multichannel (stitch): native per-channel histogram straight from the in-memory
+        // scalar layer (no GPU readback). RGB: bin the displayed pixels' R/G/B byte (8-bit client path).
+        const layer = this.channelView?.layers[this.imageMode === 'grayscale' ? 0 : channelIndex];
+        if (layer) {
+            const h = v.layerHistogram(layer, bins);
+            if (h)
+                return this.toIHistogram(h);
+        }
+        if (this.imageMode === 'rgb')
+            return this.rgbHistogram(channelIndex, bins);
+        return null;
+    }
+    getHistogram$(channelIndex, bins) {
+        // >8-bit channels: fetch the true native distribution from the server (the displayed pixels
+        // are 8-bit, so the client histogram would be clipped). 8-bit channels use the client path.
+        const bitDepth = this.descriptor?.channelInfo?.[channelIndex]?.bitDepth ?? 8;
+        if (bitDepth > 8) {
+            const z = this.loaded?.z ?? 0;
+            const key = `${z}|${channelIndex}`;
+            const cached = this.nativeHistograms.get(key);
+            if (cached)
+                return of(cached);
+            return from(this.fetchNativeHistogram(channelIndex, bins, z, key));
+        }
+        return of(this.getHistogram(channelIndex, bins));
+    }
+    /** Fetch + cache one channel's native-bit-depth histogram from `GET /histogram` (>8-bit). */
+    async fetchNativeHistogram(channel, bins, z, key) {
+        const infoB64 = this.tiles.getSelectedInfoB64();
+        if (!infoB64)
+            return null;
+        const headers = await this.tiles
+            .getAuthHeaders()
+            .catch(() => ({}));
+        const url = `${this.api}histogram?info=${infoB64}&channel=${channel}&z=${z}&bins=${bins}`;
+        try {
+            const resp = await fetch(url, { headers });
+            if (!resp.ok)
+                return null; // 202 (still caching) or transient → null; the pane retries
+            const hi = (await resp.json());
+            if (!hi?.counts)
+                return null;
+            const out = {
+                bins: hi.counts.map((_, i) => hi.rangeMin + i * hi.binWidth),
+                counts: hi.counts,
+                max: hi.counts.reduce((m, c) => (c > m ? c : m), 0),
+                bitDepth: hi.bitDepth,
+                rangeMin: hi.rangeMin,
+                rangeMax: hi.rangeMax,
+                observedMin: hi.observedMin,
+                observedMax: hi.observedMax,
+            };
+            this.nativeHistograms.set(key, out);
+            return out;
+        }
+        catch (err) {
+            console.warn('[napari-js] native histogram fetch failed', err);
+            return null;
+        }
+    }
+    /** Per-channel histogram of the displayed RGB composite (R/G/B byte), from the last readback. */
+    rgbHistogram(channelIndex, bins) {
+        const px = this.lastPixels;
+        if (!px)
+            return null;
+        const band = Math.max(0, Math.min(2, channelIndex));
+        const n = Math.max(1, Math.min(256, Math.floor(bins) || 256));
+        const counts = new Array(n).fill(0);
+        const data = px.data;
+        for (let i = 0; i < data.length; i += 4) {
+            if (data[i + 3] === 0)
+                continue; // skip transparent padding
+            counts[Math.min(n - 1, (data[i + band] * n) >> 8)]++;
+        }
+        const binsArr = Array.from({ length: n }, (_, i) => (i * 256) / n);
+        return { bins: binsArr, counts, max: counts.reduce((m, c) => (c > m ? c : m), 0) };
+    }
+    exportComposite() {
+        const v = this.viewer;
+        if (!v)
+            return;
+        void v.screenshot().then((blob) => {
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = 'napari-js.png';
+            a.click();
+            URL.revokeObjectURL(url);
+        });
+    }
+    /** Native-bit-depth (16/32-bit) multi-band TIFF export via the server `/export/tiff` endpoint —
+     *  the displayed PNG is an 8-bit figure, this preserves the true pixel values. Visible channels
+     *  only (omitted when all are visible → server default). Mirrors the OSD backend. */
+    async exportData() {
+        const infoB64 = this.tiles.getSelectedInfoB64();
+        if (!infoB64)
+            return;
+        const states = this.store.currentChannelStates();
+        const visible = states.filter((c) => c.visible).map((c) => c.index);
+        const chParam = visible.length && visible.length < states.length ? `&channels=${visible.join(',')}` : '';
+        const z = this.loaded?.z ?? 0;
+        const url = `${this.api}export/tiff?info=${infoB64}&z=${z}${chParam}`;
+        const stem = (this.loaded?.filename || 'image').replace(/\.[^.]+$/, '');
+        const headers = await this.tiles
+            .getAuthHeaders()
+            .catch(() => ({}));
+        try {
+            const resp = await fetch(url, { headers });
+            if (resp.status === 202) {
+                console.warn('[napari-js] 16-bit export: file still caching — try again shortly.');
+                return;
+            }
+            if (!resp.ok)
+                throw new Error(`status ${resp.status}`);
+            saveAs(await resp.blob(), `${stem}_16bit.ome.tif`);
+        }
+        catch (err) {
+            console.warn('[napari-js] 16-bit TIFF export failed', err);
+        }
+    }
+    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.ɵ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: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TILE_ACCESS_PORT]
+                }] }, { type: i1.VisualizerStore }, { type: i2.RegionStore }, { type: i3.WandToolService }, { type: i4.BrushToolService }, { type: i5.VertexEraserToolService }, { type: i6.ZoomToBoxToolService }, { type: i7.SamToolService }, { type: i8.SamPointToolService }, { type: i9.CellSegmentToolService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CELL_SEGMENTER]
+                }] }, { 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  /** 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      const url = 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    const channelCount = desc?.channels ?? 1;\n    const multichannel = !!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 multichannel = !!desc?.multichannel && (desc?.channels ?? 1) > 1;\n    const states = this.store.currentChannelStates();\n    this.surfaceChannel = multichannel ? states.find((s) => s.visible)?.index ?? 0 : 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    ]).subscribe(([colormap, reverse, invert, channels]) => {\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      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"]}