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

package/esm2022/lib/implementations/osd/openseadragon-visualizer.service.mjs

@@ -0,0 +1,1780 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { BehaviorSubject, Subject, combineLatest, firstValueFrom, of } from 'rxjs';
+import { timeout } from 'rxjs/operators';
+import { OSD } from './osd-lib';
+import { VisualizerStore } from '../../store/visualizer-store.service';
+import { RegionStore } from '../../store/region-store.service';
+import { TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';
+import { VIZ_CONFIG } from '../../contracts/viz-config';
+import { PlotType, PLOT_TYPE_DESCRIPTORS } from '../../contracts/plot-type';
+import { ViewerFeature, capabilitiesOf } from '../../contracts/capabilities.contract';
+import { OsdRegionOverlay } from './osd-region-overlay';
+import { OsdScaleBar } from './osd-scale-bar';
+import { OsdCoordinateTransform } from './osd-coordinate-transform';
+import { elementToImage, imageRectToViewport, viewportRectToImage } from './osd-coords';
+import { buildTileUrl, fetchTileBitmap } from './tile-client';
+import { SliceCache } from './slice-cache';
+import { DisplayPipeline } from './display-pipeline';
+import { HistogramSampler } from './histogram-sampler';
+import { BaseStoreVisualizer } from '../base-store-visualizer';
+import { SimpleSliceAccessService } from '../simple-slice-access.service';
+import { WandToolService } from '../../toolbar/wand/wand-tool.service';
+import { BrushToolService } from '../../toolbar/brush/brush-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 { VertexEraserToolService } from '../../toolbar/vertex-eraser/vertex-eraser-tool.service';
+import { ZoomToBoxToolService } from '../../toolbar/zoom-to-box/zoom-to-box-tool.service';
+import { buildColormapLut } from '../../contracts/colormap-lut';
+import { saveAs } from 'file-saver';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../toolbar/wand/wand-tool.service";
+import * as i3 from "../../toolbar/brush/brush-tool.service";
+import * as i4 from "../../toolbar/segmentation/sam-tool.service";
+import * as i5 from "../../toolbar/segmentation/sam-point-tool.service";
+import * as i6 from "../../toolbar/segmentation/cell-segment-tool.service";
+import * as i7 from "../../toolbar/vertex-eraser/vertex-eraser-tool.service";
+import * as i8 from "../../toolbar/zoom-to-box/zoom-to-box-tool.service";
+import * as i9 from "../../store/visualizer-store.service";
+import * as i10 from "../../store/region-store.service";
+import * as i11 from "../simple-slice-access.service";
+/**
+ * Quiet OpenSeadragon's "[Viewport.*] is not accurate with multi-image" advisories.
+ * A multichannel image is composited from one TiledImage per channel — a legitimate
+ * multi-image world — and OSD logs that advisory (at error level) from its own
+ * navigator/overview rendering on every animation frame, flooding the console. Our
+ * own image<->viewport conversions already route through world item 0 (see
+ * osd-coords), so the remaining advisories are OSD-internal and only affect the
+ * minimap's box accuracy (cosmetic). This wraps OSD's logger in a Proxy that drops
+ * only that one message string and forwards every other log untouched. Idempotent.
+ */
+function silenceOsdMultiImageAdvisory() {
+    const osd = OSD;
+    if (osd.__multiImageFilterInstalled)
+        return;
+    const base = (osd.console && typeof osd.console.error === 'function')
+        ? osd.console
+        : (typeof console !== 'undefined' ? console : null);
+    if (!base)
+        return;
+    const isAdvisory = (a) => typeof a === 'string' && a.indexOf('not accurate with multi-image') !== -1;
+    osd.console = new Proxy(base, {
+        get(target, prop) {
+            const orig = target[prop];
+            if ((prop === 'error' || prop === 'warn') && typeof orig === 'function') {
+                return (...args) => { if (isAdvisory(args[0]))
+                    return; orig.apply(target, args); };
+            }
+            return typeof orig === 'function' ? orig.bind(target) : orig;
+        },
+    });
+    osd.__multiImageFilterInstalled = true;
+}
+/**
+ * OpenSeadragon visualization backend.
+ *
+ * Renders the *image* plot type as a natively-tiled, zoomable raster, backed by
+ * the jit-service tile endpoints (`GET /tiles/info` + `GET /tile`, which reuse
+ * the Bio-Formats ROI renderer). Plotly keeps the scientific/data plot types
+ * (scalar heatmap, surface, contour, scatter, line, scatter3d, isosurface) —
+ * hence this backend advertises only `ImageDisplay`.
+ *
+ * Wired: load → descriptor, plot → mount viewer with a custom tile source,
+ * zoom/pan → viewport API. NOT wired yet (follow-ups): region overlays + tools
+ * (a positioned canvas/SVG overlay or Annotorious), pixel readback, and the
+ * per-tile LUT/contrast params. Not registered in DI providers — `PlotlyService`
+ * is still the only active backend; this proves the contract supports a second
+ * implementation against real endpoints.
+ */
+export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
+    constructor(http, tiles, wandTool, brushTool, samTool, samPointTool, cellSegmentTool, cellSegmenter, eraserTool, zoomToBoxTool, store, regionStore, simpleStack, config) {
+        super(regionStore, store);
+        this.http = http;
+        this.tiles = tiles;
+        this.wandTool = wandTool;
+        this.brushTool = brushTool;
+        this.samTool = samTool;
+        this.samPointTool = samPointTool;
+        this.cellSegmentTool = cellSegmentTool;
+        this.cellSegmenter = cellSegmenter;
+        this.eraserTool = eraserTool;
+        this.zoomToBoxTool = zoomToBoxTool;
+        this.simpleStack = simpleStack;
+        /** OSD's strength is displaying a large zoomable image — nothing else here. */
+        this.capabilities = capabilitiesOf([ViewerFeature.ImageDisplay]);
+        this.viewer = null;
+        this.overlay = null;
+        this.scaleBar = null;
+        this.descriptor = null;
+        /** Base64 RawFileInfo + current z-slice, kept so setZIndex can rebuild the
+         *  tile source and swap slices live (stack navigation). */
+        this.infoB64 = '';
+        this.currentZ = 0;
+        /** True while the current image is "simple" (tiled:false — self-contained
+         *  per-slice URLs, no tile server; e.g. a numbered image series assembled
+         *  client-side into a stack). setZIndex swaps the single-image source for
+         *  the new slice's URL instead of updating a tiled z-param. */
+        this.simpleMode = false;
+        /** urls[] for the current simple-mode image, so setZIndex can look up the
+         *  slice being scrubbed to (via {@link SimpleSliceAccessService.urlFor}).
+         *  Unused (and left stale, harmlessly) in tiled mode. */
+        this.simpleUrls = [];
+        /** preview blob URL → full-res upscaled blob URL (see toFullResUrl), so
+         *  re-visiting a simple-mode slice doesn't re-upscale. Revoked on file change. */
+        this.simpleFullResUrls = new Map();
+        /** Skip the full-res upscale above this longest-side dimension — a folder
+         *  stack is per-file previews (well under this); this only guards against an
+         *  accidental enormous canvas allocation. */
+        this.SIMPLE_UPSCALE_MAX_DIM = 8192;
+        this.coordTransform = null;
+        /** Wand sampling matrix read back from the rendered viewport; cached until
+         *  the viewport changes (see readbackViewport). */
+        this.viewportPixels = null;
+        /** The DOM id of the element OSD is mounted in (shared with Plotly); the
+         *  on-canvas tools attach their overlays here. */
+        this.plotDiv = '';
+        /** 256-entry RGB LUT for the active colormap, applied to grayscale tiles via
+         *  the tile-invalidated pixel pipeline (mirrors Plotly's heatmap colorscale).
+         *  Null while options resolve; recoloring is skipped until it's built. */
+        this.colorLut = null;
+        /** Only grayscale images get a colormap (RGB tiles pass through untouched). */
+        this.isGrayscaleImage = false;
+        this.colormapSub = null;
+        /** Latest per-channel display state (window/gamma/visibility) from the store,
+         *  read synchronously by recolorTile. Channel 0 drives grayscale windowing;
+         *  R/G/B (indices 0-2) drive RGB per-channel windowing. */
+        this.channelStates = [];
+        /** True for multichannel fluorescence (channelCount > 1, not RGB): tiles are
+         *  composited client-side from per-channel single-band fetches (see
+         *  recolorMultiChannelTile) rather than recolored in place. */
+        this.isMultiChannel = false;
+        /** Count of real Bio-Formats resolution levels (per-channel tiles exist only
+         *  here). For multichannel images the tile source is built from these alone so
+         *  every displayed tile supports a per-channel fetch. */
+        this.realLevels = 0;
+        /** Inverted background (white = zero): inverts the display value before the
+         *  LUT (grayscale) / per channel (RGB). */
+        this.invertBg = false;
+        /** Bearer token for OSD's own tile fetches (HttpClient calls get it via the
+         *  interceptor; OSD's loader does not, so we pass it as an ajax header). */
+        this.authHeaders = {};
+        /** Whether the overview navigator (minimap) is shown. Read at viewer creation;
+         *  a consumer that doesn't want it (e.g. a small embedded preview) sets it off
+         *  via {@link setNavigatorVisible} before the first render. */
+        this.navigatorVisible = true;
+        /** Image smoothing (bilinear). `false` → nearest-neighbour, so zoomed-in pixels
+         *  render as crisp blocks (pixel inspection). Defaults to `false` so the image
+         *  opens showing raw pixels. Read at viewer creation; toggled via
+         *  {@link setImageSmoothingEnabled}. */
+        this.smoothingEnabled = false;
+        /** Overall deadline for the /tiles/info poll loop. An uncached whole-slide
+         *  image (e.g. .ndpi) is cached server-side first (GCS->PVC), which can take
+         *  several minutes — we poll (short requests; the cache-progress overlay
+         *  shows the wait) until it's ready. Generous because each poll is cheap; on
+         *  expiry the render pipeline gives up and the router falls back to Plotly. */
+        this.tilesInfoTimeoutMs = 600000; // 10 min
+        /** Per-channel fit-view tile budget (tiles at the coarsest real level × channels).
+         *  Above it, a multichannel image renders server-composited instead of per-channel
+         *  — its full-res reads (it has no overview pyramid) would be too many × N channels.
+         *  64 (e.g. a 4x4 single-FOV z-stack × 4ch) stays per-channel; a whole-slide
+         *  (hundreds–thousands) falls back. */
+        this.MAX_MULTICHANNEL_FIT_TILES = 256;
+        /** Pixel display pipeline (window/gamma/invert/colormap + additive tint) —
+         *  shared by tile recoloring and the composite export so they stay identical
+         *  (see DisplayPipeline). Host closures read the service's live fields. */
+        this.display = new DisplayPipeline({
+            isGrayscale: () => this.isGrayscaleImage,
+            colorLut: () => this.colorLut,
+            channelStates: () => this.channelStates,
+            invertBg: () => this.invertBg,
+        });
+        /** Stack-slice cache + background preloader (see SliceCache — refactoring
+         *  plan Step 3). The host accessors are live closures, so the cache always
+         *  reads the service's current viewer/descriptor/z — exactly the fields the
+         *  moved code used to read directly. */
+        this.cache = new SliceCache({
+            viewer: () => this.viewer,
+            hasImage: () => !!(this.viewer && this.descriptor && this.infoB64),
+            sliceCount: () => this.descriptor?.z ?? 1,
+            currentZ: () => this.currentZ,
+            isMultiChannel: () => this.isMultiChannel,
+            channelCount: () => Math.max(1, this.channelStates.length || (this.descriptor?.channels ?? 1)),
+            channelVisible: (c) => this.channelStates[c]?.visible !== false,
+            buildTileSource: (z, channel) => this.buildTileSource(this.descriptor, this.infoB64, z, channel),
+            onCompositeSliceAdded: (z) => this.sampler.computeImageWindow(this.descriptor, this.infoB64, z),
+        });
+        this.stackLoading$ = new BehaviorSubject(false);
+        this.stackLoadingProgress$ = new BehaviorSubject(0);
+        this.autoscaleEvent$ = new Subject();
+        /** Visible image region (full-image pixel coords) emitted when the view
+         *  settles, so the intensity inset can re-sample at the current zoom level. */
+        this.viewportChange$ = new Subject();
+        // Region state (regions, selection, the update event) lives in the shared
+        // RegionStore; the IRegionStore methods below delegate to it.
+        this.intensityProfile$ = new Subject();
+        this.api = config.slideCropServer;
+        this.sampler = new HistogramSampler(this.http, this.api, {
+            realLevels: () => this.realLevels,
+            channelCount: (d) => this.channelStates.length || (d.channels ?? 1),
+            isGrayscale: () => this.isGrayscaleImage,
+            // Nudge the channel-states stream so the pane re-reads getHistogram now,
+            // in case its bounded retry window already lapsed.
+            onChannelHistogramsSampled: () => this.store.setChannelStates(this.store.currentChannelStates()),
+            onGrayWindowSampled: (min, max) => this.seedGrayWindow(min, max),
+        });
+        this.ensureColormapSubscription();
+    }
+    // Image metadata and classification colours live in the shared VisualizerStore.
+    /**
+     * Subscribe to the shared VisualizerStore colormap/reverse so OSD recolors in
+     * lock-step with Plotly. Idempotent and self-healing: this service is a root
+     * singleton, but `unsubscribe()` (called on VisualizerComponent destroy)
+     * tears the subscription down — and the constructor never runs again. So
+     * `plot()` calls this to re-establish it after a component teardown/recreate
+     * (e.g. switching images), otherwise colormap changes would be silently
+     * dropped on every image after the first switch.
+     */
+    ensureColormapSubscription() {
+        if (this.colormapSub)
+            return;
+        // Colormap/reverse live in the shared VisualizerStore — the single source
+        // of truth for both backends. Rebuild the LUT and re-run the pixel pipeline
+        // whenever either changes, so OSD recolors in lock-step with Plotly.
+        // Colormap/reverse + per-channel window/gamma/visibility + invert all live in
+        // the shared VisualizerStore. Rebuild the LUT and re-run the pixel pipeline
+        // whenever any of them changes, so the Channels & Histogram pane updates the
+        // image live and OSD stays in lock-step with Plotly.
+        this.colormapSub = combineLatest([
+            this.store.getColormap(),
+            this.store.getReverseScale(),
+            this.store.getChannelStates(),
+            this.store.getInvert(),
+        ]).subscribe(([cm, rev, channels, invert]) => {
+            this.colorLut = buildColormapLut(cm?.data?.value, !!rev);
+            this.channelStates = channels;
+            this.invertBg = !!invert;
+            // Multichannel: each channel is its own TiledImage — visibility is the
+            // image's opacity (window/gamma/colour are applied by recolorChannelTile
+            // on the invalidate below). Re-applying the current slice's reveal picks up
+            // the new per-channel visibility (cached slices stay hidden).
+            if (this.isMultiChannel) {
+                this.cache.revealChannelSlice(this.currentZ);
+            }
+            // requestInvalidate(true) restores each tile to its original data before
+            // re-running recolorTile, so a change always maps afresh (no compounding).
+            // RGB now recolors too (per-channel window/visibility), so don't gate on
+            // grayscale.
+            this.invalidateDisplay();
+        });
+    }
+    /** Seed the Intensity channel with a measured auto-window while it's still
+     *  at full range (never clobber the user's manual window); if the user
+     *  already windowed, just re-invalidate so painted tiles pick the LUT up. */
+    seedGrayWindow(min, max) {
+        const ch0 = this.store.currentChannelStates()[0];
+        if (ch0 && ch0.min === 0 && ch0.max === 255) {
+            this.store.setChannelState(0, { min, max });
+        }
+        else if (this.viewer && this.colorLut) {
+            try {
+                this.viewer.world.requestInvalidate(true);
+            }
+            catch {
+                /* no-op */
+            }
+            try {
+                this.viewer.navigator?.world?.requestInvalidate(true);
+            }
+            catch {
+                /* no-op */
+            }
+        }
+    }
+    // ── IDataRenderer ────────────────────────────────────────────────────
+    /**
+     * Fetch the tile-source descriptor for the selected file. The `info` param is
+     * the base64 RawFileInfo the rest of the API uses; the GET goes through the
+     * auth interceptor (Bearer). We also grab a token here for OSD's own tile
+     * fetches (its loader bypasses HttpClient).
+     */
+    async load(imageInfo, zIndex) {
+        const filename = imageInfo?.fileName;
+        // A different image was selected — stop the previous stack's background
+        // loading immediately rather than letting it finish behind the new image.
+        if (filename && this.currentFileName && filename !== this.currentFileName) {
+            this.cache.cancelBackgroundLoad();
+            this.revokeSimpleFullResUrls();
+        }
+        this.simpleStack.noteActiveFile(filename);
+        // Simple (in-memory / non-tiled) image: skip the tile server entirely — no
+        // getSelectedInfoB64, no /tiles/info poll. `urls[zIndex]` is a complete image
+        // OSD opens via its single-image source (see plot()).
+        if (this.simpleStack.isSimple(imageInfo)) {
+            return this.loadSimple(imageInfo, zIndex);
+        }
+        const infoB64 = this.tiles.getSelectedInfoB64();
+        if (!infoB64)
+            return { descriptor: null, infoB64: '', z: zIndex || 0, filename };
+        try {
+            this.authHeaders = await this.tiles.getAuthHeaders();
+        }
+        catch {
+            this.authHeaders = {}; // fall back to cookie auth (ajaxWithCredentials)
+        }
+        // Poll /tiles/info: the backend returns 202 while the source file is still
+        // being cached (GCS->PVC) — it kicks the download off in the background, so
+        // each request is short (no long-held connection to trip ingress/proxy or
+        // client timeouts), and 200 with the descriptor once it's ready. The
+        // cache-progress overlay shows progress during the wait. We give up after
+        // tilesInfoTimeoutMs so the render pipeline never hangs (the router then
+        // falls back to Plotly for this image).
+        const url = `${this.api}tiles/info?info=${infoB64}`;
+        const deadline = Date.now() + this.tilesInfoTimeoutMs;
+        for (;;) {
+            if (Date.now() > deadline) {
+                throw new Error('tiles/info not ready before deadline — file still caching');
+            }
+            try {
+                const resp = await firstValueFrom(this.http.get(url, { observe: 'response' }).pipe(timeout(45000)));
+                if (resp.status === 200 && resp.body) {
+                    this.descriptor = resp.body;
+                    return { descriptor: resp.body, infoB64, z: zIndex || 0, filename };
+                }
+                // 202 Accepted (or empty body) → still caching; fall through and re-poll.
+            }
+            catch (err) {
+                // Tolerate transient failures WHILE the file is being prepared: a slow
+                // metadata read on a multi-GB file (IFD walk), a 5xx mid-pipeline, a
+                // proxy hiccup. A single bad poll must NOT drop us to Plotly — a large
+                // image always passes through this busy window, so bailing here is why
+                // it "always ends up on Plotly". Keep polling until ready or deadline.
+                console.warn('[OSD] tiles/info poll retry', err);
+            }
+            await new Promise((r) => setTimeout(r, 1500));
+        }
+    }
+    /** Build the `plot()` payload for a simple (tiled:false) image: a single-level
+     *  descriptor sized from `trueImageSize`, plus the directly-loadable URL —
+     *  resolved and fetched via {@link SimpleSliceAccessService} (shared with
+     *  napari-js; see its docs for why this can't be a raw `fetch()`/`<img>`). */
+    async loadSimple(imageInfo, zIndex) {
+        const z = zIndex || 0;
+        const filename = imageInfo?.fileName;
+        this.authHeaders = {};
+        const [width, height] = imageInfo.trueImageSize ?? [0, 0];
+        const rawUrl = this.simpleStack.urlFor(imageInfo, z);
+        let url;
+        if (rawUrl) {
+            try {
+                const previewUrl = await this.simpleStack.fetchAsBlobUrl(rawUrl);
+                // Upscale the (downscaled) preview to full resolution so OSD's world
+                // matches the full-res ROI coordinate space — see toFullResUrl.
+                url = await this.toFullResUrl(previewUrl, width, height);
+            }
+            catch (err) {
+                console.warn('[OSD] simple-mode slice fetch failed', err);
+            }
+        }
+        // No loadable URL (empty urls[] or the fetch failed): signal "couldn't
+        // load" with a null descriptor — same as the tiled path when there's no
+        // selected-file info — so plot() returns false (its `if (!d)` guard) and
+        // the router can fall back, instead of mounting an <img> with an undefined
+        // src that throws at runtime.
+        if (!url) {
+            console.warn('[OSD] simple-mode slice has no loadable URL; skipping OSD render', rawUrl);
+            return { descriptor: null, infoB64: '', z, filename };
+        }
+        const meta = imageInfo.imageMeta?.[0];
+        const descriptor = {
+            width,
+            height,
+            tileSize: 0, // unused: simple mode never calls buildTileSource
+            z: 1, // single frame
+            channels: meta?.rgbChannels ?? (imageInfo.isGrayscale ? 1 : 3),
+            multichannel: false,
+            realLevels: 1,
+            levels: [{ res: 0, width, height }],
+            mppX: meta?.mppX ?? 0,
+            mppY: meta?.mppY ?? 0,
+        };
+        return {
+            descriptor,
+            infoB64: '',
+            z,
+            filename,
+            simple: true,
+            url,
+        };
+    }
+    /**
+     * OSD's `{type:'image'}` source sizes its coordinate world to the image's
+     * NATURAL pixels. A folder-stack slice is a server `/preview` whose pixel size
+     * needn't match the full-resolution image — it may be downscaled (large
+     * images) OR larger than the dimensions `/metadata` reports. Either way OSD's
+     * world would differ from the full-res ROI coordinate space (QuPath geojson,
+     * in level-0 pixels): a smaller preview renders ROIs oversized, a larger one
+     * renders them undersized/offset. Resample the preview to EXACTLY the
+     * full-resolution dimensions (blurry but positionally exact — scaling up or
+     * down as needed) so OSD's world matches the ROI coordinate space, while still
+     * using OSD's reliable single-image renderer. Cached per preview URL (revoked
+     * on file change); a no-op when the preview is already exactly full-res (small
+     * images, in-memory pipeline blobs), when the dims are unknown, or when
+     * they're implausibly large (guards against an enormous canvas). (jit-ui#93)
+     */
+    async toFullResUrl(previewUrl, width, height) {
+        if (!width || !height || Math.max(width, height) > this.SIMPLE_UPSCALE_MAX_DIM)
+            return previewUrl;
+        const cached = this.simpleFullResUrls.get(previewUrl);
+        if (cached)
+            return cached;
+        let img;
+        try {
+            img = await this.loadImageEl(previewUrl);
+        }
+        catch {
+            return previewUrl; // couldn't decode — let OSD try the URL as-is
+        }
+        // Already the exact full-res world — no resample needed. (A preview that is
+        // larger OR smaller than full-res must still be resized so OSD's world ==
+        // the ROI coordinate space; only an exact match is skippable.)
+        if (img.naturalWidth === width && img.naturalHeight === height)
+            return previewUrl;
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            return previewUrl;
+        ctx.drawImage(img, 0, 0, width, height); // scale preview (up or down) to full-res
+        const blob = await new Promise((resolve) => canvas.toBlob(resolve));
+        if (!blob)
+            return previewUrl;
+        const fullResUrl = URL.createObjectURL(blob);
+        this.simpleFullResUrls.set(previewUrl, fullResUrl);
+        return fullResUrl;
+    }
+    /** Load a URL into an HTMLImageElement (resolves once decoded). Uses
+     *  document.createElement rather than `new Image()` because this file's
+     *  `Image` import is image-js's decoder, not the DOM element. */
+    loadImageEl(url) {
+        return new Promise((resolve, reject) => {
+            const img = document.createElement('img');
+            img.onload = () => resolve(img);
+            img.onerror = (e) => reject(e);
+            img.src = url;
+        });
+    }
+    revokeSimpleFullResUrls() {
+        for (const u of this.simpleFullResUrls.values())
+            URL.revokeObjectURL(u);
+        this.simpleFullResUrls.clear();
+    }
+    /** Mount the viewer with a custom tile source pointing at `GET /tile`. */
+    plot(plotDiv, imageLoaded, imageInfo, _screenHeight, _plotType, inPlace) {
+        const loaded = imageLoaded;
+        const d = loaded?.descriptor;
+        if (!d)
+            return Promise.resolve(false);
+        // Re-establish the colormap subscription if a prior component teardown
+        // (unsubscribe()) tore it down — this service is a root singleton, so the
+        // constructor won't run again to recreate it.
+        this.ensureColormapSubscription();
+        // OSD tiles natively, so the in-place (large) pass is normally a no-op
+        // once mounted — the tile pyramid IS the full resolution regardless of
+        // which ImageInfo tier requested it. Simple mode has no pyramid to fall
+        // back on: it displays literally whatever URL was last opened, so
+        // without this swap the small tier's 128px placeholder would stay on
+        // screen forever (pixelated, never "sharpening" like the tiled path).
+        if (inPlace && this.viewer) {
+            if (loaded.simple && loaded.url) {
+                // Also refresh simpleUrls to THIS phase's (large-tier) urls[] — it was
+                // set from the small tier's 128px urls on the initial mount below,
+                // which never runs again for the in-place pass. Without this,
+                // setZIndex's later slider scrubs would keep reading the small
+                // tier's low-res URLs forever, even though the initial slice was
+                // correctly swapped to full resolution here.
+                this.simpleUrls = imageInfo?.urls ?? this.simpleUrls;
+                this.viewer.open({ type: 'image', url: loaded.url });
+            }
+            return Promise.resolve(true);
+        }
+        this.plotDiv = plotDiv;
+        this.currentFileName = imageInfo?.fileName;
+        this.descriptor = d;
+        this.infoB64 = loaded.infoB64;
+        this.currentZ = loaded.z;
+        this.simpleMode = !!loaded.simple;
+        this.simpleUrls = loaded.simple ? (imageInfo?.urls ?? []) : [];
+        // The descriptor's physical pixel size (server Bio-Formats `/tiles/info`) is
+        // authoritative — push it into the shared meta so the Region Editor reports
+        // areas in µm²/mm², matching the scale bar built from `d.mppX` below.
+        this.store.setPhysicalPixelSize(d.mppX, d.mppY);
+        // Use the SAME grayscale flag the colormap dropdown / Plotly use
+        // (imageInfo.isGrayscale ← rgbChannels === 1). The descriptor's `channels`
+        // (channelCount) diverges from rgbChannels for stacks, which left grayscale
+        // stacks un-recolored even though the colormap selector was shown.
+        this.isGrayscaleImage = !!imageInfo?.isGrayscale;
+        // Simple (non-tiled, in-memory) image: no pyramid, no per-channel tiles, and
+        // no server-side intensity sampling — OSD's single-image source decodes
+        // urls[z] directly. Skip the whole tiled-setup path below.
+        const simple = !!loaded.simple;
+        if (simple) {
+            this.realLevels = 1;
+            this.isMultiChannel = false;
+            this.cache.clearChannelGroups();
+            this.destroyViewer();
+        }
+        else {
+            // Multichannel fluorescence (indexed/LUT-bearing stacks) composite client-side
+            // from per-channel tiles. Trust the server's explicit `multichannel` flag — the
+            // old `channels>1 && grayscale` heuristic also matched RGB photos Bio-Formats
+            // reads as separated planes (channels>1, rgbChannels==1), splitting them into N
+            // per-channel TiledImages that flooded the tile endpoint and hung on load.
+            this.realLevels = d.realLevels ?? d.levels.length;
+            // Tiles to cover the whole image at the coarsest REAL Bio-Formats level (the
+            // smallest level that has real, per-channel-fetchable tiles — synthetic overview
+            // levels are server-composited only). A pyramidal image's coarsest real level is
+            // tiny (few tiles); a flat/no-pyramid image's is the full-res grid (many tiles).
+            const coarse = d.levels[this.realLevels - 1] ?? d.levels[d.levels.length - 1];
+            const coarseW = coarse ? Math.ceil(coarse.width / d.tileSize) : 1;
+            const coarseH = coarse ? Math.ceil(coarse.height / d.tileSize) : 1;
+            const coarseTiles = coarseW * coarseH;
+            this.isMultiChannel = !!d.multichannel;
+            if (this.isMultiChannel) {
+                // Per-channel rendering can only use the REAL levels, so OSD requests the
+                // coarsest real level's whole tile grid × N channels at fit. When that's large
+                // (a whole-slide), it's too many (often slow, pyramid-less) full-res reads —
+                // fall back to the single server-composited source (which keeps the fast
+                // synthetic overviews). A small single-FOV z-stack stays per-channel. Size in
+                // BYTES isn't the signal — tile count is.
+                const fitTiles = coarseTiles * Math.max(1, d.channels ?? 1);
+                if (fitTiles > this.MAX_MULTICHANNEL_FIT_TILES) {
+                    this.isMultiChannel = false;
+                    console.warn('[OSD] multichannel composite too large for per-channel rendering: ' +
+                        `${coarseW}x${coarseH} tiles x ${d.channels} channels = ${fitTiles} at the coarsest ` +
+                        `real level (> ${this.MAX_MULTICHANNEL_FIT_TILES}); rendering server-composited for speed.`);
+                }
+            }
+            this.cache.clearChannelGroups();
+            // Auto-range grayscale tiles to the image's actual intensity span (like the
+            // heatmap), sampling the coarsest tile level so the window matches the raw
+            // tile values. Fire-and-forget: it re-invalidates once the window is known;
+            // tiles paint unwindowed until then. (Multichannel windows are per-channel,
+            // defaulting to full range; the user auto/edits each channel.)
+            if (this.isMultiChannel) {
+                this.sampler.computeMultiChannelHistograms(d, loaded.infoB64, loaded.z);
+            }
+            else {
+                this.sampler.computeImageWindow(d, loaded.infoB64, loaded.z);
+            }
+            this.destroyViewer();
+            // Size the slice cache for this image: LRU cap to hold the whole stack
+            // (capped) and skip background preloading for stacks too large to preload
+            // (would flood full-res reads). Normal stacks keep the flicker-free pre-cache.
+            this.cache.configure(d.z ?? 1, coarseTiles);
+        }
+        // Simple mode: OSD's single-image source decodes the URL (blob:/data:/http)
+        // directly — no pyramid, no server. Tiled mode: the custom server-backed tile
+        // source (multichannel opens on channel 0; the open handler then swaps in this
+        // slice's per-channel group and the background loader pre-fills the rest).
+        const tileSource = simple
+            ? { type: 'image', url: loaded.url }
+            : this.buildTileSource(d, loaded.infoB64, loaded.z, this.isMultiChannel ? 0 : undefined);
+        silenceOsdMultiImageAdvisory();
+        this.viewer = OSD({
+            id: plotDiv,
+            // Simple-mode z-scrub calls viewer.open() again per slice (see
+            // setZIndex) — without this it resets to the home zoom/pan on every
+            // slice change. Tiled mode never re-opens (it toggles pre-added
+            // TiledImages' opacity instead), so this is a no-op there.
+            preserveViewport: true,
+            // Use the 2D canvas drawer, not WebGL: creating/destroying a viewer on
+            // each engine toggle / image load churns WebGL contexts (browsers cap
+            // how many exist at once), which surfaces as "WebGL context was lost"
+            // and blank tiles. The canvas drawer has no such limit.
+            drawer: 'canvas',
+            showNavigationControl: false, // avoids needing the icon-image assets
+            // Overview thumbnail with the current-viewport rectangle, bottom-right.
+            showNavigator: this.navigatorVisible,
+            // Nearest-neighbour when off → crisp pixels on zoom-in (pixel inspection).
+            imageSmoothingEnabled: this.smoothingEnabled,
+            navigatorPosition: 'BOTTOM_RIGHT',
+            navigatorSizeRatio: 0.16,
+            navigatorAutoFade: false,
+            navigatorBackground: 'rgba(0,0,0,0.5)',
+            loadTilesWithAjax: true,
+            ajaxWithCredentials: true, // cookie auth (oauth2-proxy)
+            ajaxHeaders: this.authHeaders, // bearer auth (Auth0), when available
+            crossOriginPolicy: 'Anonymous',
+            // Gentler zoom: the default (1.2) feels fast and big jumps cross several
+            // pyramid levels at once, firing a burst of tile requests.
+            zoomPerScroll: 1.1,
+            // Click-to-zoom toward the clicked point (OpenSeadragon's default demo
+            // behaviour). Only applies when no region tool is active — an active tool
+            // disables OSD mouse-nav so clicks draw/select instead of zooming.
+            gestureSettingsMouse: { clickToZoom: true, scrollToZoom: true },
+            // Zoom limits (jit-ui#94). Default minZoomImageRatio (0.9) stops you from
+            // zooming the image smaller than ~home; drop it so the image can be shrunk
+            // freely (effectively no minimum). Default maxZoomPixelRatio (1.1) caps
+            // zoom-in at ~1 screen px per image px; raise it so you can zoom in to
+            // inspect individual pixels (paired with imageSmoothingEnabled=false for
+            // crisp nearest-neighbour blocks).
+            minZoomImageRatio: 0.01,
+            maxZoomPixelRatio: 20,
+            // Wait for the view to settle before pulling new tiles (less churn).
+            immediateRender: false,
+            animationTime: 0.4,
+            // Release memory aggressively: cap the tile cache so tiles outside the
+            // current view (e.g. the coarser levels left behind after zooming in) are
+            // evicted instead of accumulating. Large whole-slide tiles — doubled when
+            // the colormap pipeline keeps a recolored copy — make an unbounded cache
+            // costly. Tunable; lower = less memory, more re-fetch on pan-back.
+            // Stacks keep many slices resident (the whole stack is background-loaded),
+            // so they get a much larger tile budget — otherwise switching slices evicts
+            // each other's tiles and scrubbing back re-fetches. Scaled to the resident
+            // slice count; single images keep the lean default.
+            maxImageCacheCount: (d.z ?? 1) > 1 ? Math.min(2400, Math.max(600, this.cache.maxSlices() * 40)) : 150,
+        });
+        return new Promise((resolve) => {
+            // Always settle: if OSD never emits open/open-failed (a bad tile source,
+            // a viewer torn down mid-open), the render pipeline must not hang — a hang
+            // leaves imageLoading=true, sticking the spinner and the 500ms
+            // cache-progress poll forever (NS_BINDING_ABORTED storm).
+            let settled = false;
+            const done = (ok) => {
+                if (!settled) {
+                    settled = true;
+                    resolve(ok);
+                }
+            };
+            this.viewer.addOnceHandler('open', () => {
+                // Region overlay reads/writes the shared RegionStore, so regions stay
+                // in sync with Plotly and the Region Editor. Recreate it per open() so
+                // it binds to the freshly-opened viewer's canvas/MouseTracker.
+                this.overlay?.destroy();
+                this.overlay = new OsdRegionOverlay(this.viewer, this.regionStore);
+                this.coordTransform = new OsdCoordinateTransform(this.viewer);
+                this.scaleBar = new OsdScaleBar(this.viewer, d.mppX ?? 0);
+                this.buildToolHosts();
+                // Simple mode is a single, self-contained image — no slice cache to seed.
+                if (simple) {
+                    /* nothing to cache: one frame, no pyramid */
+                }
+                else if (this.isMultiChannel) {
+                    // Drop the single opened (channel-0) image and add this slice's channel
+                    // group to the per-slice cache. The shared background loader / LRU then
+                    // pre-fills the other slices' channel groups so z-scrub is flicker-free.
+                    try {
+                        const it0 = this.viewer.world?.getItemAt?.(0);
+                        if (it0)
+                            this.viewer.world.removeItem(it0);
+                    }
+                    catch { /* nothing to remove */ }
+                    this.cache.addChannelSlice(this.currentZ);
+                }
+                else {
+                    // Seed the slice cache with the just-opened slice (world item 0), so
+                    // scrubbing back to it later is an instant opacity toggle, not a re-open.
+                    const firstItem = this.viewer.world?.getItemAt?.(0);
+                    if (firstItem)
+                        this.cache.seedComposite(this.currentZ, firstItem);
+                }
+                // The wand samples the *rendered viewport*, so its pixel matrix is only
+                // valid for the current view — drop it whenever the viewport changes.
+                this.viewer.addHandler('viewport-change', () => {
+                    this.viewportPixels = null;
+                });
+                // Grayscale tiles get the active colormap via the pixel pipeline. The
+                // handler runs per tile on load (and on requestInvalidate); recoloring
+                // is a no-op for RGB images or before the LUT resolves.
+                // (isGrayscaleImage is set from imageInfo.isGrayscale in plot() above.)
+                this.viewer.addHandler('tile-invalidated', (event) => this.recolorTile(event));
+                // The overview navigator is a separate mini-viewer with its own tiles,
+                // so it doesn't receive the main viewer's tile-invalidated events. Apply
+                // the same recolor pipeline to it so the minimap tracks the main image's
+                // colormap/LUT instead of staying grayscale.
+                const nav = this.viewer.navigator;
+                nav?.addHandler('tile-invalidated', (event) => this.recolorTile(event));
+                if ((this.isGrayscaleImage && this.colorLut) || this.isMultiChannel) {
+                    try {
+                        this.viewer.world.requestInvalidate(true);
+                    }
+                    catch {
+                        /* no-op */
+                    }
+                    try {
+                        nav?.world?.requestInvalidate(true);
+                    }
+                    catch {
+                        /* no-op */
+                    }
+                }
+                // Prefetch adjacent z-slices once the view settles (and on each settle,
+                // so it tracks the current viewport as the user pans/zooms). Simple mode
+                // has a single frame, so there's nothing to prefetch.
+                if (!simple)
+                    this.viewer.addHandler('animation-finish', () => this.cache.schedulePrefetch());
+                // Tell listeners (the intensity inset) the visible image region whenever
+                // the view settles, so they can re-sample at the current zoom resolution.
+                this.viewer.addHandler('animation-finish', () => this.emitViewportChange());
+                // Chrome compositor bug: after an OSD zoom the docked toolbar (a sibling of
+                // #plot in the <visualizer> host) is left laid-out-but-unpainted and
+                // vanishes — confirmed via DevTools (DOM intact, region simply not painted).
+                // CSS (z-index / isolation / contain) and DOM-reparenting don't fix it; a
+                // repaint reliably does. Nudge it each animation frame (so it never visibly
+                // drops) and on settle. The synchronous display toggle re-rasters with no
+                // visible gone-frame and no layout shift.
+                this.viewer.addHandler('animation', () => this.nudgeToolbarRepaint());
+                this.viewer.addHandler('animation-finish', () => this.nudgeToolbarRepaint());
+                if (!simple)
+                    this.cache.schedulePrefetch();
+                // Force fit-to-view as the split/flex layout settles. A tall
+                // non-pyramidal image can otherwise open zoomed-in (image width filling
+                // the viewer), making OSD demand slow full-res res=0 tiles for the
+                // centre instead of the fast coarse overview → white canvas. goHome
+                // fits the whole image so OSD selects the coarse synthetic level. Retry
+                // across a few frames because the container may not have its final size
+                // on the first frame after 'open'.
+                const refit = () => {
+                    try {
+                        this.viewer?.viewport.goHome(true);
+                        // The navigator was sized in the Viewer constructor — BEFORE the
+                        // layout settled — so its element can carry a stale (even
+                        // wrong-aspect) size that floats the visible minimap above the
+                        // corner. Re-size it from the settled container.
+                        this.resizeNavigator();
+                    }
+                    catch {
+                        /* torn down */
+                    }
+                };
+                requestAnimationFrame(refit);
+                setTimeout(refit, 150);
+                setTimeout(refit, 400);
+                // The timed retries above miss the case where the container is STILL
+                // zero-size at 400ms — which happens when the render starts while the
+                // file viewer is mid-switch from the folder view to the diagram (e.g.
+                // "Load as Stack" from a folder, with no image open first). Because
+                // preserveViewport suppresses OSD's own open-time fit, the image would
+                // then be left un-fitted at the top-left ("a tile"). A one-shot
+                // ResizeObserver fits the instant the container first has a real size,
+                // regardless of when the render began (jit-ui#106).
+                this.fitWhenContainerSized(document.getElementById(plotDiv), refit);
+                // Keep the navigator sized to the container as the panel resizes.
+                this.viewer.addHandler('resize', () => this.resizeNavigator());
+                done(true);
+            });
+            this.viewer.addOnceHandler('open-failed', (e) => {
+                console.warn('[OSD] open-failed', e?.message ?? e);
+                done(false);
+            });
+            setTimeout(() => {
+                if (!settled)
+                    console.warn('[OSD] viewer open timed out');
+                done(false);
+            }, 8000);
+            this.viewer.open(tileSource);
+        });
+    }
+    /**
+     * Fit-to-home once `el` first has a non-zero size. If it's already sized we
+     * rely on the timed refits the caller scheduled; otherwise a one-shot
+     * ResizeObserver runs `refit` the moment the container is laid out (then
+     * disconnects), so the initial fit doesn't depend on the render's start time
+     * relative to the diagram container's layout. No-op without a container or
+     * ResizeObserver (the timed refits remain the fallback). One-shot + only
+     * attached on a fresh mount, so slice-scrub re-opens keep the user's zoom.
+     */
+    fitWhenContainerSized(el, refit) {
+        if (!el || typeof ResizeObserver === 'undefined')
+            return;
+        if (el.clientWidth > 0 && el.clientHeight > 0)
+            return; // already sized — timed refits suffice
+        const ro = new ResizeObserver(() => {
+            if (el.clientWidth > 0 && el.clientHeight > 0) {
+                ro.disconnect();
+                refit();
+            }
+        });
+        ro.observe(el);
+        // Safety net: stop observing even if it never gains a size.
+        setTimeout(() => ro.disconnect(), 5000);
+    }
+    /**
+     * Custom tile source built from the descriptor. OSD numbers levels
+     * coarsest-first; the backend numbers resolutions full-res-first, so
+     * `res = (levels-1) - osdLevel`. Overriding getLevelScale/getNumTiles lets us
+     * honour Bio-Formats' actual per-level dimensions (not assume power-of-two).
+     */
+    buildTileSource(d, infoB64, z, channel) {
+        // Multichannel images composite from per-channel tiles, which only exist at
+        // real Bio-Formats resolutions — so drive OSD off the real levels alone and
+        // skip the synthetic (server-composited) overviews. Every displayed tile is
+        // then per-channel-fetchable at any zoom.
+        const levels = this.isMultiChannel ? d.levels.slice(0, this.realLevels) : d.levels;
+        const n = levels.length;
+        const t = d.tileSize;
+        const base = this.api;
+        // OSD level i (0 = coarsest) <-> backend resolution (n-1-i) (res 0 = full).
+        // The backend pyramid is NOT necessarily power-of-two, so we drive OSD off
+        // the backend's real per-level dimensions. We override ONLY getLevelScale:
+        // OSD derives getNumTiles, getTileBounds AND its per-zoom level selection
+        // from getLevelScale, so they all stay consistent — requesting exactly the
+        // tiles each resolution actually has (no out-of-range 400s, no flood).
+        const resForLevel = (level) => n - 1 - level;
+        const ts = new OSD.TileSource({
+            width: d.width,
+            height: d.height,
+            tileSize: t,
+            tileOverlap: 0,
+            minLevel: 0,
+            maxLevel: n - 1,
+        });
+        ts.getLevelScale = (level) => {
+            const lvl = levels[resForLevel(level)];
+            return lvl ? lvl.width / d.width : 1;
+        };
+        // Drive the tile COUNT off each level's own (independently-rounded) dimensions,
+        // not OSD's default `ceil(scale * fullDimension / tileSize)`. Synthetic AND real
+        // Bio-Formats levels aren't exact proportional scales of the full image, so
+        // `scale * fullHeight` can round up to one more row (or column) than the level
+        // actually has — OSD then requests an out-of-range tile that the server 400s
+        // ("Tile (col,row) out of range"). Using the level's real w/h matches the
+        // server's own bounds check exactly.
+        const Point = OSD.Point;
+        ts.getNumTiles = (level) => {
+            const lvl = levels[resForLevel(level)];
+            if (!lvl)
+                return new Point(0, 0);
+            return new Point(Math.ceil(lvl.width / t), Math.ceil(lvl.height / t));
+        };
+        ts.getTileUrl = (level, x, y) => buildTileUrl(base, infoB64, { res: resForLevel(level), col: x, row: y, z, tileSize: t, channel });
+        return ts;
+    }
+    /** Re-apply the display pipeline (window/gamma/colour/invert) after a state change.
+     *  Multichannel invalidates ONLY the visible slice's channel images — invalidating
+     *  the whole world would re-process every hidden/preloaded slice's tiles (hundreds),
+     *  flooding OSD with "[CacheRecord] … InvalidStateError" and wasting work on tiles
+     *  that aren't on screen. The other cached slices are marked stale and re-tinted
+     *  lazily when revealed. Composite/grayscale invalidate the world as before. */
+    invalidateDisplay() {
+        const v = this.viewer;
+        if (!v)
+            return;
+        if (this.isMultiChannel) {
+            this.cache.invalidateChannelDisplay(this.currentZ);
+            return;
+        }
+        try {
+            v.world.requestInvalidate(true);
+        }
+        catch { /* no-op */ }
+        try {
+            v.navigator?.world?.requestInvalidate(true);
+        }
+        catch { /* no-op */ }
+    }
+    destroyViewer() {
+        this.cache.cancelBackgroundLoad();
+        // Tear down any active tool overlays (shared singletons).
+        this.wandTool.setMode(false);
+        this.brushTool.setMode(false);
+        this.samPointTool.setMode(false);
+        this.eraserTool.setMode(false);
+        if (this.overlay) {
+            this.overlay.destroy();
+            this.overlay = null;
+        }
+        if (this.scaleBar) {
+            this.scaleBar.destroy();
+            this.scaleBar = null;
+        }
+        if (this.viewer) {
+            this.viewer.destroy();
+            this.viewer = null;
+        }
+        this.coordTransform = null;
+        this.cache.reset();
+        this.sampler.clear();
+    }
+    /** This backend's region renderer (the SVG overlay), once a plot is mounted. */
+    getRegionOverlay() {
+        return this.overlay;
+    }
+    /** OSD renders only the image type — no isosurface, so no controls. */
+    getIsosurfaceControls() {
+        return null;
+    }
+    /** OSD renders only the image type — no 3D scenes, so no controls. */
+    getSurface3dControls() {
+        return null;
+    }
+    /** OSD renders only the image type — no LINE intensity ROIs, so no controls. */
+    getIntensityControls() {
+        return null;
+    }
+    toOverlayMode(mode) {
+        switch (mode) {
+            case 'drawrect':
+                return 'drawrect';
+            case 'drawclosedpath':
+                return 'drawclosedpath';
+            case 'drawopenpath':
+                return 'drawopenpath';
+            case 'drawpolygon':
+                return 'drawpolygon';
+            case 'addpoint':
+                return 'addpoint';
+            case 'deletepoint':
+                return 'deletepoint';
+            case 'move':
+                return 'move';
+            case 'select':
+                return 'select';
+            default:
+                return 'none';
+        }
+    }
+    reloadAndPlot() {
+        /* host re-drives plot() via the image-info stream */
+    }
+    reset() {
+        this.destroyViewer();
+    }
+    relayout(_trueImageSize) {
+        const vp = this.viewer?.viewport;
+        if (!vp)
+            return;
+        // Keep the user's current view across a container/split resize instead of
+        // snapping home. Viewport bounds are image-relative (image width = 1), so
+        // they're independent of the container's pixel size — capture the visible
+        // region now and re-fit it once the new size has settled. OSD's autoResize
+        // fires asynchronously and the angular-split transition animates the width
+        // over a few hundred ms, so restore on the next frame and again after the
+        // transition completes.
+        const bounds = vp.getBounds(true);
+        const restore = () => {
+            try {
+                this.viewer?.viewport.fitBounds(bounds, true);
+                this.viewer?.viewport.applyConstraints(true);
+            }
+            catch {
+                /* viewer torn down */
+            }
+        };
+        requestAnimationFrame(restore);
+        setTimeout(restore, 350);
+    }
+    resetAxes() {
+        this.viewer?.viewport.goHome();
+    }
+    autoscale() {
+        this.viewer?.viewport.goHome();
+        this.autoscaleEvent$.next('autoscale');
+    }
+    zoomIn() {
+        this.viewer?.viewport.zoomBy(1.3);
+        this.viewer?.viewport.applyConstraints();
+    }
+    zoomOut() {
+        this.viewer?.viewport.zoomBy(1 / 1.3);
+        this.viewer?.viewport.applyConstraints();
+    }
+    setDragMode(mode) {
+        // Rectangle/polygon drawing run on the SVG overlay; wand/eraser/zoom-box
+        // (custom Plotly overlays) are routed to Plotly by the router and aren't
+        // handled here yet.
+        this.overlay?.setMode(this.toOverlayMode(mode));
+    }
+    setShowStack(_showstack) {
+        /* OSD navigates the stack via the z-slider -> setZIndex */
+    }
+    /** Show/hide the overview navigator. Stored for the next viewer creation, and
+     *  applied live when a viewer is already mounted (hides/reveals its element —
+     *  the navigator instance itself only exists when created with showNavigator). */
+    setNavigatorVisible(visible) {
+        this.navigatorVisible = visible;
+        const navEl = this.viewer?.navigator?.element;
+        if (navEl)
+            navEl.style.display = visible ? '' : 'none';
+    }
+    /** Toggle bilinear smoothing vs nearest-neighbour (crisp pixels). Stored for the
+     *  next viewer creation, and applied live (with a redraw) to a mounted viewer. */
+    setImageSmoothingEnabled(enabled) {
+        this.smoothingEnabled = enabled;
+        const drawer = this.viewer?.drawer;
+        if (drawer?.setImageSmoothingEnabled) {
+            drawer.setImageSmoothingEnabled(enabled);
+            this.viewer?.forceRedraw();
+        }
+    }
+    /**
+     * Swap the displayed z-slice live. Slices are kept as separate tiled images in
+     * the world, so switching is just an opacity toggle: a previously-visited slice
+     * shows instantly (its decoded + recolored tiles are still resident), and a
+     * never-seen slice is added once. The region overlay, coordinate transform,
+     * scale bar, colormap pipeline and current zoom/pan all persist — the x/y
+     * geometry is identical across slices.
+     *
+     * Simple mode (tiled:false — a numbered image series assembled client-side,
+     * each slice its own complete image with no shared tile server) has no
+     * pyramid to toggle opacity on, so it re-opens the viewer on the new
+     * slice's URL instead. preserveViewport (viewer option, see plot()) keeps
+     * the current zoom/pan across that reopen.
+     */
+    setZIndex(zIndex) {
+        const z = zIndex || 0;
+        if (z === this.currentZ)
+            return;
+        if (!this.viewer)
+            return;
+        if (this.simpleMode) {
+            const rawUrl = this.simpleUrls[z] ?? this.simpleUrls[0];
+            if (!rawUrl)
+                return;
+            this.currentZ = z;
+            this.viewportPixels = null;
+            // Fetched via SimpleSliceAccessService (auth interceptor applies) then
+            // upscaled to full-res (same as the initial load — see toFullResUrl) so
+            // the world stays full-res across slices and ROIs keep aligning. Guard
+            // against a newer scrub landing first.
+            this.simpleStack.fetchAsBlobUrl(rawUrl)
+                .then((previewUrl) => this.toFullResUrl(previewUrl, this.descriptor?.width ?? 0, this.descriptor?.height ?? 0))
+                .then((url) => {
+                if (this.currentZ !== z || !this.viewer)
+                    return;
+                this.viewer.addOnceHandler('open-failed', (e) => {
+                    console.warn('[OSD] slice re-open failed', e?.message ?? e);
+                });
+                this.viewer.open({ type: 'image', url });
+            })
+                .catch((err) => console.warn('[OSD] slice fetch failed', err));
+            return;
+        }
+        if (!this.descriptor || !this.infoB64)
+            return;
+        this.currentZ = z;
+        this.viewportPixels = null; // wand readback is slice-specific
+        this.cache.showSlice(z);
+        if (this.isMultiChannel) {
+            this.sampler.computeMultiChannelHistograms(this.descriptor, this.infoB64, z);
+        }
+    }
+    setStackLoading(stackLoading) {
+        this.stackLoading$.next(stackLoading);
+    }
+    isStackLoading() {
+        return this.stackLoading$.asObservable();
+    }
+    getStackLoadingProgress() {
+        return this.stackLoadingProgress$.asObservable();
+    }
+    getTrueImageSize() {
+        return this.descriptor ? { width: this.descriptor.width, height: this.descriptor.height } : null;
+    }
+    getCurrentImage() {
+        return Promise.resolve(null);
+    }
+    /**
+     * The currently displayed pixels — the rendered viewport (what the user sees,
+     * including the current zoom and any colormap recolor), as RGBA. Feeds the
+     * processing-pipeline dialog's "use current view". Returns null until tiles
+     * are drawn.
+     */
+    getDisplayedPixelData() {
+        const canvas = this.viewer?.drawer?.canvas;
+        if (!canvas || !canvas.width || !canvas.height)
+            return null;
+        const ctx = canvas.getContext('2d', { willReadFrequently: true });
+        if (!ctx)
+            return null;
+        const { width, height } = canvas;
+        const img = ctx.getImageData(0, 0, width, height);
+        return { width, height, channels: 4, data: img.data };
+    }
+    /**
+     * Image-pixel rectangle the drawer canvas (what {@link getDisplayedPixelData}
+     * reads) currently covers. Unlike {@link emitViewportChange}, this is NOT
+     * clamped to the image bounds: the canvas maps 1:1 to the viewport rectangle,
+     * so leaving it unclamped keeps `canvasPx -> imagePx` an exact affine map
+     * (clamping would skew coordinates near the image edges). Routed through world
+     * item 0 (see {@link viewportRectToImage}) for multi-layer accuracy.
+     */
+    getDisplayedSourceRect() {
+        const vp = this.viewer?.viewport;
+        if (!vp || !this.descriptor)
+            return null;
+        try {
+            const r = viewportRectToImage(this.viewer, vp.getBounds(true));
+            return { x: r.x, y: r.y, width: r.width, height: r.height };
+        }
+        catch {
+            return null;
+        }
+    }
+    downloadImage() {
+        // Snapshot the currently rendered OSD view as a PNG (WYSIWYG) — the parallel
+        // to Plotly's downloadImage. OSD uses the 2D canvas drawer and bakes the
+        // active display settings (window / gamma / colormap / per-channel colours /
+        // invert) into the tiles via the recolor pipeline, so the drawer canvas
+        // already reflects exactly what's on screen at the current zoom/pan. The
+        // full-resolution stitched export lives in exportComposite() (Channels &
+        // Histogram dialog).
+        const canvas = this.viewer?.drawer?.canvas;
+        if (!canvas || !canvas.width || !canvas.height)
+            return;
+        const stem = (this.currentFileName || 'image').replace(/\.[^.]+$/, '');
+        canvas.toBlob((blob) => {
+            if (blob)
+                saveAs(blob, `${stem}.png`);
+        }, 'image/png');
+    }
+    setPlotType(_plotType) {
+        /* OSD only renders the image type */
+    }
+    setSurfaceDragMode(_mode) {
+        /* 3D not supported by OSD */
+    }
+    resetSurfaceCamera() {
+        /* 3D not supported by OSD */
+    }
+    getAutoscaleEvent() {
+        return this.autoscaleEvent$.asObservable();
+    }
+    /** Visible image region (full-image pixel coords), emitted when the view
+     *  settles. The intensity inset re-samples this region at the zoom resolution. */
+    getViewportChange$() {
+        return this.viewportChange$.asObservable();
+    }
+    /** {@link IIntensitySampling} stub — intensity sampling lives in the Plotly
+     *  backend (it owns pixel readback). OSD feeds it only via getViewportChange$;
+     *  the sampling-cache priming itself is a no-op here. */
+    async ensureIntensitySampling(_imageInfo, _zIndex) {
+        /* no-op: Plotly owns intensity sampling (see IIntensitySampling) */
+    }
+    /** {@link IIntensitySampling} stub — see {@link ensureIntensitySampling}. */
+    refreshIntensitySamplingForRoi(_x, _y, _width, _height, _zIndex) {
+        /* no-op: Plotly owns intensity sampling (see IIntensitySampling) */
+    }
+    /** Compute the current viewport's image-pixel rectangle (clamped to the image)
+     *  and broadcast it. */
+    emitViewportChange() {
+        const vp = this.viewer?.viewport;
+        if (!vp || !this.descriptor)
+            return;
+        try {
+            // Route through world item 0 (osd-coords): vp.viewportToImageRectangle is
+            // inaccurate and warns when the world holds multiple images (per-channel
+            // multichannel layers), which fed the intensity inset a wrong ROI.
+            const r = viewportRectToImage(this.viewer, vp.getBounds(true));
+            const iw = this.descriptor.width, ih = this.descriptor.height;
+            const x = Math.max(0, Math.min(iw, r.x));
+            const y = Math.max(0, Math.min(ih, r.y));
+            const width = Math.max(1, Math.min(iw - x, r.width));
+            const height = Math.max(1, Math.min(ih - y, r.height));
+            this.viewportChange$.next({ x, y, width, height });
+        }
+        catch {
+            /* viewport not ready */
+        }
+    }
+    /** OSD targets the image display; the scalar/3D plot types belong to Plotly. */
+    getPlotTypeDescriptors() {
+        return [PLOT_TYPE_DESCRIPTORS[PlotType.HEATMAP]];
+    }
+    getIntensityProfile$() {
+        return this.intensityProfile$.asObservable();
+    }
+    /** OSD only renders the image type; the LINE intensity inset is Plotly-only. */
+    renderIntensityInset(_divId, _profiles) {
+        /* no LINE mode on OSD */
+    }
+    // ── IRegionStore + classification colours ────────────────────────────
+    // Inherited from BaseStoreVisualizer — pure delegations to the shared
+    // RegionStore / VisualizerStore (identical to napari-js). The OSD region
+    // overlay (constructed in plot()) reads/writes that same store, so regions
+    // stay in sync with Plotly and the Region Editor; OSD renders them as an SVG
+    // overlay rather than carrying Plotly shape dicts.
+    // ── IToolController ──────────────────────────────────────────────────
+    // Wand + vertex eraser run over OSD via ICoordinateTransform. They share the
+    // singleton tool services with Plotly, so we re-bind to our hosts on activate.
+    setWandMode(active, options) {
+        if (!active) {
+            this.wandTool.setMode(false);
+            return;
+        }
+        // Take the pointer from OSD so the drag draws instead of panning. (Nav is
+        // re-enabled when the region overlay returns to 'none' on tool switch.)
+        this.viewer?.setMouseNavEnabled(false);
+        // The wand samples the rendered viewport — read back lazily on first use.
+        this.viewportPixels = null;
+        this.wandTool.bindHost(this.wandHost);
+        this.wandTool.setMode(true, (options ?? {}));
+    }
+    setWandOptions(options) {
+        this.wandTool.setOptions(options);
+    }
+    clearActiveWandRegion() {
+        this.wandTool.clearActiveRegion();
+    }
+    setBrushMode(active, options) {
+        if (!active) {
+            this.brushTool.setMode(false);
+            return;
+        }
+        // Take the pointer from OSD so the drag paints instead of panning.
+        this.viewer?.setMouseNavEnabled(false);
+        // The brush works in the rendered-viewport coordinate frame — read it back
+        // lazily on first use, like the wand. It shares the wand's host.
+        this.viewportPixels = null;
+        this.brushTool.bindHost(this.wandHost);
+        this.brushTool.setMode(true, (options ?? {}));
+    }
+    setBrushOptions(options) {
+        this.brushTool.setSize(options?.size ?? 0);
+    }
+    setVertexEraserMode(active) {
+        if (active) {
+            this.viewer?.setMouseNavEnabled(false); // tool takes the pointer
+            this.viewportPixels = null;
+            this.eraserTool.bindHost(this.eraserHost);
+        }
+        this.eraserTool.setMode(active);
+    }
+    setVertexEraserRadius(radius) {
+        this.eraserTool.setRadius(radius);
+    }
+    setZoomToBoxMode(active) {
+        if (active) {
+            this.viewer?.setMouseNavEnabled(false); // the box drag must not pan
+            this.zoomToBoxTool.bindHost(this.zoomBoxHost());
+        }
+        this.zoomToBoxTool.setMode(active);
+        if (!active)
+            this.viewer?.setMouseNavEnabled(true);
+    }
+    /** Box-prompted SAM: segment the drawn rectangles. The SAM tool reuses the
+     *  wand host (viewport readback + coordinate transform + region store). */
+    segmentRectangles() {
+        this.viewportPixels = null; // segment against the current viewport readback
+        this.samTool.bindHost(this.wandHost);
+        return this.samTool.segmentBoxes();
+    }
+    segmentRectanglesCellpose() {
+        if (!this.cellSegmenter)
+            return Promise.resolve(0);
+        this.viewportPixels = null; // crop against the current viewport readback
+        this.cellSegmentTool.bindHost(this.wandHost);
+        return this.cellSegmentTool.segmentBoxes(this.cellSegmenter);
+    }
+    setSamModel(id) {
+        this.samTool.setModel(id);
+        this.samPointTool.setModel(id);
+    }
+    setSamPointMode(active) {
+        if (active) {
+            this.viewer?.setMouseNavEnabled(false); // clicks add points, don't pan
+            this.viewportPixels = null;
+            this.samPointTool.bindHost(this.wandHost);
+        }
+        this.samPointTool.setMode(active);
+    }
+    commitSamPoints() { this.samPointTool.commit(); }
+    clearSamPoints() { this.samPointTool.clear(); }
+    /** Build the wand/eraser host objects bound to this backend. Both tools run
+     *  over OSD via the shared coordinate transform + a viewport pixel readback,
+     *  and read/write regions directly on the shared RegionStore (neutral model). */
+    buildToolHosts() {
+        this.wandHost = {
+            getRegions: () => this.regionStore.getRegions(),
+            setRegions: (regions) => this.regionStore.setRegions(regions),
+            getCachedImageData: () => this.readbackViewport(),
+            getActiveFrameIndex: () => this.currentZ,
+            getOverlayContainer: () => this.getOverlayContainer(),
+            getCoordinateTransform: () => this.coordTransform,
+            getFileName: () => this.currentFileName,
+            getShapeColor: () => this.regionStore.getShapeColor(),
+        };
+        this.eraserHost = {
+            getRegions: () => this.regionStore.getRegions(),
+            setRegions: (regions) => this.regionStore.setRegions(regions),
+            invalidateWandRegion: () => this.wandTool.clearActiveRegion(),
+            getOverlayContainer: () => this.getOverlayContainer(),
+            getCoordinateTransform: () => this.coordTransform,
+            getCachedImageRatio: () => this.readbackViewport()?.ratios[0] ?? 1,
+        };
+    }
+    /** The element the on-canvas tool overlays attach to (OSD is mounted here). */
+    getOverlayContainer() {
+        return this.plotDiv ? document.getElementById(this.plotDiv) : null;
+    }
+    /** Size the navigator from the CURRENT container (navigatorSizeRatio of the
+     *  viewer element) and keep it pinned to the corner. OSD computes the size
+     *  once in the Viewer constructor — before the host flex layout settles —
+     *  and never corrects it, leaving a stale-size element whose visible minimap
+     *  floats above the bottom-right corner. */
+    resizeNavigator() {
+        const v = this.viewer;
+        const nav = v?.navigator;
+        const el = v?.element;
+        if (!nav?.element || !el?.clientWidth || !el?.clientHeight)
+            return;
+        const w = Math.round(el.clientWidth * 0.16);
+        const h = Math.round(el.clientHeight * 0.16);
+        if (nav.element.style.width !== `${w}px` || nav.element.style.height !== `${h}px`) {
+            try {
+                nav.setWidth(w);
+                nav.setHeight(h);
+            }
+            catch { /* navigator torn down */ }
+        }
+        // Normalize OSD's control-corner stack so the minimap sits flush in the
+        // corner, inset 12px to line up with the scale bar:
+        //  - the inline-block wrapper carries line-box struts and can retain stale
+        //    sizing → make it a tight block;
+        //  - anything else OSD left in the corner would stack below the navigator
+        //    and float it up → hide it;
+        //  - inset the corner itself (bottom/right 12px), keeping the element in
+        //    normal flow.
+        const wrapper = nav.element.parentElement;
+        const corner = wrapper?.parentElement;
+        if (wrapper && corner) {
+            wrapper.style.display = 'block';
+            wrapper.style.lineHeight = '0';
+            wrapper.style.fontSize = '0';
+            // The wrapper keeps the navigator's stale pre-settle height as an
+            // explicit size (the nav was 0.16x the UNSETTLED container at creation),
+            // leaving an empty band under the resized minimap — measured live:
+            // navH=87 inside wrapH=167. Force it to hug its content.
+            wrapper.style.height = 'auto';
+            wrapper.style.width = 'auto';
+            for (const child of Array.from(corner.children)) {
+                if (child !== wrapper)
+                    child.style.display = 'none';
+            }
+            for (const child of Array.from(wrapper.children)) {
+                if (child !== nav.element)
+                    child.style.display = 'none';
+            }
+            corner.style.bottom = '12px';
+            corner.style.right = '12px';
+        }
+        Object.assign(nav.element.style, { position: 'relative', top: '', left: '', bottom: '', right: '', margin: '0' });
+        // TODO(debug): remove after verification
+        const ner = nav.element.getBoundingClientRect();
+        const wr = wrapper?.getBoundingClientRect();
+        const cr = corner?.getBoundingClientRect();
+        const per = el.getBoundingClientRect();
+        console.warn(`[viz:nav] navBottom=${Math.round(ner.bottom)} wrapBottom=${Math.round(wr?.bottom ?? -1)} ` +
+            `cornerBottom=${Math.round(cr?.bottom ?? -1)} plotBottom=${Math.round(per.bottom)} ` +
+            `navH=${Math.round(ner.height)} wrapH=${Math.round(wr?.height ?? -1)} cornerH=${Math.round(cr?.height ?? -1)}`);
+    }
+    /** Force the docked toolbar to repaint after an OSD zoom. Chrome leaves it
+     *  laid-out-but-unpainted (the canvas's compositing churn strands the toolbar's
+     *  raster). A synchronous display toggle re-rasters it with no visible gone-frame
+     *  and no layout shift. Located via the DOM since this service doesn't own the
+     *  toolbar; a no-op when there's no toolbar (e.g. embedded without one). */
+    nudgeToolbarRepaint() {
+        const plotEl = this.plotDiv ? document.getElementById(this.plotDiv) : null;
+        const dock = plotEl?.closest('visualization')?.querySelector('.toolbar-dock');
+        if (!dock)
+            return;
+        const prev = dock.style.display;
+        dock.style.display = 'none';
+        void dock.offsetHeight; // reflow so the toggle re-rasters on the next paint
+        dock.style.display = prev;
+    }
+    /** Host for the (shared) zoom-to-box tool: convert overlay pixels to image
+     *  coords via the viewport, and fit the viewport to the chosen rectangle. */
+    zoomBoxHost() {
+        return {
+            getPlotDiv: () => this.plotDiv,
+            pixelToData: (px, py) => elementToImage(this.viewer, px, py),
+            applyZoomToBox: (coords) => this.applyZoomToBox(coords),
+        };
+    }
+    /** Fit the OSD viewport to an image-space rectangle (coords ordered
+     *  [xMin, xMax, yMax, yMin]). */
+    applyZoomToBox(coordinates) {
+        if (!this.viewer || coordinates.length < 4)
+            return;
+        const [a, b, c, d] = coordinates;
+        const x = Math.min(a, b);
+        const w = Math.abs(b - a);
+        const y = Math.min(c, d);
+        const h = Math.abs(c - d);
+        if (w <= 0 || h <= 0)
+            return;
+        const rect = imageRectToViewport(this.viewer, x, y, w, h);
+        this.viewer.viewport.fitBounds(rect, false);
+    }
+    /**
+     * Read back the *currently rendered* OSD canvas as the wand's pixel matrix.
+     * The matrix covers only the visible viewport at screen resolution, so when
+     * the user is zoomed into a sub-region the wand samples that region's detail
+     * (rather than the whole image at preview resolution). `originX/originY` and
+     * `ratios` map image coords <-> readback-pixel coords for the wand's
+     * data/ratio/origin model. Cached until the viewport changes.
+     */
+    readbackViewport() {
+        if (this.viewportPixels)
+            return this.viewportPixels;
+        const viewer = this.viewer;
+        const canvas = viewer?.drawer?.canvas;
+        const vp = viewer?.viewport;
+        if (!canvas || !canvas.width || !canvas.height || !vp)
+            return null;
+        const ctx = canvas.getContext('2d', { willReadFrequently: true });
+        if (!ctx)
+            return null;
+        const w = canvas.width; // device pixels
+        const h = canvas.height;
+        const data = ctx.getImageData(0, 0, w, h).data; // RGBA, row-major
+        // Build the [y][x] = [r,g,b] matrix the wand expects for RGB frames.
+        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;
+        }
+        // Image-coord span the readback covers (CSS px in, image coords out). Route
+        // through world item 0 (osd-coords) so it stays accurate — and quiet — when
+        // the world holds multiple images (per-channel multichannel layers).
+        const elW = canvas.clientWidth || w;
+        const elH = canvas.clientHeight || h;
+        const tl = elementToImage(this.viewer, 0, 0);
+        const br = elementToImage(this.viewer, elW, elH);
+        const ratioX = (br.x - tl.x) / w; // image px per readback px
+        const ratioY = (br.y - tl.y) / h;
+        this.viewportPixels = {
+            frames: [matrix],
+            width: w,
+            height: h,
+            ratios: [ratioX, ratioY],
+            isGrayscale: false, // canvas readback is always RGBA
+            originX: tl.x,
+            originY: tl.y,
+        };
+        return this.viewportPixels;
+    }
+    /**
+     * Recolor a grayscale tile through the active colormap LUT, using OSD's
+     * tile-invalidated pixel pipeline (OSD 5+/6). Maps each pixel's grayscale
+     * value (r==g==b) to the LUT's RGB. No-op for RGB images or until the LUT is
+     * built. Handler is async — OSD awaits it (raiseEventAwaiting).
+     */
+    async recolorTile(event) {
+        if (this.isMultiChannel) {
+            await this.recolorChannelTile(event);
+            return;
+        }
+        const gray = this.isGrayscaleImage;
+        if (gray) {
+            if (!this.colorLut)
+                return;
+        }
+        else if (!this.display.rgbNeedsRecolor()) {
+            return; // RGB at default (all visible, full window, γ=1, no invert) → passthrough
+        }
+        // Read the tile's pixels. Prefer the rendering context, but some tile caches
+        // (ajax PNG blobs) convert to an *empty* context2d — recoloring that would
+        // blank the tile (white canvas). So if the context has no opaque pixels, draw
+        // the tile's own bitmap/image and recolor that instead. We never write back
+        // unless we actually recolored something, so a tile is never blanked.
+        let ctx = null;
+        try {
+            ctx = await event.getData('context2d');
+        }
+        catch {
+            /* try bitmap below */
+        }
+        let img = null;
+        if (ctx && ctx.canvas && ctx.canvas.width && ctx.canvas.height) {
+            try {
+                img = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+            }
+            catch {
+                img = null;
+            }
+        }
+        if (!img || !this.hasOpaque(img.data)) {
+            // Fall back to the tile's decoded image/bitmap.
+            let src = null;
+            try {
+                src = await event.getData('imageBitmap');
+            }
+            catch {
+                /* none */
+            }
+            if (!src || !src.width) {
+                try {
+                    src = await event.getData('image');
+                }
+                catch {
+                    /* none */
+                }
+            }
+            if (!src || !src.width)
+                return; // can't get pixels — leave the tile untouched
+            const c = document.createElement('canvas');
+            c.width = src.width;
+            c.height = src.height;
+            ctx = c.getContext('2d', { willReadFrequently: true });
+            if (!ctx)
+                return;
+            ctx.drawImage(src, 0, 0);
+            img = ctx.getImageData(0, 0, c.width, c.height);
+        }
+        if (!this.display.applyToRgba(img.data) || !ctx)
+            return; // nothing opaque
+        ctx.putImageData(img, 0, 0);
+        // The tile's cache can be evicted between the awaits above and here (slice
+        // change / invalidation), making setData throw a DOMException on a dead
+        // canvas. Swallow it — the tile is gone, so there's nothing to recolor.
+        try {
+            await event.setData(ctx, 'context2d');
+        }
+        catch { /* tile evicted */ }
+    }
+    /**
+     * Tint a single channel's tile in place. Each channel is its own OpenSeadragon
+     * TiledImage (a single-band grayscale tile); OSD composites the N images
+     * additively ('lighter') in its drawer — so this just maps the tile's intensity
+     * through the channel's window/gamma and its pseudo-colour. Synchronous (no
+     * cross-tile fetch) → no race, no seams. Channel is parsed from the tile URL.
+     */
+    async recolorChannelTile(event) {
+        const tile = event?.tile;
+        const url = (tile && (typeof tile.getUrl === 'function' ? tile.getUrl() : tile.url)) || '';
+        const m = /[?&]channel=(\d+)/.exec(url);
+        const ch = m ? parseInt(m[1], 10) : 0;
+        const st = this.channelStates[ch];
+        let ctx = null;
+        try {
+            ctx = await event.getData('context2d');
+        }
+        catch { /* fallback below */ }
+        let img = null;
+        if (ctx && ctx.canvas && ctx.canvas.width && ctx.canvas.height) {
+            try {
+                img = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+            }
+            catch {
+                img = null;
+            }
+        }
+        if (!img || !this.hasOpaque(img.data)) {
+            let src = null;
+            try {
+                src = await event.getData('imageBitmap');
+            }
+            catch { /* none */ }
+            if (!src || !src.width) {
+                try {
+                    src = await event.getData('image');
+                }
+                catch { /* none */ }
+            }
+            if (!src || !src.width)
+                return;
+            const c = document.createElement('canvas');
+            c.width = src.width;
+            c.height = src.height;
+            ctx = c.getContext('2d', { willReadFrequently: true });
+            if (!ctx)
+                return;
+            ctx.drawImage(src, 0, 0);
+            img = ctx.getImageData(0, 0, c.width, c.height);
+        }
+        if (!ctx)
+            return;
+        // Precompute lum(0..255) → tinted RGB once, then map each pixel by lookup —
+        // the channel tile is single-band, so this turns ~262k per-pixel
+        // channelIntensity() (with Math.pow for gamma) calls into 256 — the difference
+        // between a snappy and a sluggish slider on a 4-channel stack.
+        const { r: rL, g: gL, b: bL } = this.display.channelRgbLut(st);
+        const d = img.data;
+        let changed = false;
+        for (let i = 0; i < d.length; i += 4) {
+            if (d[i + 3] === 0)
+                continue;
+            const r = d[i], g = d[i + 1], b = d[i + 2];
+            const lum = r >= g ? (r >= b ? r : b) : g >= b ? g : b; // single-band → max
+            d[i] = rL[lum];
+            d[i + 1] = gL[lum];
+            d[i + 2] = bL[lum];
+            changed = true;
+        }
+        if (!changed)
+            return;
+        ctx.putImageData(img, 0, 0);
+        // See recolorTile: the tile cache can die between the awaits and here.
+        try {
+            await event.setData(ctx, 'context2d');
+        }
+        catch { /* tile evicted */ }
+    }
+    /** Per-channel histogram for the Channels & Histogram pane, from the current
+     *  slice's sampled tiles (grayscale → channel 0; RGB → R/G/B). Null until the
+     *  async sampling resolves or if it was skipped. */
+    getHistogram(channelIndex, _bins) {
+        return this.sampler.get(this.currentZ, channelIndex);
+    }
+    /** Native bit depth of a channel from the tile descriptor (8 when unknown). */
+    channelBitDepth(channelIndex) {
+        return this.descriptor?.channelInfo?.[channelIndex]?.bitDepth ?? 8;
+    }
+    /**
+     * Async histogram for the Channels & Histogram pane. For >8-bit images it
+     * fetches the **native** distribution from the server `/histogram` endpoint
+     * (the 8-bit canvas tiles can't carry 16-bit values) and caches it per
+     * slice+channel; for 8-bit/RGB it returns the existing client-sampled 8-bit
+     * histogram. Read-only — it never touches the tile/display pipeline.
+     */
+    getHistogram$(channelIndex, bins) {
+        if (this.channelBitDepth(channelIndex) <= 8 || !this.infoB64) {
+            return of(this.getHistogram(channelIndex, bins));
+        }
+        return this.sampler.native$(this.infoB64, this.currentZ, channelIndex, bins);
+    }
+    /**
+     * Export the underlying image data as a data-preserving multi-band TIFF at
+     * native bit depth via `GET /export/tiff` (the server reads the raw 16-bit
+     * planes — the client never sees them). Sends only the visible channels; the
+     * existing 8-bit composite PNG export is unaffected.
+     */
+    async exportData() {
+        if (!this.infoB64)
+            return;
+        const visible = this.channelStates.filter((c) => c.visible).map((c) => c.index);
+        const all = this.channelStates.length;
+        // Omit `channels` when every channel is visible (server default = all).
+        const chParam = visible.length && visible.length < all ? `&channels=${visible.join(',')}` : '';
+        const url = `${this.api}export/tiff?info=${this.infoB64}&z=${this.currentZ}${chParam}`;
+        const stem = (this.currentFileName || 'image').replace(/\.[^.]+$/, '');
+        try {
+            const resp = await firstValueFrom(this.http
+                .get(url, { observe: 'response', responseType: 'blob' })
+                .pipe(timeout(600000)));
+            if (resp.status === 202) {
+                console.warn('[OSD] 16-bit export: file still caching — try again shortly.');
+                return;
+            }
+            const blob = resp.body;
+            if (blob)
+                saveAs(blob, `${stem}_16bit.ome.tif`);
+        }
+        catch (err) {
+            console.warn('[OSD] 16-bit TIFF export failed', err);
+        }
+    }
+    /**
+     * Export the current slice as a publication-ready PNG composited with the
+     * active display settings (window / gamma / colormap or per-channel pseudo-
+     * colours / invert). Picks the largest pyramid level under a pixel cap (the
+     * coarser overview for huge whole-slides), fetches that level's tile grid,
+     * stitches it into one canvas, runs the shared display pipeline, and saves it.
+     */
+    async exportComposite() {
+        const desc = this.descriptor;
+        const levels = desc?.levels ?? [];
+        if (!desc || !this.infoB64 || !levels.length)
+            return;
+        const CAP = 32_000_000; // ~32 MP — bounds memory for whole-slide images
+        let res = levels.length - 1; // coarsest fallback
+        for (let i = 0; i < levels.length; i++) {
+            if (levels[i].width * levels[i].height <= CAP) {
+                res = i;
+                break;
+            }
+        }
+        const lw = levels[res].width;
+        const lh = levels[res].height;
+        const t = desc.tileSize;
+        const cols = Math.max(1, Math.ceil(lw / t));
+        const rows = Math.max(1, Math.ceil(lh / t));
+        const canvas = document.createElement('canvas');
+        canvas.width = lw;
+        canvas.height = lh;
+        const ctx = canvas.getContext('2d', { willReadFrequently: true });
+        if (!ctx)
+            return;
+        const z = this.currentZ;
+        const jobs = [];
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
+                const url = buildTileUrl(this.api, this.infoB64, { res, col, row, z, tileSize: t });
+                jobs.push((async () => {
+                    try {
+                        const bmp = await fetchTileBitmap(this.http, url, 30000);
+                        ctx.drawImage(bmp, col * t, row * t);
+                        bmp.close?.();
+                    }
+                    catch (err) {
+                        // Skip a failed tile — the exported composite has a gap there.
+                        console.warn('[viz:export] composite tile fetch failed, skipping', url, err);
+                    }
+                })());
+            }
+        }
+        await Promise.all(jobs);
+        try {
+            const imageData = ctx.getImageData(0, 0, lw, lh);
+            if (this.display.applyToRgba(imageData.data))
+                ctx.putImageData(imageData, 0, 0);
+        }
+        catch (err) {
+            // Keep the un-recolored composite if readback fails — but say why.
+            console.warn('[viz:export] composite recolor readback failed — exporting raw tiles', err);
+        }
+        const stem = (this.currentFileName || 'image').replace(/\.[^.]+$/, '');
+        canvas.toBlob((blob) => {
+            if (blob)
+                saveAs(blob, `${stem}_composite.png`);
+        }, 'image/png');
+    }
+    /** True if any pixel in the RGBA buffer is non-transparent. */
+    hasOpaque(d) {
+        for (let i = 3; i < d.length; i += 4) {
+            if (d[i] !== 0)
+                return true;
+        }
+        return false;
+    }
+    // ── IDisplayOptions ──────────────────────────────────────────────────
+    // Inherited from BaseStoreVisualizer — pure delegations to the shared
+    // VisualizerStore, so OSD and Plotly stay in lock-step. OSD applies the
+    // colormap to grayscale tiles via the LUT reactively (see the constructor's
+    // colormap subscription), not in setColormap.
+    // ── IVisualizer ──────────────────────────────────────────────────────
+    unsubscribe() {
+        this.colormapSub?.unsubscribe();
+        this.colormapSub = null;
+        this.destroyViewer();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: OpenSeadragonVisualizerService, deps: [{ token: i1.HttpClient }, { token: TILE_ACCESS_PORT }, { token: i2.WandToolService }, { token: i3.BrushToolService }, { token: i4.SamToolService }, { token: i5.SamPointToolService }, { token: i6.CellSegmentToolService }, { token: CELL_SEGMENTER, optional: true }, { token: i7.VertexEraserToolService }, { token: i8.ZoomToBoxToolService }, { token: i9.VisualizerStore }, { token: i10.RegionStore }, { token: i11.SimpleSliceAccessService }, { token: VIZ_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: OpenSeadragonVisualizerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: OpenSeadragonVisualizerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TILE_ACCESS_PORT]
+                }] }, { type: i2.WandToolService }, { type: i3.BrushToolService }, { type: i4.SamToolService }, { type: i5.SamPointToolService }, { type: i6.CellSegmentToolService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CELL_SEGMENTER]
+                }] }, { type: i7.VertexEraserToolService }, { type: i8.ZoomToBoxToolService }, { type: i9.VisualizerStore }, { type: i10.RegionStore }, { type: i11.SimpleSliceAccessService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VIZ_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openseadragon-visualizer.service.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/openseadragon-visualizer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, Optional } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { BehaviorSubject, Observable, Subject, Subscription, combineLatest, firstValueFrom, of } from 'rxjs';\nimport { timeout } from 'rxjs/operators';\nimport { Image } from 'image-js';\nimport * as OpenSeadragon from 'openseadragon';\nimport { OSD } from './osd-lib';\n\n\nimport { VisualizerStore } from '../../store/visualizer-store.service';\nimport { RegionStore } from '../../store/region-store.service';\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { TileAccessPort, TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';\nimport { VizConfig, VIZ_CONFIG } from '../../contracts/viz-config';\nimport { PlotType, PLOT_TYPE_DESCRIPTORS, PlotTypeDescriptor } from '../../contracts/plot-type';\nimport { IVisualizer, PixelData, IntensityProfile, IIsosurfaceControls, IIntensityControls, ISurface3dControls } from '../../contracts/visualizer.contract';\nimport { ViewerCapabilities, ViewerFeature, capabilitiesOf } from '../../contracts/capabilities.contract';\nimport { OsdRegionOverlay } from './osd-region-overlay';\nimport { OsdScaleBar } from './osd-scale-bar';\nimport { IRegionOverlay, RegionToolMode } from '../../contracts/region-overlay.contract';\nimport { ICoordinateTransform } from '../../contracts/coordinate-transform.contract';\nimport { OsdCoordinateTransform } from './osd-coordinate-transform';\nimport { elementToImage, imageRectToViewport, viewportRectToImage } from './osd-coords';\nimport { buildTileUrl, fetchTileBitmap } from './tile-client';\nimport { SliceCache } from './slice-cache';\nimport { DisplayPipeline } from './display-pipeline';\nimport { HistogramSampler } from './histogram-sampler';\nimport { BaseStoreVisualizer } from '../base-store-visualizer';\nimport { SimpleSliceAccessService } from '../simple-slice-access.service';\nimport { CachedImageData, WandToolService, WandToolHost } from '../../toolbar/wand/wand-tool.service';\nimport { BrushToolService, BrushOptions } from '../../toolbar/brush/brush-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';\nimport { VertexEraserToolService, VertexEraserToolHost } from '../../toolbar/vertex-eraser/vertex-eraser-tool.service';\nimport { ZoomToBoxToolService, ZoomToBoxToolHost } from '../../toolbar/zoom-to-box/zoom-to-box-tool.service';\nimport { WandOptions } from '../../toolbar/wand/wand.service';\nimport { buildColormapLut, Rgb } from '../../contracts/colormap-lut';\nimport { IChannelState, IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { saveAs } from 'file-saver';\n\n/**\n * Quiet OpenSeadragon's \"[Viewport.*] is not accurate with multi-image\" advisories.\n * A multichannel image is composited from one TiledImage per channel — a legitimate\n * multi-image world — and OSD logs that advisory (at error level) from its own\n * navigator/overview rendering on every animation frame, flooding the console. Our\n * own image<->viewport conversions already route through world item 0 (see\n * osd-coords), so the remaining advisories are OSD-internal and only affect the\n * minimap's box accuracy (cosmetic). This wraps OSD's logger in a Proxy that drops\n * only that one message string and forwards every other log untouched. Idempotent.\n */\nfunction silenceOsdMultiImageAdvisory(): void {\n  const osd: any = OSD as any;\n  if (osd.__multiImageFilterInstalled) return;\n  const base: any = (osd.console && typeof osd.console.error === 'function')\n    ? osd.console\n    : (typeof console !== 'undefined' ? console : null);\n  if (!base) return;\n  const isAdvisory = (a: unknown) =>\n    typeof a === 'string' && a.indexOf('not accurate with multi-image') !== -1;\n  osd.console = new Proxy(base, {\n    get(target: any, prop: string) {\n      const orig = target[prop];\n      if ((prop === 'error' || prop === 'warn') && typeof orig === 'function') {\n        return (...args: any[]) => { if (isAdvisory(args[0])) return; orig.apply(target, args); };\n      }\n      return typeof orig === 'function' ? orig.bind(target) : orig;\n    },\n  });\n  osd.__multiImageFilterInstalled = true;\n}\n\n/** One pyramid level from `GET /tiles/info`. */\ninterface TileLevel { res: number; width: number; height: number; }\n\n/** Tile-source descriptor returned by `GET /tiles/info`. */\ninterface TileDescriptor {\n  width: number;\n  height: number;\n  tileSize: number;\n  z: number;\n  channels: number;\n  /** True only for genuine multi-channel composites (indexed/LUT-bearing\n   *  fluorescence stacks) the client should split into per-channel layers. The\n   *  server sets it; an RGB photo read as separated planes has channels>1 but\n   *  multichannel=false, so it stays a single composite tile source. */\n  multichannel?: boolean;\n  /** Real Bio-Formats resolution levels at the front of `levels`; the remaining\n   *  levels are synthetic composited overviews (no per-channel tiles). */\n  realLevels?: number;\n  /** Per-channel metadata (name/color/bitDepth/min-maxAllowed) for native 16-bit\n   *  windowing + histogram; null for plain 8-bit/RGB sources. */\n  channelInfo?: Array<{\n    name?: string; color?: string; bitDepth?: number; minAllowed?: number; maxAllowed?: number;\n  }> | null;\n  levels: TileLevel[];\n  /** Physical pixel size in µm (0 when the format doesn't report it). */\n  mppX?: number;\n  mppY?: number;\n}\n\n/** What `load()` hands to `plot()`. */\ninterface OsdLoaded {\n  descriptor: TileDescriptor | null;\n  infoB64: string;\n  z: number;\n  /** Mirrors the loaded image's filename — the diagram's render pipeline\n   *  guards on `loaded.filename === phaseInfo.fileName` before calling plot(). */\n  filename: string | undefined;\n  /** Simple (non-tiled) image: `plot()` opens {@link url} directly via OSD's\n   *  single-image source — no tile pyramid, no server. Set when the image\n   *  carries `tiled === false` (see {@link IImageInfo.tiled}). */\n  simple?: boolean;\n  /** The directly-loadable image URL (`blob:`/`data:`/`http`) for simple mode. */\n  url?: string;\n}\n\n/**\n * OpenSeadragon visualization backend.\n *\n * Renders the *image* plot type as a natively-tiled, zoomable raster, backed by\n * the jit-service tile endpoints (`GET /tiles/info` + `GET /tile`, which reuse\n * the Bio-Formats ROI renderer). Plotly keeps the scientific/data plot types\n * (scalar heatmap, surface, contour, scatter, line, scatter3d, isosurface) —\n * hence this backend advertises only `ImageDisplay`.\n *\n * Wired: load → descriptor, plot → mount viewer with a custom tile source,\n * zoom/pan → viewport API. NOT wired yet (follow-ups): region overlays + tools\n * (a positioned canvas/SVG overlay or Annotorious), pixel readback, and the\n * per-tile LUT/contrast params. Not registered in DI providers — `PlotlyService`\n * is still the only active backend; this proves the contract supports a second\n * implementation against real endpoints.\n */\n@Injectable({ providedIn: 'root' })\nexport class OpenSeadragonVisualizerService extends BaseStoreVisualizer implements IVisualizer {\n  /** OSD's strength is displaying a large zoomable image — nothing else here. */\n  readonly capabilities: ViewerCapabilities = capabilitiesOf([ViewerFeature.ImageDisplay]);\n\n  private readonly api: string;\n  private viewer: OpenSeadragon.Viewer | null = null;\n  private overlay: IRegionOverlay | null = null;\n  private scaleBar: OsdScaleBar | null = null;\n  private descriptor: TileDescriptor | null = null;\n  /** Base64 RawFileInfo + current z-slice, kept so setZIndex can rebuild the\n   *  tile source and swap slices live (stack navigation). */\n  private infoB64 = '';\n  private currentZ = 0;\n  /** True while the current image is \"simple\" (tiled:false — self-contained\n   *  per-slice URLs, no tile server; e.g. a numbered image series assembled\n   *  client-side into a stack). setZIndex swaps the single-image source for\n   *  the new slice's URL instead of updating a tiled z-param. */\n  private simpleMode = false;\n  /** urls[] for the current simple-mode image, so setZIndex can look up the\n   *  slice being scrubbed to (via {@link SimpleSliceAccessService.urlFor}).\n   *  Unused (and left stale, harmlessly) in tiled mode. */\n  private simpleUrls: string[] = [];\n  /** preview blob URL → full-res upscaled blob URL (see toFullResUrl), so\n   *  re-visiting a simple-mode slice doesn't re-upscale. Revoked on file change. */\n  private readonly simpleFullResUrls = new Map<string, string>();\n  /** Skip the full-res upscale above this longest-side dimension — a folder\n   *  stack is per-file previews (well under this); this only guards against an\n   *  accidental enormous canvas allocation. */\n  private readonly SIMPLE_UPSCALE_MAX_DIM = 8192;\n  private coordTransform: ICoordinateTransform | null = null;\n  private wandHost!: WandToolHost;\n  private eraserHost!: VertexEraserToolHost;\n  /** Wand sampling matrix read back from the rendered viewport; cached until\n   *  the viewport changes (see readbackViewport). */\n  private viewportPixels: CachedImageData | null = null;\n  /** The DOM id of the element OSD is mounted in (shared with Plotly); the\n   *  on-canvas tools attach their overlays here. */\n  private plotDiv = '';\n  /** Current file name, tagged onto wand-created shapes. */\n  private currentFileName: string | undefined;\n  /** 256-entry RGB LUT for the active colormap, applied to grayscale tiles via\n   *  the tile-invalidated pixel pipeline (mirrors Plotly's heatmap colorscale).\n   *  Null while options resolve; recoloring is skipped until it's built. */\n  private colorLut: Rgb[] | null = null;\n  /** Only grayscale images get a colormap (RGB tiles pass through untouched). */\n  private isGrayscaleImage = false;\n  private colormapSub: Subscription | null = null;\n  /** Latest per-channel display state (window/gamma/visibility) from the store,\n   *  read synchronously by recolorTile. Channel 0 drives grayscale windowing;\n   *  R/G/B (indices 0-2) drive RGB per-channel windowing. */\n  private channelStates: IChannelState[] = [];\n  /** True for multichannel fluorescence (channelCount > 1, not RGB): tiles are\n   *  composited client-side from per-channel single-band fetches (see\n   *  recolorMultiChannelTile) rather than recolored in place. */\n  private isMultiChannel = false;\n  /** Count of real Bio-Formats resolution levels (per-channel tiles exist only\n   *  here). For multichannel images the tile source is built from these alone so\n   *  every displayed tile supports a per-channel fetch. */\n  private realLevels = 0;\n  /** Inverted background (white = zero): inverts the display value before the\n   *  LUT (grayscale) / per channel (RGB). */\n  private invertBg = false;\n  /** Bearer token for OSD's own tile fetches (HttpClient calls get it via the\n   *  interceptor; OSD's loader does not, so we pass it as an ajax header). */\n  private authHeaders: Record<string, string> = {};\n  /** Whether the overview navigator (minimap) is shown. Read at viewer creation;\n   *  a consumer that doesn't want it (e.g. a small embedded preview) sets it off\n   *  via {@link setNavigatorVisible} before the first render. */\n  private navigatorVisible = true;\n  /** Image smoothing (bilinear). `false` → nearest-neighbour, so zoomed-in pixels\n   *  render as crisp blocks (pixel inspection). Defaults to `false` so the image\n   *  opens showing raw pixels. Read at viewer creation; toggled via\n   *  {@link setImageSmoothingEnabled}. */\n  private smoothingEnabled = false;\n\n  /** Overall deadline for the /tiles/info poll loop. An uncached whole-slide\n   *  image (e.g. .ndpi) is cached server-side first (GCS->PVC), which can take\n   *  several minutes — we poll (short requests; the cache-progress overlay\n   *  shows the wait) until it's ready. Generous because each poll is cheap; on\n   *  expiry the render pipeline gives up and the router falls back to Plotly. */\n  private readonly tilesInfoTimeoutMs = 600000; // 10 min\n\n  /** Per-channel fit-view tile budget (tiles at the coarsest real level × channels).\n   *  Above it, a multichannel image renders server-composited instead of per-channel\n   *  — its full-res reads (it has no overview pyramid) would be too many × N channels.\n   *  64 (e.g. a 4x4 single-FOV z-stack × 4ch) stays per-channel; a whole-slide\n   *  (hundreds–thousands) falls back. */\n  private readonly MAX_MULTICHANNEL_FIT_TILES = 256;\n\n  /** Pixel display pipeline (window/gamma/invert/colormap + additive tint) —\n   *  shared by tile recoloring and the composite export so they stay identical\n   *  (see DisplayPipeline). Host closures read the service's live fields. */\n  private readonly display = new DisplayPipeline({\n    isGrayscale: () => this.isGrayscaleImage,\n    colorLut: () => this.colorLut,\n    channelStates: () => this.channelStates,\n    invertBg: () => this.invertBg,\n  });\n\n  /** Histogram + auto-window sampling (see HistogramSampler). Constructed in\n   *  the ctor body because it captures the resolved API base URL. */\n  private sampler!: HistogramSampler;\n\n  /** Stack-slice cache + background preloader (see SliceCache — refactoring\n   *  plan Step 3). The host accessors are live closures, so the cache always\n   *  reads the service's current viewer/descriptor/z — exactly the fields the\n   *  moved code used to read directly. */\n  private readonly cache = new SliceCache({\n    viewer: () => this.viewer,\n    hasImage: () => !!(this.viewer && this.descriptor && this.infoB64),\n    sliceCount: () => this.descriptor?.z ?? 1,\n    currentZ: () => this.currentZ,\n    isMultiChannel: () => this.isMultiChannel,\n    channelCount: () => Math.max(1, this.channelStates.length || (this.descriptor?.channels ?? 1)),\n    channelVisible: (c: number) => this.channelStates[c]?.visible !== false,\n    buildTileSource: (z: number, channel?: number) =>\n      this.buildTileSource(this.descriptor!, this.infoB64, z, channel),\n    onCompositeSliceAdded: (z: number) => this.sampler.computeImageWindow(this.descriptor!, this.infoB64, z),\n  });\n\n  constructor(\n    private http: HttpClient,\n    @Inject(TILE_ACCESS_PORT) private tiles: TileAccessPort,\n    private wandTool: WandToolService,\n    private brushTool: BrushToolService,\n    private samTool: SamToolService,\n    private samPointTool: SamPointToolService,\n    private cellSegmentTool: CellSegmentToolService,\n    @Optional() @Inject(CELL_SEGMENTER) private cellSegmenter: ICellSegmenter | null,\n    private eraserTool: VertexEraserToolService,\n    private zoomToBoxTool: ZoomToBoxToolService,\n    store: VisualizerStore,\n    regionStore: RegionStore,\n    private simpleStack: SimpleSliceAccessService,\n    @Inject(VIZ_CONFIG) config: VizConfig,\n  ) {\n    super(regionStore, store);\n    this.api = config.slideCropServer;\n    this.sampler = new HistogramSampler(this.http, this.api, {\n      realLevels: () => this.realLevels,\n      channelCount: (d) => this.channelStates.length || (d.channels ?? 1),\n      isGrayscale: () => this.isGrayscaleImage,\n      // Nudge the channel-states stream so the pane re-reads getHistogram now,\n      // in case its bounded retry window already lapsed.\n      onChannelHistogramsSampled: () => this.store.setChannelStates(this.store.currentChannelStates()),\n      onGrayWindowSampled: (min, max) => this.seedGrayWindow(min, max),\n    });\n    this.ensureColormapSubscription();\n  }\n\n  private readonly stackLoading$ = new BehaviorSubject<boolean>(false);\n  private readonly stackLoadingProgress$ = new BehaviorSubject<number>(0);\n  private readonly autoscaleEvent$ = new Subject<any>();\n  /** Visible image region (full-image pixel coords) emitted when the view\n   *  settles, so the intensity inset can re-sample at the current zoom level. */\n  private readonly viewportChange$ = new Subject<{ x: number; y: number; width: number; height: number }>();\n  // Region state (regions, selection, the update event) lives in the shared\n  // RegionStore; the IRegionStore methods below delegate to it.\n  private readonly intensityProfile$ = new Subject<IntensityProfile[]>();\n  // Image metadata and classification colours live in the shared VisualizerStore.\n\n  /**\n   * Subscribe to the shared VisualizerStore colormap/reverse so OSD recolors in\n   * lock-step with Plotly. Idempotent and self-healing: this service is a root\n   * singleton, but `unsubscribe()` (called on VisualizerComponent destroy)\n   * tears the subscription down — and the constructor never runs again. So\n   * `plot()` calls this to re-establish it after a component teardown/recreate\n   * (e.g. switching images), otherwise colormap changes would be silently\n   * dropped on every image after the first switch.\n   */\n  private ensureColormapSubscription(): void {\n    if (this.colormapSub) return;\n    // Colormap/reverse live in the shared VisualizerStore — the single source\n    // of truth for both backends. Rebuild the LUT and re-run the pixel pipeline\n    // whenever either changes, so OSD recolors in lock-step with Plotly.\n    // Colormap/reverse + per-channel window/gamma/visibility + invert all live in\n    // the shared VisualizerStore. Rebuild the LUT and re-run the pixel pipeline\n    // whenever any of them changes, so the Channels & Histogram pane updates the\n    // image live and OSD stays in lock-step with Plotly.\n    this.colormapSub = combineLatest([\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getChannelStates(),\n      this.store.getInvert(),\n    ]).subscribe(([cm, rev, channels, invert]) => {\n      this.colorLut = buildColormapLut(cm?.data?.value, !!rev);\n      this.channelStates = channels;\n      this.invertBg = !!invert;\n      // Multichannel: each channel is its own TiledImage — visibility is the\n      // image's opacity (window/gamma/colour are applied by recolorChannelTile\n      // on the invalidate below). Re-applying the current slice's reveal picks up\n      // the new per-channel visibility (cached slices stay hidden).\n      if (this.isMultiChannel) {\n        this.cache.revealChannelSlice(this.currentZ);\n      }\n      // requestInvalidate(true) restores each tile to its original data before\n      // re-running recolorTile, so a change always maps afresh (no compounding).\n      // RGB now recolors too (per-channel window/visibility), so don't gate on\n      // grayscale.\n      this.invalidateDisplay();\n    });\n  }\n\n  /** Seed the Intensity channel with a measured auto-window while it's still\n   *  at full range (never clobber the user's manual window); if the user\n   *  already windowed, just re-invalidate so painted tiles pick the LUT up. */\n  private seedGrayWindow(min: number, max: number): void {\n    const ch0 = this.store.currentChannelStates()[0];\n    if (ch0 && ch0.min === 0 && ch0.max === 255) {\n      this.store.setChannelState(0, { min, max });\n    } else if (this.viewer && this.colorLut) {\n      try {\n        (this.viewer as any).world.requestInvalidate(true);\n      } catch {\n        /* no-op */\n      }\n      try {\n        (this.viewer as any).navigator?.world?.requestInvalidate(true);\n      } catch {\n        /* no-op */\n      }\n    }\n  }\n\n  // ── IDataRenderer ────────────────────────────────────────────────────\n\n  /**\n   * Fetch the tile-source descriptor for the selected file. The `info` param is\n   * the base64 RawFileInfo the rest of the API uses; the GET goes through the\n   * auth interceptor (Bearer). We also grab a token here for OSD's own tile\n   * fetches (its loader bypasses HttpClient).\n   */\n  async load(imageInfo: IImageInfo, zIndex: number): Promise<OsdLoaded> {\n    const filename = imageInfo?.fileName;\n    // A different image was selected — stop the previous stack's background\n    // loading immediately rather than letting it finish behind the new image.\n    if (filename && this.currentFileName && filename !== this.currentFileName) {\n      this.cache.cancelBackgroundLoad();\n      this.revokeSimpleFullResUrls();\n    }\n    this.simpleStack.noteActiveFile(filename);\n    // Simple (in-memory / non-tiled) image: skip the tile server entirely — no\n    // getSelectedInfoB64, no /tiles/info poll. `urls[zIndex]` is a complete image\n    // OSD opens via its single-image source (see plot()).\n    if (this.simpleStack.isSimple(imageInfo)) {\n      return this.loadSimple(imageInfo, zIndex);\n    }\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) return { descriptor: null, infoB64: '', z: zIndex || 0, filename };\n\n    try {\n      this.authHeaders = await this.tiles.getAuthHeaders();\n    } catch {\n      this.authHeaders = {}; // fall back to cookie auth (ajaxWithCredentials)\n    }\n    // Poll /tiles/info: the backend returns 202 while the source file is still\n    // being cached (GCS->PVC) — it kicks the download off in the background, so\n    // each request is short (no long-held connection to trip ingress/proxy or\n    // client timeouts), and 200 with the descriptor once it's ready. The\n    // cache-progress overlay shows progress during the wait. We give up after\n    // tilesInfoTimeoutMs so the render pipeline never hangs (the router then\n    // falls back to Plotly for this image).\n    const url = `${this.api}tiles/info?info=${infoB64}`;\n    const deadline = Date.now() + this.tilesInfoTimeoutMs;\n    for (;;) {\n      if (Date.now() > deadline) {\n        throw new Error('tiles/info not ready before deadline — file still caching');\n      }\n      try {\n        const resp = await firstValueFrom(\n          this.http.get<TileDescriptor>(url, { observe: 'response' }).pipe(timeout(45000)),\n        );\n        if (resp.status === 200 && resp.body) {\n          this.descriptor = resp.body;\n          return { descriptor: resp.body, infoB64, z: zIndex || 0, filename };\n        }\n        // 202 Accepted (or empty body) → still caching; fall through and re-poll.\n      } catch (err) {\n        // Tolerate transient failures WHILE the file is being prepared: a slow\n        // metadata read on a multi-GB file (IFD walk), a 5xx mid-pipeline, a\n        // proxy hiccup. A single bad poll must NOT drop us to Plotly — a large\n        // image always passes through this busy window, so bailing here is why\n        // it \"always ends up on Plotly\". Keep polling until ready or deadline.\n        console.warn('[OSD] tiles/info poll retry', err);\n      }\n      await new Promise((r) => setTimeout(r, 1500));\n    }\n  }\n\n  /** Build the `plot()` payload for a simple (tiled:false) image: a single-level\n   *  descriptor sized from `trueImageSize`, plus the directly-loadable URL —\n   *  resolved and fetched via {@link SimpleSliceAccessService} (shared with\n   *  napari-js; see its docs for why this can't be a raw `fetch()`/`<img>`). */\n  private async loadSimple(imageInfo: IImageInfo, zIndex: number): Promise<OsdLoaded> {\n    const z = zIndex || 0;\n    const filename = imageInfo?.fileName;\n    this.authHeaders = {};\n    const [width, height] = imageInfo.trueImageSize ?? [0, 0];\n    const rawUrl = this.simpleStack.urlFor(imageInfo, z);\n    let url: string | undefined;\n    if (rawUrl) {\n      try {\n        const previewUrl = await this.simpleStack.fetchAsBlobUrl(rawUrl);\n        // Upscale the (downscaled) preview to full resolution so OSD's world\n        // matches the full-res ROI coordinate space — see toFullResUrl.\n        url = await this.toFullResUrl(previewUrl, width, height);\n      } catch (err) {\n        console.warn('[OSD] simple-mode slice fetch failed', err);\n      }\n    }\n    // No loadable URL (empty urls[] or the fetch failed): signal \"couldn't\n    // load\" with a null descriptor — same as the tiled path when there's no\n    // selected-file info — so plot() returns false (its `if (!d)` guard) and\n    // the router can fall back, instead of mounting an <img> with an undefined\n    // src that throws at runtime.\n    if (!url) {\n      console.warn('[OSD] simple-mode slice has no loadable URL; skipping OSD render', rawUrl);\n      return { descriptor: null, infoB64: '', z, filename };\n    }\n    const meta = imageInfo.imageMeta?.[0];\n    const descriptor: TileDescriptor = {\n      width,\n      height,\n      tileSize: 0,            // unused: simple mode never calls buildTileSource\n      z: 1,                   // single frame\n      channels: meta?.rgbChannels ?? (imageInfo.isGrayscale ? 1 : 3),\n      multichannel: false,\n      realLevels: 1,\n      levels: [{ res: 0, width, height }],\n      mppX: meta?.mppX ?? 0,\n      mppY: meta?.mppY ?? 0,\n    };\n    return {\n      descriptor,\n      infoB64: '',\n      z,\n      filename,\n      simple: true,\n      url,\n    };\n  }\n\n  /**\n   * OSD's `{type:'image'}` source sizes its coordinate world to the image's\n   * NATURAL pixels. A folder-stack slice is a server `/preview` whose pixel size\n   * needn't match the full-resolution image — it may be downscaled (large\n   * images) OR larger than the dimensions `/metadata` reports. Either way OSD's\n   * world would differ from the full-res ROI coordinate space (QuPath geojson,\n   * in level-0 pixels): a smaller preview renders ROIs oversized, a larger one\n   * renders them undersized/offset. Resample the preview to EXACTLY the\n   * full-resolution dimensions (blurry but positionally exact — scaling up or\n   * down as needed) so OSD's world matches the ROI coordinate space, while still\n   * using OSD's reliable single-image renderer. Cached per preview URL (revoked\n   * on file change); a no-op when the preview is already exactly full-res (small\n   * images, in-memory pipeline blobs), when the dims are unknown, or when\n   * they're implausibly large (guards against an enormous canvas). (jit-ui#93)\n   */\n  private async toFullResUrl(previewUrl: string, width: number, height: number): Promise<string> {\n    if (!width || !height || Math.max(width, height) > this.SIMPLE_UPSCALE_MAX_DIM) return previewUrl;\n    const cached = this.simpleFullResUrls.get(previewUrl);\n    if (cached) return cached;\n    let img: HTMLImageElement;\n    try {\n      img = await this.loadImageEl(previewUrl);\n    } catch {\n      return previewUrl; // couldn't decode — let OSD try the URL as-is\n    }\n    // Already the exact full-res world — no resample needed. (A preview that is\n    // larger OR smaller than full-res must still be resized so OSD's world ==\n    // the ROI coordinate space; only an exact match is skippable.)\n    if (img.naturalWidth === width && img.naturalHeight === height) return previewUrl;\n    const canvas = document.createElement('canvas');\n    canvas.width = width;\n    canvas.height = height;\n    const ctx = canvas.getContext('2d');\n    if (!ctx) return previewUrl;\n    ctx.drawImage(img, 0, 0, width, height); // scale preview (up or down) to full-res\n    const blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve));\n    if (!blob) return previewUrl;\n    const fullResUrl = URL.createObjectURL(blob);\n    this.simpleFullResUrls.set(previewUrl, fullResUrl);\n    return fullResUrl;\n  }\n\n  /** Load a URL into an HTMLImageElement (resolves once decoded). Uses\n   *  document.createElement rather than `new Image()` because this file's\n   *  `Image` import is image-js's decoder, not the DOM element. */\n  private loadImageEl(url: string): Promise<HTMLImageElement> {\n    return new Promise((resolve, reject) => {\n      const img = document.createElement('img');\n      img.onload = () => resolve(img);\n      img.onerror = (e) => reject(e);\n      img.src = url;\n    });\n  }\n\n  private revokeSimpleFullResUrls(): void {\n    for (const u of this.simpleFullResUrls.values()) URL.revokeObjectURL(u);\n    this.simpleFullResUrls.clear();\n  }\n\n  /** Mount the viewer with a custom tile source pointing at `GET /tile`. */\n  plot(\n    plotDiv: string,\n    imageLoaded: any,\n    imageInfo: IImageInfo,\n    _screenHeight: number,\n    _plotType: PlotType,\n    inPlace?: boolean,\n  ): Promise<boolean> {\n    const loaded = imageLoaded as OsdLoaded;\n    const d = loaded?.descriptor;\n    if (!d) return Promise.resolve(false);\n    // Re-establish the colormap subscription if a prior component teardown\n    // (unsubscribe()) tore it down — this service is a root singleton, so the\n    // constructor won't run again to recreate it.\n    this.ensureColormapSubscription();\n    // OSD tiles natively, so the in-place (large) pass is normally a no-op\n    // once mounted — the tile pyramid IS the full resolution regardless of\n    // which ImageInfo tier requested it. Simple mode has no pyramid to fall\n    // back on: it displays literally whatever URL was last opened, so\n    // without this swap the small tier's 128px placeholder would stay on\n    // screen forever (pixelated, never \"sharpening\" like the tiled path).\n    if (inPlace && this.viewer) {\n      if (loaded.simple && loaded.url) {\n        // Also refresh simpleUrls to THIS phase's (large-tier) urls[] — it was\n        // set from the small tier's 128px urls on the initial mount below,\n        // which never runs again for the in-place pass. Without this,\n        // setZIndex's later slider scrubs would keep reading the small\n        // tier's low-res URLs forever, even though the initial slice was\n        // correctly swapped to full resolution here.\n        this.simpleUrls = imageInfo?.urls ?? this.simpleUrls;\n        this.viewer.open({ type: 'image', url: loaded.url } as any);\n      }\n      return Promise.resolve(true);\n    }\n    this.plotDiv = plotDiv;\n    this.currentFileName = imageInfo?.fileName;\n    this.descriptor = d;\n    this.infoB64 = loaded.infoB64;\n    this.currentZ = loaded.z;\n    this.simpleMode = !!loaded.simple;\n    this.simpleUrls = loaded.simple ? (imageInfo?.urls ?? []) : [];\n    // The descriptor's physical pixel size (server Bio-Formats `/tiles/info`) is\n    // authoritative — push it into the shared meta so the Region Editor reports\n    // areas in µm²/mm², matching the scale bar built from `d.mppX` below.\n    this.store.setPhysicalPixelSize(d.mppX, d.mppY);\n    // Use the SAME grayscale flag the colormap dropdown / Plotly use\n    // (imageInfo.isGrayscale ← rgbChannels === 1). The descriptor's `channels`\n    // (channelCount) diverges from rgbChannels for stacks, which left grayscale\n    // stacks un-recolored even though the colormap selector was shown.\n    this.isGrayscaleImage = !!imageInfo?.isGrayscale;\n    // Simple (non-tiled, in-memory) image: no pyramid, no per-channel tiles, and\n    // no server-side intensity sampling — OSD's single-image source decodes\n    // urls[z] directly. Skip the whole tiled-setup path below.\n    const simple = !!loaded.simple;\n    if (simple) {\n      this.realLevels = 1;\n      this.isMultiChannel = false;\n      this.cache.clearChannelGroups();\n      this.destroyViewer();\n    } else {\n      // Multichannel fluorescence (indexed/LUT-bearing stacks) composite client-side\n      // from per-channel tiles. Trust the server's explicit `multichannel` flag — the\n      // old `channels>1 && grayscale` heuristic also matched RGB photos Bio-Formats\n      // reads as separated planes (channels>1, rgbChannels==1), splitting them into N\n      // per-channel TiledImages that flooded the tile endpoint and hung on load.\n      this.realLevels = d.realLevels ?? d.levels.length;\n      // Tiles to cover the whole image at the coarsest REAL Bio-Formats level (the\n      // smallest level that has real, per-channel-fetchable tiles — synthetic overview\n      // levels are server-composited only). A pyramidal image's coarsest real level is\n      // tiny (few tiles); a flat/no-pyramid image's is the full-res grid (many tiles).\n      const coarse = d.levels[this.realLevels - 1] ?? d.levels[d.levels.length - 1];\n      const coarseW = coarse ? Math.ceil(coarse.width / d.tileSize) : 1;\n      const coarseH = coarse ? Math.ceil(coarse.height / d.tileSize) : 1;\n      const coarseTiles = coarseW * coarseH;\n      this.isMultiChannel = !!d.multichannel;\n      if (this.isMultiChannel) {\n        // Per-channel rendering can only use the REAL levels, so OSD requests the\n        // coarsest real level's whole tile grid × N channels at fit. When that's large\n        // (a whole-slide), it's too many (often slow, pyramid-less) full-res reads —\n        // fall back to the single server-composited source (which keeps the fast\n        // synthetic overviews). A small single-FOV z-stack stays per-channel. Size in\n        // BYTES isn't the signal — tile count is.\n        const fitTiles = coarseTiles * Math.max(1, d.channels ?? 1);\n        if (fitTiles > this.MAX_MULTICHANNEL_FIT_TILES) {\n          this.isMultiChannel = false;\n          console.warn(\n            '[OSD] multichannel composite too large for per-channel rendering: ' +\n            `${coarseW}x${coarseH} tiles x ${d.channels} channels = ${fitTiles} at the coarsest ` +\n            `real level (> ${this.MAX_MULTICHANNEL_FIT_TILES}); rendering server-composited for speed.`,\n          );\n        }\n      }\n      this.cache.clearChannelGroups();\n      // Auto-range grayscale tiles to the image's actual intensity span (like the\n      // heatmap), sampling the coarsest tile level so the window matches the raw\n      // tile values. Fire-and-forget: it re-invalidates once the window is known;\n      // tiles paint unwindowed until then. (Multichannel windows are per-channel,\n      // defaulting to full range; the user auto/edits each channel.)\n      if (this.isMultiChannel) {\n        this.sampler.computeMultiChannelHistograms(d, loaded.infoB64, loaded.z);\n      } else {\n        this.sampler.computeImageWindow(d, loaded.infoB64, loaded.z);\n      }\n      this.destroyViewer();\n      // Size the slice cache for this image: LRU cap to hold the whole stack\n      // (capped) and skip background preloading for stacks too large to preload\n      // (would flood full-res reads). Normal stacks keep the flicker-free pre-cache.\n      this.cache.configure(d.z ?? 1, coarseTiles);\n    }\n\n    // Simple mode: OSD's single-image source decodes the URL (blob:/data:/http)\n    // directly — no pyramid, no server. Tiled mode: the custom server-backed tile\n    // source (multichannel opens on channel 0; the open handler then swaps in this\n    // slice's per-channel group and the background loader pre-fills the rest).\n    const tileSource = simple\n      ? { type: 'image', url: loaded.url }\n      : this.buildTileSource(d, loaded.infoB64, loaded.z, this.isMultiChannel ? 0 : undefined);\n    silenceOsdMultiImageAdvisory();\n    this.viewer = (OSD as any)({\n      id: plotDiv,\n      // Simple-mode z-scrub calls viewer.open() again per slice (see\n      // setZIndex) — without this it resets to the home zoom/pan on every\n      // slice change. Tiled mode never re-opens (it toggles pre-added\n      // TiledImages' opacity instead), so this is a no-op there.\n      preserveViewport: true,\n      // Use the 2D canvas drawer, not WebGL: creating/destroying a viewer on\n      // each engine toggle / image load churns WebGL contexts (browsers cap\n      // how many exist at once), which surfaces as \"WebGL context was lost\"\n      // and blank tiles. The canvas drawer has no such limit.\n      drawer: 'canvas',\n      showNavigationControl: false, // avoids needing the icon-image assets\n      // Overview thumbnail with the current-viewport rectangle, bottom-right.\n      showNavigator: this.navigatorVisible,\n      // Nearest-neighbour when off → crisp pixels on zoom-in (pixel inspection).\n      imageSmoothingEnabled: this.smoothingEnabled,\n      navigatorPosition: 'BOTTOM_RIGHT',\n      navigatorSizeRatio: 0.16,\n      navigatorAutoFade: false,\n      navigatorBackground: 'rgba(0,0,0,0.5)',\n      loadTilesWithAjax: true,\n      ajaxWithCredentials: true, // cookie auth (oauth2-proxy)\n      ajaxHeaders: this.authHeaders, // bearer auth (Auth0), when available\n      crossOriginPolicy: 'Anonymous',\n      // Gentler zoom: the default (1.2) feels fast and big jumps cross several\n      // pyramid levels at once, firing a burst of tile requests.\n      zoomPerScroll: 1.1,\n      // Click-to-zoom toward the clicked point (OpenSeadragon's default demo\n      // behaviour). Only applies when no region tool is active — an active tool\n      // disables OSD mouse-nav so clicks draw/select instead of zooming.\n      gestureSettingsMouse: { clickToZoom: true, scrollToZoom: true },\n      // Zoom limits (jit-ui#94). Default minZoomImageRatio (0.9) stops you from\n      // zooming the image smaller than ~home; drop it so the image can be shrunk\n      // freely (effectively no minimum). Default maxZoomPixelRatio (1.1) caps\n      // zoom-in at ~1 screen px per image px; raise it so you can zoom in to\n      // inspect individual pixels (paired with imageSmoothingEnabled=false for\n      // crisp nearest-neighbour blocks).\n      minZoomImageRatio: 0.01,\n      maxZoomPixelRatio: 20,\n      // Wait for the view to settle before pulling new tiles (less churn).\n      immediateRender: false,\n      animationTime: 0.4,\n      // Release memory aggressively: cap the tile cache so tiles outside the\n      // current view (e.g. the coarser levels left behind after zooming in) are\n      // evicted instead of accumulating. Large whole-slide tiles — doubled when\n      // the colormap pipeline keeps a recolored copy — make an unbounded cache\n      // costly. Tunable; lower = less memory, more re-fetch on pan-back.\n      // Stacks keep many slices resident (the whole stack is background-loaded),\n      // so they get a much larger tile budget — otherwise switching slices evicts\n      // each other's tiles and scrubbing back re-fetches. Scaled to the resident\n      // slice count; single images keep the lean default.\n      maxImageCacheCount: (d.z ?? 1) > 1 ? Math.min(2400, Math.max(600, this.cache.maxSlices() * 40)) : 150,\n    });\n\n    return new Promise<boolean>((resolve) => {\n      // Always settle: if OSD never emits open/open-failed (a bad tile source,\n      // a viewer torn down mid-open), the render pipeline must not hang — a hang\n      // leaves imageLoading=true, sticking the spinner and the 500ms\n      // cache-progress poll forever (NS_BINDING_ABORTED storm).\n      let settled = false;\n      const done = (ok: boolean) => {\n        if (!settled) {\n          settled = true;\n          resolve(ok);\n        }\n      };\n      this.viewer!.addOnceHandler('open', () => {\n        // Region overlay reads/writes the shared RegionStore, so regions stay\n        // in sync with Plotly and the Region Editor. Recreate it per open() so\n        // it binds to the freshly-opened viewer's canvas/MouseTracker.\n        this.overlay?.destroy();\n        this.overlay = new OsdRegionOverlay(this.viewer as any, this.regionStore);\n        this.coordTransform = new OsdCoordinateTransform(this.viewer as any);\n        this.scaleBar = new OsdScaleBar(this.viewer as any, d.mppX ?? 0);\n        this.buildToolHosts();\n        // Simple mode is a single, self-contained image — no slice cache to seed.\n        if (simple) {\n          /* nothing to cache: one frame, no pyramid */\n        } else if (this.isMultiChannel) {\n          // Drop the single opened (channel-0) image and add this slice's channel\n          // group to the per-slice cache. The shared background loader / LRU then\n          // pre-fills the other slices' channel groups so z-scrub is flicker-free.\n          try {\n            const it0 = (this.viewer as any).world?.getItemAt?.(0);\n            if (it0) (this.viewer as any).world.removeItem(it0);\n          } catch { /* nothing to remove */ }\n          this.cache.addChannelSlice(this.currentZ);\n        } else {\n          // Seed the slice cache with the just-opened slice (world item 0), so\n          // scrubbing back to it later is an instant opacity toggle, not a re-open.\n          const firstItem = (this.viewer as any).world?.getItemAt?.(0);\n          if (firstItem) this.cache.seedComposite(this.currentZ, firstItem);\n        }\n        // The wand samples the *rendered viewport*, so its pixel matrix is only\n        // valid for the current view — drop it whenever the viewport changes.\n        this.viewer!.addHandler('viewport-change', () => {\n          this.viewportPixels = null;\n        });\n        // Grayscale tiles get the active colormap via the pixel pipeline. The\n        // handler runs per tile on load (and on requestInvalidate); recoloring\n        // is a no-op for RGB images or before the LUT resolves.\n        // (isGrayscaleImage is set from imageInfo.isGrayscale in plot() above.)\n        this.viewer!.addHandler('tile-invalidated', (event: any) => this.recolorTile(event));\n        // The overview navigator is a separate mini-viewer with its own tiles,\n        // so it doesn't receive the main viewer's tile-invalidated events. Apply\n        // the same recolor pipeline to it so the minimap tracks the main image's\n        // colormap/LUT instead of staying grayscale.\n        const nav = (this.viewer as any).navigator;\n        nav?.addHandler('tile-invalidated', (event: any) => this.recolorTile(event));\n        if ((this.isGrayscaleImage && this.colorLut) || this.isMultiChannel) {\n          try {\n            (this.viewer as any).world.requestInvalidate(true);\n          } catch {\n            /* no-op */\n          }\n          try {\n            nav?.world?.requestInvalidate(true);\n          } catch {\n            /* no-op */\n          }\n        }\n        // Prefetch adjacent z-slices once the view settles (and on each settle,\n        // so it tracks the current viewport as the user pans/zooms). Simple mode\n        // has a single frame, so there's nothing to prefetch.\n        if (!simple) this.viewer!.addHandler('animation-finish', () => this.cache.schedulePrefetch());\n        // Tell listeners (the intensity inset) the visible image region whenever\n        // the view settles, so they can re-sample at the current zoom resolution.\n        this.viewer!.addHandler('animation-finish', () => this.emitViewportChange());\n        // Chrome compositor bug: after an OSD zoom the docked toolbar (a sibling of\n        // #plot in the <visualizer> host) is left laid-out-but-unpainted and\n        // vanishes — confirmed via DevTools (DOM intact, region simply not painted).\n        // CSS (z-index / isolation / contain) and DOM-reparenting don't fix it; a\n        // repaint reliably does. Nudge it each animation frame (so it never visibly\n        // drops) and on settle. The synchronous display toggle re-rasters with no\n        // visible gone-frame and no layout shift.\n        this.viewer!.addHandler('animation', () => this.nudgeToolbarRepaint());\n        this.viewer!.addHandler('animation-finish', () => this.nudgeToolbarRepaint());\n        if (!simple) this.cache.schedulePrefetch();\n        // Force fit-to-view as the split/flex layout settles. A tall\n        // non-pyramidal image can otherwise open zoomed-in (image width filling\n        // the viewer), making OSD demand slow full-res res=0 tiles for the\n        // centre instead of the fast coarse overview → white canvas. goHome\n        // fits the whole image so OSD selects the coarse synthetic level. Retry\n        // across a few frames because the container may not have its final size\n        // on the first frame after 'open'.\n        const refit = () => {\n          try {\n            this.viewer?.viewport.goHome(true);\n            // The navigator was sized in the Viewer constructor — BEFORE the\n            // layout settled — so its element can carry a stale (even\n            // wrong-aspect) size that floats the visible minimap above the\n            // corner. Re-size it from the settled container.\n            this.resizeNavigator();\n          } catch {\n            /* torn down */\n          }\n        };\n        requestAnimationFrame(refit);\n        setTimeout(refit, 150);\n        setTimeout(refit, 400);\n        // The timed retries above miss the case where the container is STILL\n        // zero-size at 400ms — which happens when the render starts while the\n        // file viewer is mid-switch from the folder view to the diagram (e.g.\n        // \"Load as Stack\" from a folder, with no image open first). Because\n        // preserveViewport suppresses OSD's own open-time fit, the image would\n        // then be left un-fitted at the top-left (\"a tile\"). A one-shot\n        // ResizeObserver fits the instant the container first has a real size,\n        // regardless of when the render began (jit-ui#106).\n        this.fitWhenContainerSized(document.getElementById(plotDiv), refit);\n        // Keep the navigator sized to the container as the panel resizes.\n        this.viewer!.addHandler('resize', () => this.resizeNavigator());\n        done(true);\n      });\n      this.viewer!.addOnceHandler('open-failed', (e: any) => {\n        console.warn('[OSD] open-failed', e?.message ?? e);\n        done(false);\n      });\n      setTimeout(() => {\n        if (!settled) console.warn('[OSD] viewer open timed out');\n        done(false);\n      }, 8000);\n      this.viewer!.open(tileSource as any);\n    });\n  }\n\n  /**\n   * Fit-to-home once `el` first has a non-zero size. If it's already sized we\n   * rely on the timed refits the caller scheduled; otherwise a one-shot\n   * ResizeObserver runs `refit` the moment the container is laid out (then\n   * disconnects), so the initial fit doesn't depend on the render's start time\n   * relative to the diagram container's layout. No-op without a container or\n   * ResizeObserver (the timed refits remain the fallback). One-shot + only\n   * attached on a fresh mount, so slice-scrub re-opens keep the user's zoom.\n   */\n  private fitWhenContainerSized(el: HTMLElement | null, refit: () => void): void {\n    if (!el || typeof ResizeObserver === 'undefined') return;\n    if (el.clientWidth > 0 && el.clientHeight > 0) return; // already sized — timed refits suffice\n    const ro = new ResizeObserver(() => {\n      if (el.clientWidth > 0 && el.clientHeight > 0) {\n        ro.disconnect();\n        refit();\n      }\n    });\n    ro.observe(el);\n    // Safety net: stop observing even if it never gains a size.\n    setTimeout(() => ro.disconnect(), 5000);\n  }\n\n  /**\n   * Custom tile source built from the descriptor. OSD numbers levels\n   * coarsest-first; the backend numbers resolutions full-res-first, so\n   * `res = (levels-1) - osdLevel`. Overriding getLevelScale/getNumTiles lets us\n   * honour Bio-Formats' actual per-level dimensions (not assume power-of-two).\n   */\n  private buildTileSource(d: TileDescriptor, infoB64: string, z: number, channel?: number): any {\n    // Multichannel images composite from per-channel tiles, which only exist at\n    // real Bio-Formats resolutions — so drive OSD off the real levels alone and\n    // skip the synthetic (server-composited) overviews. Every displayed tile is\n    // then per-channel-fetchable at any zoom.\n    const levels = this.isMultiChannel ? d.levels.slice(0, this.realLevels) : d.levels;\n    const n = levels.length;\n    const t = d.tileSize;\n    const base = this.api;\n\n    // OSD level i (0 = coarsest) <-> backend resolution (n-1-i) (res 0 = full).\n    // The backend pyramid is NOT necessarily power-of-two, so we drive OSD off\n    // the backend's real per-level dimensions. We override ONLY getLevelScale:\n    // OSD derives getNumTiles, getTileBounds AND its per-zoom level selection\n    // from getLevelScale, so they all stay consistent — requesting exactly the\n    // tiles each resolution actually has (no out-of-range 400s, no flood).\n    const resForLevel = (level: number) => n - 1 - level;\n    const ts: any = new (OSD as any).TileSource({\n      width: d.width,\n      height: d.height,\n      tileSize: t,\n      tileOverlap: 0,\n      minLevel: 0,\n      maxLevel: n - 1,\n    });\n    ts.getLevelScale = (level: number) => {\n      const lvl = levels[resForLevel(level)];\n      return lvl ? lvl.width / d.width : 1;\n    };\n    // Drive the tile COUNT off each level's own (independently-rounded) dimensions,\n    // not OSD's default `ceil(scale * fullDimension / tileSize)`. Synthetic AND real\n    // Bio-Formats levels aren't exact proportional scales of the full image, so\n    // `scale * fullHeight` can round up to one more row (or column) than the level\n    // actually has — OSD then requests an out-of-range tile that the server 400s\n    // (\"Tile (col,row) out of range\"). Using the level's real w/h matches the\n    // server's own bounds check exactly.\n    const Point = (OSD as any).Point;\n    ts.getNumTiles = (level: number) => {\n      const lvl = levels[resForLevel(level)];\n      if (!lvl) return new Point(0, 0);\n      return new Point(Math.ceil(lvl.width / t), Math.ceil(lvl.height / t));\n    };\n    ts.getTileUrl = (level: number, x: number, y: number) =>\n      buildTileUrl(base, infoB64, { res: resForLevel(level), col: x, row: y, z, tileSize: t, channel });\n    return ts;\n  }\n\n  /** Re-apply the display pipeline (window/gamma/colour/invert) after a state change.\n   *  Multichannel invalidates ONLY the visible slice's channel images — invalidating\n   *  the whole world would re-process every hidden/preloaded slice's tiles (hundreds),\n   *  flooding OSD with \"[CacheRecord] … InvalidStateError\" and wasting work on tiles\n   *  that aren't on screen. The other cached slices are marked stale and re-tinted\n   *  lazily when revealed. Composite/grayscale invalidate the world as before. */\n  private invalidateDisplay(): void {\n    const v: any = this.viewer;\n    if (!v) return;\n    if (this.isMultiChannel) {\n      this.cache.invalidateChannelDisplay(this.currentZ);\n      return;\n    }\n    try { v.world.requestInvalidate(true); } catch { /* no-op */ }\n    try { v.navigator?.world?.requestInvalidate(true); } catch { /* no-op */ }\n  }\n\n  private destroyViewer(): void {\n    this.cache.cancelBackgroundLoad();\n    // Tear down any active tool overlays (shared singletons).\n    this.wandTool.setMode(false);\n    this.brushTool.setMode(false);\n    this.samPointTool.setMode(false);\n    this.eraserTool.setMode(false);\n    if (this.overlay) {\n      this.overlay.destroy();\n      this.overlay = null;\n    }\n    if (this.scaleBar) {\n      this.scaleBar.destroy();\n      this.scaleBar = null;\n    }\n    if (this.viewer) {\n      this.viewer.destroy();\n      this.viewer = null;\n    }\n    this.coordTransform = null;\n    this.cache.reset();\n    this.sampler.clear();\n  }\n\n  /** This backend's region renderer (the SVG overlay), once a plot is mounted. */\n  getRegionOverlay(): IRegionOverlay | null {\n    return this.overlay;\n  }\n\n  /** OSD renders only the image type — no isosurface, so no controls. */\n  getIsosurfaceControls(): IIsosurfaceControls | null {\n    return null;\n  }\n\n  /** OSD renders only the image type — no 3D scenes, so no controls. */\n  getSurface3dControls(): ISurface3dControls | null {\n    return null;\n  }\n\n  /** OSD renders only the image type — no LINE intensity ROIs, so no controls. */\n  getIntensityControls(): IIntensityControls | null {\n    return null;\n  }\n\n  private toOverlayMode(mode: string | false): RegionToolMode {\n    switch (mode) {\n      case 'drawrect':\n        return 'drawrect';\n      case 'drawclosedpath':\n        return 'drawclosedpath';\n      case 'drawopenpath':\n        return 'drawopenpath';\n      case 'drawpolygon':\n        return 'drawpolygon';\n      case 'addpoint':\n        return 'addpoint';\n      case 'deletepoint':\n        return 'deletepoint';\n      case 'move':\n        return 'move';\n      case 'select':\n        return 'select';\n      default:\n        return 'none';\n    }\n  }\n\n  reloadAndPlot(): void {\n    /* host re-drives plot() via the image-info stream */\n  }\n  reset(): void {\n    this.destroyViewer();\n  }\n  relayout(_trueImageSize?: number[]): void {\n    const vp = this.viewer?.viewport;\n    if (!vp) return;\n    // Keep the user's current view across a container/split resize instead of\n    // snapping home. Viewport bounds are image-relative (image width = 1), so\n    // they're independent of the container's pixel size — capture the visible\n    // region now and re-fit it once the new size has settled. OSD's autoResize\n    // fires asynchronously and the angular-split transition animates the width\n    // over a few hundred ms, so restore on the next frame and again after the\n    // transition completes.\n    const bounds = vp.getBounds(true);\n    const restore = () => {\n      try {\n        this.viewer?.viewport.fitBounds(bounds, true);\n        this.viewer?.viewport.applyConstraints(true);\n      } catch {\n        /* viewer torn down */\n      }\n    };\n    requestAnimationFrame(restore);\n    setTimeout(restore, 350);\n  }\n  resetAxes(): void {\n    this.viewer?.viewport.goHome();\n  }\n  autoscale(): void {\n    this.viewer?.viewport.goHome();\n    this.autoscaleEvent$.next('autoscale');\n  }\n  zoomIn(): void {\n    this.viewer?.viewport.zoomBy(1.3);\n    this.viewer?.viewport.applyConstraints();\n  }\n  zoomOut(): void {\n    this.viewer?.viewport.zoomBy(1 / 1.3);\n    this.viewer?.viewport.applyConstraints();\n  }\n  setDragMode(mode: string | false): void {\n    // Rectangle/polygon drawing run on the SVG overlay; wand/eraser/zoom-box\n    // (custom Plotly overlays) are routed to Plotly by the router and aren't\n    // handled here yet.\n    this.overlay?.setMode(this.toOverlayMode(mode));\n  }\n\n  setShowStack(_showstack: boolean): void {\n    /* OSD navigates the stack via the z-slider -> setZIndex */\n  }\n\n  /** Show/hide the overview navigator. Stored for the next viewer creation, and\n   *  applied live when a viewer is already mounted (hides/reveals its element —\n   *  the navigator instance itself only exists when created with showNavigator). */\n  setNavigatorVisible(visible: boolean): void {\n    this.navigatorVisible = visible;\n    const navEl: HTMLElement | undefined = (this.viewer as any)?.navigator?.element;\n    if (navEl) navEl.style.display = visible ? '' : 'none';\n  }\n\n  /** Toggle bilinear smoothing vs nearest-neighbour (crisp pixels). Stored for the\n   *  next viewer creation, and applied live (with a redraw) to a mounted viewer. */\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.smoothingEnabled = enabled;\n    const drawer: any = (this.viewer as any)?.drawer;\n    if (drawer?.setImageSmoothingEnabled) {\n      drawer.setImageSmoothingEnabled(enabled);\n      this.viewer?.forceRedraw();\n    }\n  }\n\n  /**\n   * Swap the displayed z-slice live. Slices are kept as separate tiled images in\n   * the world, so switching is just an opacity toggle: a previously-visited slice\n   * shows instantly (its decoded + recolored tiles are still resident), and a\n   * never-seen slice is added once. The region overlay, coordinate transform,\n   * scale bar, colormap pipeline and current zoom/pan all persist — the x/y\n   * geometry is identical across slices.\n   *\n   * Simple mode (tiled:false — a numbered image series assembled client-side,\n   * each slice its own complete image with no shared tile server) has no\n   * pyramid to toggle opacity on, so it re-opens the viewer on the new\n   * slice's URL instead. preserveViewport (viewer option, see plot()) keeps\n   * the current zoom/pan across that reopen.\n   */\n  setZIndex(zIndex: number): void {\n    const z = zIndex || 0;\n    if (z === this.currentZ) return;\n    if (!this.viewer) return;\n    if (this.simpleMode) {\n      const rawUrl = this.simpleUrls[z] ?? this.simpleUrls[0];\n      if (!rawUrl) return;\n      this.currentZ = z;\n      this.viewportPixels = null;\n      // Fetched via SimpleSliceAccessService (auth interceptor applies) then\n      // upscaled to full-res (same as the initial load — see toFullResUrl) so\n      // the world stays full-res across slices and ROIs keep aligning. Guard\n      // against a newer scrub landing first.\n      this.simpleStack.fetchAsBlobUrl(rawUrl)\n        .then((previewUrl) =>\n          this.toFullResUrl(previewUrl, this.descriptor?.width ?? 0, this.descriptor?.height ?? 0),\n        )\n        .then((url) => {\n          if (this.currentZ !== z || !this.viewer) return;\n          this.viewer.addOnceHandler('open-failed', (e: any) => {\n            console.warn('[OSD] slice re-open failed', e?.message ?? e);\n          });\n          this.viewer.open({ type: 'image', url } as any);\n        })\n        .catch((err) => console.warn('[OSD] slice fetch failed', err));\n      return;\n    }\n    if (!this.descriptor || !this.infoB64) return;\n    this.currentZ = z;\n    this.viewportPixels = null; // wand readback is slice-specific\n    this.cache.showSlice(z);\n    if (this.isMultiChannel) {\n      this.sampler.computeMultiChannelHistograms(this.descriptor, this.infoB64, z);\n    }\n  }\n\n  setStackLoading(stackLoading: boolean): void {\n    this.stackLoading$.next(stackLoading);\n  }\n  isStackLoading(): Observable<boolean> {\n    return this.stackLoading$.asObservable();\n  }\n  getStackLoadingProgress(): Observable<number> {\n    return this.stackLoadingProgress$.asObservable();\n  }\n\n  getTrueImageSize(): { width: number; height: number } | null {\n    return this.descriptor ? { width: this.descriptor.width, height: this.descriptor.height } : null;\n  }\n  getCurrentImage(): Promise<Image | null> {\n    return Promise.resolve(null);\n  }\n\n  /**\n   * The currently displayed pixels — the rendered viewport (what the user sees,\n   * including the current zoom and any colormap recolor), as RGBA. Feeds the\n   * processing-pipeline dialog's \"use current view\". Returns null until tiles\n   * are drawn.\n   */\n  getDisplayedPixelData(): PixelData | null {\n    const canvas: HTMLCanvasElement | undefined = (this.viewer as any)?.drawer?.canvas;\n    if (!canvas || !canvas.width || !canvas.height) return null;\n    const ctx = canvas.getContext('2d', { willReadFrequently: true });\n    if (!ctx) return null;\n    const { width, height } = canvas;\n    const img = ctx.getImageData(0, 0, width, height);\n    return { width, height, channels: 4, data: img.data };\n  }\n\n  /**\n   * Image-pixel rectangle the drawer canvas (what {@link getDisplayedPixelData}\n   * reads) currently covers. Unlike {@link emitViewportChange}, this is NOT\n   * clamped to the image bounds: the canvas maps 1:1 to the viewport rectangle,\n   * so leaving it unclamped keeps `canvasPx -> imagePx` an exact affine map\n   * (clamping would skew coordinates near the image edges). Routed through world\n   * item 0 (see {@link viewportRectToImage}) for multi-layer accuracy.\n   */\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    const vp: any = this.viewer?.viewport;\n    if (!vp || !this.descriptor) return null;\n    try {\n      const r = viewportRectToImage(this.viewer, vp.getBounds(true));\n      return { x: r.x, y: r.y, width: r.width, height: r.height };\n    } catch {\n      return null;\n    }\n  }\n\n  downloadImage(): void {\n    // Snapshot the currently rendered OSD view as a PNG (WYSIWYG) — the parallel\n    // to Plotly's downloadImage. OSD uses the 2D canvas drawer and bakes the\n    // active display settings (window / gamma / colormap / per-channel colours /\n    // invert) into the tiles via the recolor pipeline, so the drawer canvas\n    // already reflects exactly what's on screen at the current zoom/pan. The\n    // full-resolution stitched export lives in exportComposite() (Channels &\n    // Histogram dialog).\n    const canvas: HTMLCanvasElement | undefined = (this.viewer as any)?.drawer?.canvas;\n    if (!canvas || !canvas.width || !canvas.height) return;\n    const stem = (this.currentFileName || 'image').replace(/\\.[^.]+$/, '');\n    canvas.toBlob((blob) => {\n      if (blob) saveAs(blob, `${stem}.png`);\n    }, 'image/png');\n  }\n\n  setPlotType(_plotType: PlotType): void {\n    /* OSD only renders the image type */\n  }\n  setSurfaceDragMode(_mode: string): void {\n    /* 3D not supported by OSD */\n  }\n  resetSurfaceCamera(): void {\n    /* 3D not supported by OSD */\n  }\n\n  getAutoscaleEvent(): Observable<any> {\n    return this.autoscaleEvent$.asObservable();\n  }\n\n  /** Visible image region (full-image pixel coords), emitted when the view\n   *  settles. The intensity inset re-samples this region at the zoom resolution. */\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return this.viewportChange$.asObservable();\n  }\n\n  /** {@link IIntensitySampling} stub — intensity sampling lives in the Plotly\n   *  backend (it owns pixel readback). OSD feeds it only via getViewportChange$;\n   *  the sampling-cache priming itself is a no-op here. */\n  async ensureIntensitySampling(_imageInfo: IImageInfo, _zIndex: number): Promise<void> {\n    /* no-op: Plotly owns intensity sampling (see IIntensitySampling) */\n  }\n\n  /** {@link IIntensitySampling} stub — see {@link ensureIntensitySampling}. */\n  refreshIntensitySamplingForRoi(_x: number, _y: number, _width: number, _height: number,\n                                 _zIndex: number): void {\n    /* no-op: Plotly owns intensity sampling (see IIntensitySampling) */\n  }\n\n  /** Compute the current viewport's image-pixel rectangle (clamped to the image)\n   *  and broadcast it. */\n  private emitViewportChange(): void {\n    const vp: any = this.viewer?.viewport;\n    if (!vp || !this.descriptor) return;\n    try {\n      // Route through world item 0 (osd-coords): vp.viewportToImageRectangle is\n      // inaccurate and warns when the world holds multiple images (per-channel\n      // multichannel layers), which fed the intensity inset a wrong ROI.\n      const r = viewportRectToImage(this.viewer, vp.getBounds(true));\n      const iw = this.descriptor.width, ih = this.descriptor.height;\n      const x = Math.max(0, Math.min(iw, r.x));\n      const y = Math.max(0, Math.min(ih, r.y));\n      const width = Math.max(1, Math.min(iw - x, r.width));\n      const height = Math.max(1, Math.min(ih - y, r.height));\n      this.viewportChange$.next({ x, y, width, height });\n    } catch {\n      /* viewport not ready */\n    }\n  }\n\n  /** OSD targets the image display; the scalar/3D plot types belong to Plotly. */\n  getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    return [PLOT_TYPE_DESCRIPTORS[PlotType.HEATMAP]!];\n  }\n\n  getIntensityProfile$(): Observable<IntensityProfile[]> {\n    return this.intensityProfile$.asObservable();\n  }\n  /** OSD only renders the image type; the LINE intensity inset is Plotly-only. */\n  renderIntensityInset(_divId: string, _profiles: IntensityProfile[]): void {\n    /* no LINE mode on OSD */\n  }\n\n  // ── IRegionStore + classification colours ────────────────────────────\n  // Inherited from BaseStoreVisualizer — pure delegations to the shared\n  // RegionStore / VisualizerStore (identical to napari-js). The OSD region\n  // overlay (constructed in plot()) reads/writes that same store, so regions\n  // stay in sync with Plotly and the Region Editor; OSD renders them as an SVG\n  // overlay rather than carrying Plotly shape dicts.\n\n  // ── IToolController ──────────────────────────────────────────────────\n  // Wand + vertex eraser run over OSD via ICoordinateTransform. They share the\n  // singleton tool services with Plotly, so we re-bind to our hosts on activate.\n  setWandMode(active: boolean, options?: any): void {\n    if (!active) {\n      this.wandTool.setMode(false);\n      return;\n    }\n    // Take the pointer from OSD so the drag draws instead of panning. (Nav is\n    // re-enabled when the region overlay returns to 'none' on tool switch.)\n    this.viewer?.setMouseNavEnabled(false);\n    // The wand samples the rendered viewport — read back lazily on first use.\n    this.viewportPixels = null;\n    this.wandTool.bindHost(this.wandHost);\n    this.wandTool.setMode(true, (options ?? {}) as WandOptions);\n  }\n  setWandOptions(options: any): void {\n    this.wandTool.setOptions(options as WandOptions);\n  }\n  clearActiveWandRegion(): void {\n    this.wandTool.clearActiveRegion();\n  }\n  setBrushMode(active: boolean, options?: any): void {\n    if (!active) {\n      this.brushTool.setMode(false);\n      return;\n    }\n    // Take the pointer from OSD so the drag paints instead of panning.\n    this.viewer?.setMouseNavEnabled(false);\n    // The brush works in the rendered-viewport coordinate frame — read it back\n    // lazily on first use, like the wand. It shares the wand's host.\n    this.viewportPixels = null;\n    this.brushTool.bindHost(this.wandHost);\n    this.brushTool.setMode(true, (options ?? {}) as BrushOptions);\n  }\n  setBrushOptions(options: any): void {\n    this.brushTool.setSize((options as BrushOptions)?.size ?? 0);\n  }\n  setVertexEraserMode(active: boolean): void {\n    if (active) {\n      this.viewer?.setMouseNavEnabled(false); // tool takes the pointer\n      this.viewportPixels = null;\n      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 (active) {\n      this.viewer?.setMouseNavEnabled(false); // the box drag must not pan\n      this.zoomToBoxTool.bindHost(this.zoomBoxHost());\n    }\n    this.zoomToBoxTool.setMode(active);\n    if (!active) this.viewer?.setMouseNavEnabled(true);\n  }\n  /** Box-prompted SAM: segment the drawn rectangles. The SAM tool reuses the\n   *  wand host (viewport readback + coordinate transform + region store). */\n  segmentRectangles(): Promise<number> {\n    this.viewportPixels = null; // segment against the current viewport readback\n    this.samTool.bindHost(this.wandHost);\n    return this.samTool.segmentBoxes();\n  }\n  segmentRectanglesCellpose(): Promise<number> {\n    if (!this.cellSegmenter) return Promise.resolve(0);\n    this.viewportPixels = null; // crop against the current viewport readback\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 (active) {\n      this.viewer?.setMouseNavEnabled(false); // clicks add points, don't pan\n      this.viewportPixels = null;\n      this.samPointTool.bindHost(this.wandHost);\n    }\n    this.samPointTool.setMode(active);\n  }\n  commitSamPoints(): void { this.samPointTool.commit(); }\n  clearSamPoints(): void { this.samPointTool.clear(); }\n\n  /** Build the wand/eraser host objects bound to this backend. Both tools run\n   *  over OSD via the shared coordinate transform + a viewport pixel readback,\n   *  and read/write regions directly on the shared RegionStore (neutral model). */\n  private buildToolHosts(): void {\n    this.wandHost = {\n      getRegions: () => this.regionStore.getRegions(),\n      setRegions: (regions) => this.regionStore.setRegions(regions),\n      getCachedImageData: () => this.readbackViewport(),\n      getActiveFrameIndex: () => this.currentZ,\n      getOverlayContainer: () => this.getOverlayContainer(),\n      getCoordinateTransform: () => this.coordTransform as ICoordinateTransform,\n      getFileName: () => this.currentFileName,\n      getShapeColor: () => this.regionStore.getShapeColor(),\n    };\n    this.eraserHost = {\n      getRegions: () => this.regionStore.getRegions(),\n      setRegions: (regions) => this.regionStore.setRegions(regions),\n      invalidateWandRegion: () => this.wandTool.clearActiveRegion(),\n      getOverlayContainer: () => this.getOverlayContainer(),\n      getCoordinateTransform: () => this.coordTransform as ICoordinateTransform,\n      getCachedImageRatio: () => this.readbackViewport()?.ratios[0] ?? 1,\n    };\n  }\n\n  /** The element the on-canvas tool overlays attach to (OSD is mounted here). */\n  private getOverlayContainer(): HTMLElement | null {\n    return this.plotDiv ? document.getElementById(this.plotDiv) : null;\n  }\n\n  /** Size the navigator from the CURRENT container (navigatorSizeRatio of the\n   *  viewer element) and keep it pinned to the corner. OSD computes the size\n   *  once in the Viewer constructor — before the host flex layout settles —\n   *  and never corrects it, leaving a stale-size element whose visible minimap\n   *  floats above the bottom-right corner. */\n  private resizeNavigator(): void {\n    const v: any = this.viewer;\n    const nav = v?.navigator;\n    const el: HTMLElement | undefined = v?.element;\n    if (!nav?.element || !el?.clientWidth || !el?.clientHeight) return;\n    const w = Math.round(el.clientWidth * 0.16);\n    const h = Math.round(el.clientHeight * 0.16);\n    if (nav.element.style.width !== `${w}px` || nav.element.style.height !== `${h}px`) {\n      try {\n        nav.setWidth(w);\n        nav.setHeight(h);\n      } catch { /* navigator torn down */ }\n    }\n    // Normalize OSD's control-corner stack so the minimap sits flush in the\n    // corner, inset 12px to line up with the scale bar:\n    //  - the inline-block wrapper carries line-box struts and can retain stale\n    //    sizing → make it a tight block;\n    //  - anything else OSD left in the corner would stack below the navigator\n    //    and float it up → hide it;\n    //  - inset the corner itself (bottom/right 12px), keeping the element in\n    //    normal flow.\n    const wrapper = nav.element.parentElement as HTMLElement | null;\n    const corner = wrapper?.parentElement as HTMLElement | null;\n    if (wrapper && corner) {\n      wrapper.style.display = 'block';\n      wrapper.style.lineHeight = '0';\n      wrapper.style.fontSize = '0';\n      // The wrapper keeps the navigator's stale pre-settle height as an\n      // explicit size (the nav was 0.16x the UNSETTLED container at creation),\n      // leaving an empty band under the resized minimap — measured live:\n      // navH=87 inside wrapH=167. Force it to hug its content.\n      wrapper.style.height = 'auto';\n      wrapper.style.width = 'auto';\n      for (const child of Array.from(corner.children) as HTMLElement[]) {\n        if (child !== wrapper) child.style.display = 'none';\n      }\n      for (const child of Array.from(wrapper.children) as HTMLElement[]) {\n        if (child !== nav.element) child.style.display = 'none';\n      }\n      corner.style.bottom = '12px';\n      corner.style.right = '12px';\n    }\n    Object.assign(nav.element.style, { position: 'relative', top: '', left: '', bottom: '', right: '', margin: '0' });\n    // TODO(debug): remove after verification\n    const ner = nav.element.getBoundingClientRect();\n    const wr = wrapper?.getBoundingClientRect();\n    const cr = corner?.getBoundingClientRect();\n    const per = el.getBoundingClientRect();\n    console.warn(`[viz:nav] navBottom=${Math.round(ner.bottom)} wrapBottom=${Math.round(wr?.bottom ?? -1)} ` +\n      `cornerBottom=${Math.round(cr?.bottom ?? -1)} plotBottom=${Math.round(per.bottom)} ` +\n      `navH=${Math.round(ner.height)} wrapH=${Math.round(wr?.height ?? -1)} cornerH=${Math.round(cr?.height ?? -1)}`);\n  }\n\n  /** Force the docked toolbar to repaint after an OSD zoom. Chrome leaves it\n   *  laid-out-but-unpainted (the canvas's compositing churn strands the toolbar's\n   *  raster). A synchronous display toggle re-rasters it with no visible gone-frame\n   *  and no layout shift. Located via the DOM since this service doesn't own the\n   *  toolbar; a no-op when there's no toolbar (e.g. embedded without one). */\n  private nudgeToolbarRepaint(): void {\n    const plotEl = this.plotDiv ? document.getElementById(this.plotDiv) : null;\n    const dock = plotEl?.closest('visualization')?.querySelector<HTMLElement>('.toolbar-dock');\n    if (!dock) return;\n    const prev = dock.style.display;\n    dock.style.display = 'none';\n    void dock.offsetHeight; // reflow so the toggle re-rasters on the next paint\n    dock.style.display = prev;\n  }\n\n  /** Host for the (shared) zoom-to-box tool: convert overlay pixels to image\n   *  coords via the viewport, and fit the viewport to the chosen rectangle. */\n  private zoomBoxHost(): ZoomToBoxToolHost {\n    return {\n      getPlotDiv: () => this.plotDiv,\n      pixelToData: (px: number, py: number) => elementToImage(this.viewer, px, py),\n      applyZoomToBox: (coords: number[]) => this.applyZoomToBox(coords),\n    };\n  }\n\n  /** Fit the OSD viewport to an image-space rectangle (coords ordered\n   *  [xMin, xMax, yMax, yMin]). */\n  private applyZoomToBox(coordinates: number[]): void {\n    if (!this.viewer || coordinates.length < 4) return;\n    const [a, b, c, d] = coordinates;\n    const x = Math.min(a, b);\n    const w = Math.abs(b - a);\n    const y = Math.min(c, d);\n    const h = Math.abs(c - d);\n    if (w <= 0 || h <= 0) return;\n    const rect = imageRectToViewport(this.viewer, x, y, w, h);\n    this.viewer.viewport.fitBounds(rect, false);\n  }\n\n  /**\n   * Read back the *currently rendered* OSD canvas as the wand's pixel matrix.\n   * The matrix covers only the visible viewport at screen resolution, so when\n   * the user is zoomed into a sub-region the wand samples that region's detail\n   * (rather than the whole image at preview resolution). `originX/originY` and\n   * `ratios` map image coords <-> readback-pixel coords for the wand's\n   * data/ratio/origin model. Cached until the viewport changes.\n   */\n  private readbackViewport(): CachedImageData | null {\n    if (this.viewportPixels) return this.viewportPixels;\n    const viewer = this.viewer as any;\n    const canvas: HTMLCanvasElement | undefined = viewer?.drawer?.canvas;\n    const vp = viewer?.viewport;\n    if (!canvas || !canvas.width || !canvas.height || !vp) return null;\n    const ctx = canvas.getContext('2d', { willReadFrequently: true });\n    if (!ctx) return null;\n\n    const w = canvas.width; // device pixels\n    const h = canvas.height;\n    const data = ctx.getImageData(0, 0, w, h).data; // RGBA, row-major\n    // Build the [y][x] = [r,g,b] matrix the wand expects for RGB frames.\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\n    // Image-coord span the readback covers (CSS px in, image coords out). Route\n    // through world item 0 (osd-coords) so it stays accurate — and quiet — when\n    // the world holds multiple images (per-channel multichannel layers).\n    const elW = canvas.clientWidth || w;\n    const elH = canvas.clientHeight || h;\n    const tl = elementToImage(this.viewer, 0, 0);\n    const br = elementToImage(this.viewer, elW, elH);\n    const ratioX = (br.x - tl.x) / w; // image px per readback px\n    const ratioY = (br.y - tl.y) / h;\n\n    this.viewportPixels = {\n      frames: [matrix],\n      width: w,\n      height: h,\n      ratios: [ratioX, ratioY],\n      isGrayscale: false, // canvas readback is always RGBA\n      originX: tl.x,\n      originY: tl.y,\n    };\n    return this.viewportPixels;\n  }\n\n  /**\n   * Recolor a grayscale tile through the active colormap LUT, using OSD's\n   * tile-invalidated pixel pipeline (OSD 5+/6). Maps each pixel's grayscale\n   * value (r==g==b) to the LUT's RGB. No-op for RGB images or until the LUT is\n   * built. Handler is async — OSD awaits it (raiseEventAwaiting).\n   */\n  private async recolorTile(event: any): Promise<void> {\n    if (this.isMultiChannel) {\n      await this.recolorChannelTile(event);\n      return;\n    }\n    const gray = this.isGrayscaleImage;\n    if (gray) {\n      if (!this.colorLut) return;\n    } else if (!this.display.rgbNeedsRecolor()) {\n      return; // RGB at default (all visible, full window, γ=1, no invert) → passthrough\n    }\n\n    // Read the tile's pixels. Prefer the rendering context, but some tile caches\n    // (ajax PNG blobs) convert to an *empty* context2d — recoloring that would\n    // blank the tile (white canvas). So if the context has no opaque pixels, draw\n    // the tile's own bitmap/image and recolor that instead. We never write back\n    // unless we actually recolored something, so a tile is never blanked.\n    let ctx: CanvasRenderingContext2D | null = null;\n    try {\n      ctx = await event.getData('context2d');\n    } catch {\n      /* try bitmap below */\n    }\n    let img: ImageData | null = null;\n    if (ctx && ctx.canvas && ctx.canvas.width && ctx.canvas.height) {\n      try {\n        img = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);\n      } catch {\n        img = null;\n      }\n    }\n    if (!img || !this.hasOpaque(img.data)) {\n      // Fall back to the tile's decoded image/bitmap.\n      let src: any = null;\n      try {\n        src = await event.getData('imageBitmap');\n      } catch {\n        /* none */\n      }\n      if (!src || !src.width) {\n        try {\n          src = await event.getData('image');\n        } catch {\n          /* none */\n        }\n      }\n      if (!src || !src.width) return; // can't get pixels — leave the tile untouched\n      const c = document.createElement('canvas');\n      c.width = src.width;\n      c.height = src.height;\n      ctx = c.getContext('2d', { willReadFrequently: true });\n      if (!ctx) return;\n      ctx.drawImage(src, 0, 0);\n      img = ctx.getImageData(0, 0, c.width, c.height);\n    }\n\n    if (!this.display.applyToRgba(img.data) || !ctx) return; // nothing opaque\n    ctx.putImageData(img, 0, 0);\n    // The tile's cache can be evicted between the awaits above and here (slice\n    // change / invalidation), making setData throw a DOMException on a dead\n    // canvas. Swallow it — the tile is gone, so there's nothing to recolor.\n    try { await event.setData(ctx, 'context2d'); } catch { /* tile evicted */ }\n  }\n\n  /**\n   * Tint a single channel's tile in place. Each channel is its own OpenSeadragon\n   * TiledImage (a single-band grayscale tile); OSD composites the N images\n   * additively ('lighter') in its drawer — so this just maps the tile's intensity\n   * through the channel's window/gamma and its pseudo-colour. Synchronous (no\n   * cross-tile fetch) → no race, no seams. Channel is parsed from the tile URL.\n   */\n  private async recolorChannelTile(event: any): Promise<void> {\n    const tile = event?.tile;\n    const url: string = (tile && (typeof tile.getUrl === 'function' ? tile.getUrl() : tile.url)) || '';\n    const m = /[?&]channel=(\\d+)/.exec(url);\n    const ch = m ? parseInt(m[1], 10) : 0;\n    const st = this.channelStates[ch];\n\n    let ctx: CanvasRenderingContext2D | null = null;\n    try { ctx = await event.getData('context2d'); } catch { /* fallback below */ }\n    let img: ImageData | null = null;\n    if (ctx && ctx.canvas && ctx.canvas.width && ctx.canvas.height) {\n      try { img = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height); } catch { img = null; }\n    }\n    if (!img || !this.hasOpaque(img.data)) {\n      let src: any = null;\n      try { src = await event.getData('imageBitmap'); } catch { /* none */ }\n      if (!src || !src.width) { try { src = await event.getData('image'); } catch { /* none */ } }\n      if (!src || !src.width) return;\n      const c = document.createElement('canvas');\n      c.width = src.width; c.height = src.height;\n      ctx = c.getContext('2d', { willReadFrequently: true });\n      if (!ctx) return;\n      ctx.drawImage(src, 0, 0);\n      img = ctx.getImageData(0, 0, c.width, c.height);\n    }\n    if (!ctx) return;\n\n    // Precompute lum(0..255) → tinted RGB once, then map each pixel by lookup —\n    // the channel tile is single-band, so this turns ~262k per-pixel\n    // channelIntensity() (with Math.pow for gamma) calls into 256 — the difference\n    // between a snappy and a sluggish slider on a 4-channel stack.\n    const { r: rL, g: gL, b: bL } = this.display.channelRgbLut(st);\n    const d = img.data;\n    let changed = false;\n    for (let i = 0; i < d.length; i += 4) {\n      if (d[i + 3] === 0) continue;\n      const r = d[i], g = d[i + 1], b = d[i + 2];\n      const lum = r >= g ? (r >= b ? r : b) : g >= b ? g : b; // single-band → max\n      d[i] = rL[lum];\n      d[i + 1] = gL[lum];\n      d[i + 2] = bL[lum];\n      changed = true;\n    }\n    if (!changed) return;\n    ctx.putImageData(img, 0, 0);\n    // See recolorTile: the tile cache can die between the awaits and here.\n    try { await event.setData(ctx, 'context2d'); } catch { /* tile evicted */ }\n  }\n\n  /** Per-channel histogram for the Channels & Histogram pane, from the current\n   *  slice's sampled tiles (grayscale → channel 0; RGB → R/G/B). Null until the\n   *  async sampling resolves or if it was skipped. */\n  getHistogram(channelIndex: number, _bins: number): IHistogram | null {\n    return this.sampler.get(this.currentZ, channelIndex);\n  }\n\n  /** Native bit depth of a channel from the tile descriptor (8 when unknown). */\n  private channelBitDepth(channelIndex: number): number {\n    return this.descriptor?.channelInfo?.[channelIndex]?.bitDepth ?? 8;\n  }\n\n  /**\n   * Async histogram for the Channels & Histogram pane. For >8-bit images it\n   * fetches the **native** distribution from the server `/histogram` endpoint\n   * (the 8-bit canvas tiles can't carry 16-bit values) and caches it per\n   * slice+channel; for 8-bit/RGB it returns the existing client-sampled 8-bit\n   * histogram. Read-only — it never touches the tile/display pipeline.\n   */\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    if (this.channelBitDepth(channelIndex) <= 8 || !this.infoB64) {\n      return of(this.getHistogram(channelIndex, bins));\n    }\n    return this.sampler.native$(this.infoB64, this.currentZ, channelIndex, bins);\n  }\n\n  /**\n   * Export the underlying image data as a data-preserving multi-band TIFF at\n   * native bit depth via `GET /export/tiff` (the server reads the raw 16-bit\n   * planes — the client never sees them). Sends only the visible channels; the\n   * existing 8-bit composite PNG export is unaffected.\n   */\n  async exportData(): Promise<void> {\n    if (!this.infoB64) return;\n    const visible = this.channelStates.filter((c) => c.visible).map((c) => c.index);\n    const all = this.channelStates.length;\n    // Omit `channels` when every channel is visible (server default = all).\n    const chParam =\n      visible.length && visible.length < all ? `&channels=${visible.join(',')}` : '';\n    const url = `${this.api}export/tiff?info=${this.infoB64}&z=${this.currentZ}${chParam}`;\n    const stem = (this.currentFileName || 'image').replace(/\\.[^.]+$/, '');\n    try {\n      const resp = await firstValueFrom(\n        this.http\n          .get(url, { observe: 'response', responseType: 'blob' })\n          .pipe(timeout(600000)), // large exports stream slowly; generous deadline\n      );\n      if (resp.status === 202) {\n        console.warn('[OSD] 16-bit export: file still caching — try again shortly.');\n        return;\n      }\n      const blob = resp.body;\n      if (blob) saveAs(blob, `${stem}_16bit.ome.tif`);\n    } catch (err) {\n      console.warn('[OSD] 16-bit TIFF export failed', err);\n    }\n  }\n\n  /**\n   * Export the current slice as a publication-ready PNG composited with the\n   * active display settings (window / gamma / colormap or per-channel pseudo-\n   * colours / invert). Picks the largest pyramid level under a pixel cap (the\n   * coarser overview for huge whole-slides), fetches that level's tile grid,\n   * stitches it into one canvas, runs the shared display pipeline, and saves it.\n   */\n  async exportComposite(): Promise<void> {\n    const desc = this.descriptor;\n    const levels = desc?.levels ?? [];\n    if (!desc || !this.infoB64 || !levels.length) return;\n    const CAP = 32_000_000; // ~32 MP — bounds memory for whole-slide images\n    let res = levels.length - 1; // coarsest fallback\n    for (let i = 0; i < levels.length; i++) {\n      if (levels[i].width * levels[i].height <= CAP) { res = i; break; }\n    }\n    const lw = levels[res].width;\n    const lh = levels[res].height;\n    const t = desc.tileSize;\n    const cols = Math.max(1, Math.ceil(lw / t));\n    const rows = Math.max(1, Math.ceil(lh / t));\n    const canvas = document.createElement('canvas');\n    canvas.width = lw;\n    canvas.height = lh;\n    const ctx = canvas.getContext('2d', { willReadFrequently: true });\n    if (!ctx) return;\n    const z = this.currentZ;\n    const jobs: Promise<void>[] = [];\n    for (let row = 0; row < rows; row++) {\n      for (let col = 0; col < cols; col++) {\n        const url = buildTileUrl(this.api, this.infoB64, { res, col, row, z, tileSize: t });\n        jobs.push(\n          (async () => {\n            try {\n              const bmp = await fetchTileBitmap(this.http, url, 30000);\n              ctx.drawImage(bmp, col * t, row * t);\n              bmp.close?.();\n            } catch (err) {\n              // Skip a failed tile — the exported composite has a gap there.\n              console.warn('[viz:export] composite tile fetch failed, skipping', url, err);\n            }\n          })(),\n        );\n      }\n    }\n    await Promise.all(jobs);\n    try {\n      const imageData = ctx.getImageData(0, 0, lw, lh);\n      if (this.display.applyToRgba(imageData.data)) ctx.putImageData(imageData, 0, 0);\n    } catch (err) {\n      // Keep the un-recolored composite if readback fails — but say why.\n      console.warn('[viz:export] composite recolor readback failed — exporting raw tiles', err);\n    }\n    const stem = (this.currentFileName || 'image').replace(/\\.[^.]+$/, '');\n    canvas.toBlob((blob) => {\n      if (blob) saveAs(blob, `${stem}_composite.png`);\n    }, 'image/png');\n  }\n\n  /** True if any pixel in the RGBA buffer is non-transparent. */\n  private hasOpaque(d: Uint8ClampedArray): boolean {\n    for (let i = 3; i < d.length; i += 4) {\n      if (d[i] !== 0) return true;\n    }\n    return false;\n  }\n\n  // ── IDisplayOptions ──────────────────────────────────────────────────\n  // Inherited from BaseStoreVisualizer — pure delegations to the shared\n  // VisualizerStore, so OSD and Plotly stay in lock-step. OSD applies the\n  // colormap to grayscale tiles via the LUT reactively (see the constructor's\n  // colormap subscription), not in setColormap.\n\n  // ── IVisualizer ──────────────────────────────────────────────────────\n  unsubscribe(): void {\n    this.colormapSub?.unsubscribe();\n    this.colormapSub = null;\n    this.destroyViewer();\n  }\n}\n"]}