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

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

@@ -1,9 +1,8 @@
 import { Injectable, Inject, Optional } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
-import { BehaviorSubject, Subject, combineLatest, defer, firstValueFrom, of } from 'rxjs';
-import { startWith, timeout } from 'rxjs/operators';
-import { OSD } from './osd-lib';
-import { OSD_ZOOM_PER_SCROLL } from './osd-zoom';
+import { BehaviorSubject, EMPTY, of } from 'rxjs';
+import { buildViewerOptions } from './openseadragon-viewer-options';
+import { createViewer, openViewer } from './osd-viewer-mount';
 import { VisualizerStore } from '../../store/visualizer-store.service';
 import { RegionStore } from '../../store/region-store.service';
 import { TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';
@@ -13,96 +12,73 @@ import { ViewerFeature, capabilitiesOf } from '../../contracts/capabilities.cont
 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 { OsdViewportAdapter } from './osd-viewport';
+import { OsdNavigatorChrome } from './osd-navigator-chrome';
+import { elementToImage } from './osd-coords';
+import { buildOsdTileSource, planTiledMount } from './osd-tile-source';
 import { SliceCache } from './slice-cache';
-import { DisplayPipeline } from './display-pipeline';
+import { OsdTileRecolorer } from './tile-recolor';
+import { OsdSimpleSource } from './simple-source';
+import { readDrawerPixels, readbackViewportFrame, saveDrawerSnapshot } from './osd-pixel-readback';
+import { fetchTiffExport, fileStem, renderCompositePng } from './osd-export';
 import { HistogramSampler } from './histogram-sampler';
+import { exportTiffFilename, exportTiffUrl, httpFetchJson, pollDescriptor, throwIfAborted, tilesInfoUrl, } from '../tile-server';
 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 { createCanvasToolManager } from '../../toolbar/canvas-tools';
+import { WandService } from '../../toolbar/wand/wand.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;
-}
+import * as i2 from "../../toolbar/wand/wand.service";
+import * as i3 from "../../toolbar/segmentation/sam-tool.service";
+import * as i4 from "../../toolbar/segmentation/sam-point-tool.service";
+import * as i5 from "../../toolbar/segmentation/cell-segment-tool.service";
+import * as i6 from "../../store/visualizer-store.service";
+import * as i7 from "../../store/region-store.service";
+import * as i8 from "../simple-slice-access.service";
+/** Wait between two `/tiles/info` polls while the server answers 202. */
+const OSD_TILES_INFO_POLL_INTERVAL_MS = 1500;
+/** The drag modes the SVG region overlay handles itself (see setDragMode). */
+const OVERLAY_MODES = new Set([
+    'drawrect',
+    'drawclosedpath',
+    'drawopenpath',
+    'drawpolygon',
+    'addpoint',
+    'deletepoint',
+    'move',
+    'select',
+]);
 /**
  * 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
+ * the Bio-Formats ROI renderer), or — for a `tiled: false` image — by
+ * self-contained per-slice URLs. 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.
+ * Display settings (window/gamma/colormap/invert, per-channel tints) are applied
+ * client-side by recoloring tiles; regions are drawn by {@link OsdRegionOverlay}
+ * and the canvas tools read back the rendered viewport. The collaborators
+ * (slice cache, display pipeline, histogram sampler, tile client) and the
+ * recolor invariant are described in this folder's README.
  */
 export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
-    constructor(http, tiles, wandTool, brushTool, samTool, samPointTool, cellSegmentTool, cellSegmenter, eraserTool, zoomToBoxTool, store, regionStore, simpleStack, config) {
+    constructor(http, tiles, wandService, samTool, samPointTool, cellSegmentTool, cellSegmenter, 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]);
@@ -114,30 +90,6 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
          *  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();
-        /** SERVERLESS multichannel (tiled:false + channelCount>1): the stack's
-         *  per-slice per-channel plane URLs, the current slice's decoded planes, and
-         *  the last composite blob URL. Composited client-side via display.channelRgbLut
-         *  (no tile server); kept OFF the tiled isMultiChannel path. */
-        this.simpleMultichannel = false;
-        this.simpleChannelUrls = [];
-        this.simpleChannelPlanes = [];
-        this.simpleCompositeUrl = null;
-        /** 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). */
@@ -145,207 +97,154 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
         /** 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;
-        /** Bumped by every display invalidation. A recolor round captures it and, after
-         *  each `await`, abandons the tile once a newer round has started. Writing a
-         *  superseded context back is not merely wasted work: OSD's conversion sees a
-         *  canvas the newer round already replaced, throws `DOMException`, and
-         *  `_handleConversionError` DESTROYS the cache record and unloads the tile
-         *  (unlike the drawer's rasterBlob path, it does not re-prepare). Enough of
-         *  those and the viewer goes white mid-drag. */
-        this.displayToken = 0;
-        /** Pending coalesced invalidation (see {@link scheduleInvalidate}). */
-        this.invalidateHandle = 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. */
+        /** True for multichannel fluorescence drawn per channel: one single-band
+         *  TiledImage per channel, tinted by the recolorer (see planTiledMount). */
         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;
+        /** Navigator, smoothing, initial fit and the toolbar repaint workaround
+         *  (see OsdNavigatorChrome). */
+        this.chrome = new OsdNavigatorChrome({
+            viewer: () => this.viewer,
+            plotDiv: () => this.plotDiv,
+        });
         /** 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. */
+         *  several minutes. Generous because each poll is cheap; on expiry the router
+         *  falls back to Plotly. (napari-js waits less — it falls back to a single tile.) */
         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({
+        /** Window/gamma/colormap/invert and per-channel tints, applied to the tiles
+         *  through OSD's pixel pipeline (see OsdTileRecolorer and the README's recolor
+         *  invariant). Its DisplayPipeline also drives the compositor and the export. */
+        this.recolor = new OsdTileRecolorer({
+            viewer: () => this.viewer,
             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. */
+            isMultiChannel: () => this.isMultiChannel,
+            isSimpleMultichannel: () => this.simple.multichannel,
+            currentZ: () => this.currentZ,
+            revealChannelSlice: (z) => this.cache.revealChannelSlice(z),
+            invalidateChannelDisplay: (z) => this.cache.invalidateChannelDisplay(z),
+            recomposite: (token) => void this.simple.recompositeAndOpen(token),
+        }, this.store);
+        /** The serverless (`tiled: false`) image source and all its state (see
+         *  OsdSimpleSource). */
+        this.simple = new OsdSimpleSource({
+            viewer: () => this.viewer,
+            descriptor: () => this.descriptor,
+            isGrayscale: () => this.isGrayscaleImage,
+            currentZ: () => this.currentZ,
+            setCurrentZ: (z) => {
+                this.currentZ = z;
+                this.viewportPixels = null; // the readback is slice-specific
+            },
+            sampler: () => this.sampler,
+            display: () => this.recolor.display,
+            channelStates: () => this.store.currentChannelStates(),
+            isCurrentDisplay: (token) => this.recolor.isCurrent(token),
+            scheduleInvalidate: () => this.recolor.scheduleInvalidate(),
+        }, this.simpleStack);
+        /** Stack-slice cache + background preloader (see SliceCache). */
         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,
+            channelCount: () => Math.max(1, this.recolor.channelStates.length || (this.descriptor?.channels ?? 1)),
+            channelVisible: (c) => this.recolor.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();
-        /** The visible rect on every redraw, coalesced to one emission per animation
-         *  frame. Feeds {@link PlotModeViewport.frame$}. */
-        this.frame$ = new Subject();
-        this.frameRaf = null;
-        this.plotModeViewport = null;
-        // Region state (regions, selection, the update event) lives in the shared
-        // RegionStore; the IRegionStore methods below delegate to it.
-        this.intensityProfile$ = new Subject();
+        /** The viewport as the library sees it: visible rects, the plot-mode
+         *  viewport, zoom/fit (see OsdViewportAdapter). */
+        this.viewport = new OsdViewportAdapter({
+            viewer: () => this.viewer,
+            descriptor: () => this.descriptor,
+            coordTransform: () => this.coordTransform,
+            overlayContainer: () => this.getOverlayContainer(),
+        });
+        this.viewportSource = {
+            getViewportChange$: () => this.viewport.viewportChange$.asObservable(),
+        };
+        this.viewOptions = {
+            setNavigatorVisible: (visible) => this.setNavigatorVisible(visible),
+            setImageSmoothingEnabled: (enabled) => this.setImageSmoothingEnabled(enabled),
+        };
+        // The canvas tools run over OSD through the shared coordinate transform and a
+        // viewport readback, and read/write the shared RegionStore. This backend owns
+        // its own tool instances (RT-21); the host reads live state, so it is built once.
+        this.toolHost = {
+            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(),
+            // Zoom-to-box: overlay pixels -> image coords, and fit the viewport to the box.
+            pixelToData: (px, py) => elementToImage(this.viewer, px, py),
+            applyZoomToBox: (coords) => this.viewport.applyZoomToBox(coords),
+        };
+        this.canvasTools = createCanvasToolManager(this.toolHost, {
+            wandService,
+            regionStore,
+            samPoint: samPointTool,
+        });
         this.api = config.slideCropServer;
         this.sampler = new HistogramSampler(this.http, this.api, {
             realLevels: () => this.realLevels,
-            channelCount: (d) => this.channelStates.length || (d.channels ?? 1),
+            channelCount: (d) => this.recolor.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;
-            // Serverless multichannel: re-composite the current slice from its cached
-            // planes with the new channel states + re-open (no tile-invalidate path).
-            if (this.simpleMultichannel) {
-                void this.recompositeAndOpen();
-                return;
-            }
-            // 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. Coalesced: PrimeNG's slider fires (onChange) continuously, so
-            // a single drag would otherwise queue dozens of overlapping restore +
-            // re-process rounds over every channel image.
-            this.scheduleInvalidate();
+            // Background-preloaded slices are sampled too (histograms per slice), but
+            // only the displayed slice's window may seed or re-invalidate the display.
+            onGrayWindowSampled: (min, max, z) => {
+                if (z === this.currentZ)
+                    this.recolor.seedGrayWindow(min, max);
+            },
         });
+        this.recolor.ensureSubscription();
     }
-    /** 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 */
-            }
-        }
-    }
+    // Region state (regions, selection, the update event) lives in the shared
+    // RegionStore; image metadata and classification colours in the shared
+    // VisualizerStore — the inherited IRegionStore/display methods delegate there.
     // ── 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).
+     *
+     * `signal` (the host's render supersession) cancels the `/tiles/info` poll and
+     * the simple-image fetches: the load then rejects with an `AbortError`.
      */
-    async load(imageInfo, zIndex) {
+    async load(imageInfo, zIndex, signal) {
+        throwIfAborted(signal);
         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.simple.revokeUrls();
         }
         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);
+            this.authHeaders = {};
+            return this.simple.load(imageInfo, zIndex, signal);
         }
         const infoB64 = this.tiles.getSelectedInfoB64();
         if (!infoB64)
@@ -356,295 +255,29 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
         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 meta = imageInfo.imageMeta?.[0];
-        // SERVERLESS MULTICHANNEL: composite the slice's per-channel planes
-        // client-side (no tile server), driven by the channel pane. Kept OFF the
-        // tiled isMultiChannel path (see compositeSimpleMultichannel).
-        const chUrls = imageInfo.channelUrls;
-        this.simpleMultichannel = !!chUrls?.length && (meta?.channelCount ?? 1) > 1;
-        let url;
-        if (this.simpleMultichannel) {
-            this.simpleChannelUrls = chUrls;
-            try {
-                await this.loadSimpleChannelPlanes(chUrls[z] ?? chUrls[0]);
-                url = await this.compositeSimpleMultichannel();
-                // NB: histograms are binned in plot(), AFTER destroyViewer clears the
-                // sampler — computing them here would be wiped by that clear.
-            }
-            catch (err) {
-                console.warn('[OSD] simple multichannel composite failed', err);
-            }
-        }
-        else {
-            this.simpleChannelUrls = [];
-            this.simpleChannelPlanes = [];
-            const rawUrl = this.simpleStack.urlFor(imageInfo, z);
-            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', filename);
-            return { descriptor: null, infoB64: '', z, filename };
-        }
-        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;
-    }
-    /** Sample a SIMPLE-mode slice's own decoded pixels into the histogram — the
-     *  serverless analog of the tiled samplers (no tile server). Fire-and-forget;
-     *  a decode failure just leaves the pane empty rather than throwing. */
-    async sampleSimpleHistogram(url, z) {
-        if (!url)
-            return;
-        try {
-            const img = await this.loadImageEl(url);
-            const w = img.naturalWidth, h = img.naturalHeight;
-            if (!w || !h)
-                return;
-            const c = document.createElement('canvas');
-            c.width = w;
-            c.height = h;
-            const ctx = c.getContext('2d', { willReadFrequently: true });
-            if (!ctx)
-                return;
-            ctx.drawImage(img, 0, 0);
-            const data = ctx.getImageData(0, 0, w, h).data;
-            this.sampler.computeSimpleHistogram(z, data, this.isGrayscaleImage);
-        }
-        catch (err) {
-            console.warn('[OSD] simple-mode histogram sample failed', err);
-        }
-    }
-    /** Fetch + decode a slice's per-channel planes (single-band grayscale) into
-     *  pixel buffers, for the SERVERLESS multichannel compositor. Auth-safe: goes
-     *  through SimpleSliceAccessService (blob:/data: as-is; http via HttpClient). */
-    async loadSimpleChannelPlanes(urls) {
-        const planes = [];
-        for (const u of urls ?? []) {
-            try {
-                const previewUrl = await this.simpleStack.fetchAsBlobUrl(u);
-                const img = await this.loadImageEl(previewUrl);
-                const w = img.naturalWidth, h = img.naturalHeight;
-                if (!w || !h) {
-                    planes.push({ data: new Uint8ClampedArray(0), width: 0, height: 0 });
-                    continue;
-                }
-                const c = document.createElement('canvas');
-                c.width = w;
-                c.height = h;
-                const ctx = c.getContext('2d', { willReadFrequently: true });
-                if (!ctx) {
-                    planes.push({ data: new Uint8ClampedArray(0), width: 0, height: 0 });
-                    continue;
-                }
-                ctx.drawImage(img, 0, 0);
-                planes.push({ data: ctx.getImageData(0, 0, w, h).data, width: w, height: h });
-            }
-            catch (err) {
-                console.warn('[OSD] channel plane decode failed', err);
-                planes.push({ data: new Uint8ClampedArray(0), width: 0, height: 0 });
-            }
-        }
-        this.simpleChannelPlanes = planes;
-    }
-    /** Composite the cached per-channel planes into ONE RGBA image using the
-     *  current channel states (colour/window/gamma/visibility) — the client-side,
-     *  serverless analog of the tiled per-channel 'lighter' compositor
-     *  (same display.channelRgbLut math as recolorChannelTile, applied per-plane).
-     *  Returns a blob: URL of the composite PNG, revoking the previous one. */
-    async compositeSimpleMultichannel() {
-        const planes = this.simpleChannelPlanes;
-        if (!planes.length)
-            return undefined;
-        const w = planes[0].width, h = planes[0].height;
-        if (!w || !h)
-            return undefined;
-        const states = this.store.currentChannelStates();
-        const out = new Uint8ClampedArray(w * h * 4);
-        for (let c = 0; c < planes.length; c++) {
-            const st = states[c];
-            if (st && st.visible === false)
-                continue; // hidden channel contributes nothing
-            const plane = planes[c];
-            if (plane.width !== w || plane.height !== h || !plane.data.length)
-                continue;
-            const { r, g, b } = this.display.channelRgbLut(st);
-            const pd = plane.data;
-            for (let i = 0; i < out.length; i += 4) {
-                if (pd[i + 3] === 0)
-                    continue;
-                const lum = pd[i]; // single-band plane (R=G=B)
-                out[i] += r[lum]; // Uint8ClampedArray clamps → additive ('lighter')
-                out[i + 1] += g[lum];
-                out[i + 2] += b[lum];
-            }
-        }
-        for (let i = 3; i < out.length; i += 4)
-            out[i] = 255; // opaque
-        const canvas = document.createElement('canvas');
-        canvas.width = w;
-        canvas.height = h;
-        const ctx = canvas.getContext('2d');
-        if (!ctx)
-            return undefined;
-        ctx.putImageData(new ImageData(out, w, h), 0, 0);
-        const blob = await new Promise((res) => canvas.toBlob(res, 'image/png'));
-        if (!blob)
-            return undefined;
-        if (this.simpleCompositeUrl)
-            URL.revokeObjectURL(this.simpleCompositeUrl);
-        this.simpleCompositeUrl = URL.createObjectURL(blob);
-        return this.simpleCompositeUrl;
-    }
-    /** Re-composite the current slice from its cached planes (new channel states)
-     *  and re-open — the serverless analog of the tiled invalidate-on-channel-change. */
-    async recompositeAndOpen() {
-        const url = await this.compositeSimpleMultichannel();
-        if (!url || !this.viewer)
-            return;
-        try {
-            this.viewer.open({ type: 'image', url });
-        }
-        catch { /* viewer gone */ }
-    }
-    /** 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;
+        throwIfAborted(signal);
+        // Poll /tiles/info (the shared jit-service client): 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. Transport failures (a proxy hiccup, a slow metadata read
+        // timing a request out) are retried until the deadline; a non-202 status
+        // means this server won't describe the file.
+        //
+        // No descriptor (deadline, or a status other than 202) is a load failure, so
+        // the router falls back to Plotly for this image, as before. Not committed to
+        // `this.descriptor` here: the previous image stays mounted (and keeps using
+        // its own descriptor) until plot().
+        const descriptor = await pollDescriptor(httpFetchJson(this.http), tilesInfoUrl(this.api, infoB64), {
+            deadlineMs: this.tilesInfoTimeoutMs,
+            intervalMs: OSD_TILES_INFO_POLL_INTERVAL_MS,
+            signal,
+            tag: '[OSD]',
         });
-    }
-    revokeSimpleFullResUrls() {
-        for (const u of this.simpleFullResUrls.values())
-            URL.revokeObjectURL(u);
-        this.simpleFullResUrls.clear();
-        if (this.simpleCompositeUrl) {
-            URL.revokeObjectURL(this.simpleCompositeUrl);
-            this.simpleCompositeUrl = null;
-        }
+        if (!descriptor)
+            throw new Error('tiles/info gave no descriptor — file still caching or not tileable');
+        return { descriptor, infoB64, z: zIndex || 0, filename };
     }
     /** Mount the viewer with a custom tile source pointing at `GET /tile`. */
     plot(plotDiv, imageLoaded, imageInfo, _screenHeight, _plotType, inPlace) {
@@ -655,7 +288,10 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
         // 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();
+        this.recolor.ensureSubscription();
+        // A new image: a stroke or SAM prompt in progress belonged to the old one.
+        if (!inPlace)
+            this.canvasTools.resetAll();
         // 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
@@ -663,25 +299,16 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
         // 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 });
-            }
+            this.simple.refreshInPlace(loaded, imageInfo);
             return Promise.resolve(true);
         }
         this.plotDiv = plotDiv;
+        this.chrome.onMount(); // the toolbar is re-located for this mount
         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 ?? []) : [];
+        this.simple.commit(loaded, imageInfo);
         // 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.
@@ -700,64 +327,35 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
             this.isMultiChannel = false;
             this.cache.clearChannelGroups();
             this.destroyViewer();
-            // Serverless histogram — AFTER destroyViewer (its last act is sampler.clear()).
-            // Multichannel bins each cached channel plane; single-band / RGB bins the
-            // decoded frame's own pixels.
-            if (this.simpleMultichannel) {
-                this.sampler.computeSimpleMultichannelHistograms(loaded.z, this.simpleChannelPlanes);
-            }
-            else {
-                void this.sampleSimpleHistogram(loaded.url, loaded.z);
-            }
+            // Take over the composite URL and bin the histograms — AFTER destroyViewer
+            // (its last act is sampler.clear()).
+            this.simple.mount(loaded);
         }
         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.`);
-                }
-            }
+            // A tiled image is going on screen: no simple-mode state may survive it
+            // (load() normally cleared it already; plot() is what mounts the image).
+            this.simple.reset();
+            const plan = planTiledMount(d);
+            this.realLevels = plan.realLevels;
+            this.isMultiChannel = plan.multiChannel;
             this.cache.clearChannelGroups();
+            this.destroyViewer();
             // 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.)
+            // defaulting to full range; the user auto/edits each channel.) Started
+            // AFTER destroyViewer: its sampler.clear() supersedes every run in flight.
             if (this.isMultiChannel) {
-                this.sampler.computeMultiChannelHistograms(d, loaded.infoB64, loaded.z);
+                void this.sampler.computeMultiChannelHistograms(d, loaded.infoB64, loaded.z);
             }
             else {
-                this.sampler.computeImageWindow(d, loaded.infoB64, loaded.z);
+                void 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);
+            this.cache.configure(d.z ?? 1, plan.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
@@ -766,356 +364,79 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
         const tileSource = simple
             ? { type: 'image', url: loaded.url }
             : this.buildTileSource(d, loaded.infoB64, loaded.z, this.isMultiChannel ? 0 : undefined);
-        silenceOsdMultiImageAdvisory();
-        this.viewer = OSD({
+        const options = buildViewerOptions({
             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. Shared with the
-            // region overlay, which takes the wheel over while a tool is active.
-            zoomPerScroll: OSD_ZOOM_PER_SCROLL,
-            // 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,
-            // OSD's stock value, restored. DO NOT RAISE IT: the name reads like
-            // "minimum sharpness" but it is the opposite. From OSD's own
-            // TiledImage._getLevelsInterval:
-            //
-            //   highestLevel = floor( log2( currentZeroRatio / minPixelRatio ) )
-            //
-            // minPixelRatio is a floor on how small a tile pixel may shrink, and it
-            // DIVIDES into the ratio - so raising it lowers the chosen level, i.e.
-            // picks a COARSER image. OSD's own comment on the default says as much:
-            // "closer to 0 draws tiles meant for a higher zoom at this zoom".
-            //
-            // Measured on a flat 22304x24528 image (levels 697/1394/2788/5576/11152/
-            // 22304), predicted level matching actual in all nine trials:
-            //
-            //            zoom 2        zoom 8        ~1:1
-            //   1.0      1.34x up      1.34x up      1.86x up
-            //   0.5      0.67x (none)  0.67x (none)  0.93x -> full res
-            //   0.25     0.33x         0.33x         0.93x
-            //
-            // 0.5 is what gives "never upscaled below native, full resolution at 1:1".
-            // 0.25 is not better - it jumps two rungs finer and fetches ~4x the tiles
-            // for no visible gain, and tiles are not cached by the ingress.
-            minPixelRatio: 0.5,
-            // 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,
+            navigatorVisible: this.chrome.navigatorVisible,
+            smoothing: this.chrome.smoothingEnabled,
+            authHeaders: this.authHeaders,
+            sliceCount: d.z ?? 1,
+            maxSlices: this.cache.maxSlices(),
         });
-        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());
-                // Every redraw (pan/zoom animation frames, resize) — for a contributed
-                // plot mode's overlay, which has to move with the image, not after it.
-                this.viewer.addHandler('update-viewport', () => this.scheduleFrame());
-                // 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);
+        this.viewer = createViewer(options);
+        return openViewer(this.viewer, tileSource, (v) => this.onViewerOpened(v, d, simple, plotDiv));
+    }
+    /** Wire a freshly opened viewer: the region overlay, coordinate transform and
+     *  scale bar, the slice cache, the recolor pipeline, the viewport streams and
+     *  the chrome. */
+    onViewerOpened(viewer, d, simple, plotDiv) {
+        // 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(viewer, this.regionStore);
+        this.coordTransform = new OsdCoordinateTransform(viewer);
+        this.scaleBar = new OsdScaleBar(viewer, d.mppX ?? 0);
+        if (simple) {
+            // A single, self-contained image — no slice cache to seed. Its z-scrub and
+            // recomposite re-open the viewer; one persistent handler reports a failed
+            // re-open (a once-handler per scrub would pile up).
+            viewer.addHandler('open-failed', (e) => {
+                console.warn('[OSD] slice re-open failed', this.currentZ, e?.message ?? e);
             });
-            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();
-            }
+        }
+        else {
+            this.cache.adoptOpenedSlice(this.currentZ);
+        }
+        // The wand samples the *rendered viewport*, so its pixel matrix is only
+        // valid for the current view — drop it whenever the viewport changes.
+        viewer.addHandler('viewport-change', () => {
+            this.viewportPixels = null;
         });
-        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).
-     */
+        // Recolor every tile (main viewer and navigator) through the display pipeline.
+        this.recolor.attach(viewer);
+        // 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)
+            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.
+        viewer.addHandler('animation-finish', () => this.viewport.emitViewportChange());
+        // Every redraw (pan/zoom animation frames, resize) — for a contributed
+        // plot mode's overlay, which has to move with the image, not after it.
+        viewer.addHandler('update-viewport', () => this.viewport.scheduleFrame());
+        if (!simple)
+            this.cache.schedulePrefetch();
+        // Toolbar nudges, fit-to-view as the layout settles, navigator sizing.
+        this.chrome.attach(viewer, plotDiv);
+    }
+    /** The `GET /tile` source for slice `z` (one channel's, when given) — see
+     *  {@link buildOsdTileSource}. Multichannel draws off the real levels only. */
     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. */
-    /** Collapse a burst of display-state changes into ONE invalidation on the next
-     *  frame. Dragging a window slider emits per pixel of travel, and each round
-     *  restores and re-processes every tile of every channel — so the burst is both
-     *  wasted work and the race that breaks cache records (see {@link displayToken}).
-     *  The store write stays live, so the pane itself remains responsive. */
-    scheduleInvalidate() {
-        if (this.invalidateHandle !== null)
-            return; // already queued for this frame
-        const raf = typeof requestAnimationFrame === 'function'
-            ? requestAnimationFrame
-            : (cb) => setTimeout(() => cb(0), 16);
-        this.invalidateHandle = raf(() => {
-            this.invalidateHandle = null;
-            this.invalidateDisplay();
+        return buildOsdTileSource(d, {
+            api: this.api,
+            infoB64,
+            z,
+            channel,
+            realLevelsOnly: this.isMultiChannel ? this.realLevels : undefined,
         });
     }
-    invalidateDisplay() {
-        // Supersede any in-flight recolor round before restarting one (see displayToken).
-        this.displayToken++;
-        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();
-        if (this.frameRaf !== null) {
-            cancelAnimationFrame(this.frameRaf);
-            this.frameRaf = null;
-        }
-        // Tear down any active tool overlays (shared singletons).
-        this.wandTool.setMode(false);
-        this.brushTool.setMode(false);
-        this.samPointTool.setMode(false);
-        this.eraserTool.setMode(false);
+        this.viewport.cancelFrame();
+        // Tear down an armed pixel tool's overlay (zoom-to-box stays armed, as before).
+        if (this.canvasTools.activeId !== 'zoomToBox')
+            this.canvasTools.deactivate();
         if (this.overlay) {
             this.overlay.destroy();
             this.overlay = null;
@@ -1149,71 +470,29 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
         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';
-        }
+        return OVERLAY_MODES.has(mode) ? mode : 'none';
     }
     reloadAndPlot() {
         /* host re-drives plot() via the image-info stream */
     }
     reset() {
         this.destroyViewer();
+        this.simple.reset();
     }
     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);
+        this.viewport.keepViewAcrossResize();
     }
     resetAxes() {
-        this.viewer?.viewport.goHome();
+        this.viewport.goHome();
     }
     autoscale() {
-        this.viewer?.viewport.goHome();
-        this.autoscaleEvent$.next('autoscale');
+        this.viewport.goHome();
     }
     zoomIn() {
-        this.viewer?.viewport.zoomBy(1.3);
-        this.viewer?.viewport.applyConstraints();
+        this.viewport.zoomBy(1);
     }
     zoomOut() {
-        this.viewer?.viewport.zoomBy(1 / 1.3);
-        this.viewer?.viewport.applyConstraints();
+        this.viewport.zoomBy(-1);
     }
     setDragMode(mode) {
         // Rectangle/polygon drawing run on the SVG overlay; wand/eraser/zoom-box
@@ -1224,24 +503,13 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
     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). */
+    /** Show/hide the overview navigator (now, and for the next viewer). */
     setNavigatorVisible(visible) {
-        this.navigatorVisible = visible;
-        const navEl = this.viewer?.navigator?.element;
-        if (navEl)
-            navEl.style.display = visible ? '' : 'none';
+        this.chrome.setNavigatorVisible(visible);
     }
-    /** Toggle bilinear smoothing vs nearest-neighbour (crisp pixels). Stored for the
-     *  next viewer creation, and applied live (with a redraw) to a mounted viewer. */
+    /** Toggle bilinear smoothing vs nearest-neighbour (now, and for the next viewer). */
     setImageSmoothingEnabled(enabled) {
-        this.smoothingEnabled = enabled;
-        const drawer = this.viewer?.drawer;
-        if (drawer?.setImageSmoothingEnabled) {
-            drawer.setImageSmoothingEnabled(enabled);
-            this.viewer?.forceRedraw();
-        }
+        this.chrome.setImageSmoothingEnabled(enabled);
     }
     /**
      * Swap the displayed z-slice live. Slices are kept as separate tiled images in
@@ -1263,46 +531,8 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
             return;
         if (!this.viewer)
             return;
-        if (this.simpleMode) {
-            if (this.simpleMultichannel) {
-                const urls = this.simpleChannelUrls[z] ?? this.simpleChannelUrls[0];
-                if (!urls)
-                    return;
-                this.currentZ = z;
-                this.viewportPixels = null;
-                void (async () => {
-                    await this.loadSimpleChannelPlanes(urls);
-                    if (this.currentZ !== z || !this.viewer)
-                        return;
-                    this.sampler.computeSimpleMultichannelHistograms(z, this.simpleChannelPlanes);
-                    const url = await this.compositeSimpleMultichannel();
-                    if (this.currentZ !== z || !this.viewer || !url)
-                        return;
-                    this.viewer.open({ type: 'image', url });
-                })();
-                return;
-            }
-            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 });
-                void this.sampleSimpleHistogram(url, z); // re-bin the scrubbed slice
-            })
-                .catch((err) => console.warn('[OSD] slice fetch failed', err));
+        if (this.simple.active) {
+            this.simple.setZIndex(z);
             return;
         }
         if (!this.descriptor || !this.infoB64)
@@ -1321,7 +551,7 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
         return this.stackLoading$.asObservable();
     }
     getStackLoadingProgress() {
-        return this.stackLoadingProgress$.asObservable();
+        return of(0); // OSD loads a stack's slices lazily (SliceCache); no progress to report
     }
     getTrueImageSize() {
         return this.descriptor ? { width: this.descriptor.width, height: this.descriptor.height } : null;
@@ -1336,52 +566,19 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
      * 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 };
+        return readDrawerPixels(this.viewer);
     }
-    /**
-     * 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.
-     */
+    /** Image-pixel rectangle the drawer canvas (what {@link getDisplayedPixelData}
+     *  reads) currently covers — unclamped, see OsdViewportAdapter.displayedSourceRect. */
     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;
-        }
+        return this.viewport.displayedSourceRect();
     }
+    /** Snapshot the currently rendered view as a PNG (WYSIWYG) — the parallel to
+     *  Plotly's downloadImage. The drawer canvas already carries the display
+     *  settings (the recolor pipeline bakes them into the tiles); the full-resolution
+     *  stitched export is exportComposite(). */
     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');
+        saveDrawerSnapshot(this.viewer, (blob) => saveAs(blob, `${fileStem(this.currentFileName)}.png`));
     }
     setPlotType(_plotType) {
         /* OSD only renders the image type */
@@ -1392,115 +589,32 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
     resetSurfaceCamera() {
         /* 3D not supported by OSD */
     }
+    /** The router reads the autoscale event from Plotly only. */
     getAutoscaleEvent() {
-        return this.autoscaleEvent$.asObservable();
+        return EMPTY;
     }
     /** 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) */
+    getIntensitySampling() {
+        return this.viewportSource;
     }
-    /** {@link IIntensitySampling} stub — see {@link ensureIntensitySampling}. */
-    refreshIntensitySamplingForRoi(_x, _y, _width, _height, _zIndex) {
-        /* no-op: Plotly owns intensity sampling (see IIntensitySampling) */
+    /** The navigator and image smoothing (see {@link setNavigatorVisible}). */
+    getOsdViewOptions() {
+        return this.viewOptions;
     }
-    /** Compute the current viewport's image-pixel rectangle (clamped to the image)
-     *  and broadcast it. */
-    emitViewportChange() {
-        const rect = this.visibleImageRect();
-        if (rect)
-            this.viewportChange$.next(rect);
-    }
-    /** The current viewport's image-pixel rectangle, clamped to the image, or
-     *  null when there is no laid-out viewport. */
-    visibleImageRect() {
-        const vp = this.viewer?.viewport;
-        if (!vp || !this.descriptor)
-            return null;
-        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));
-            return { x, y, width, height };
-        }
-        catch {
-            return null; /* viewport not ready */
-        }
-    }
-    /** Coalesce redraws into one {@link frame$} emission per animation frame.
-     *  Skipped entirely while nothing listens. */
-    scheduleFrame() {
-        if (this.frameRaf !== null || !this.frame$.observed)
-            return;
-        this.frameRaf = requestAnimationFrame(() => {
-            this.frameRaf = null;
-            const rect = this.visibleImageRect();
-            if (rect)
-                this.frame$.next(rect);
-        });
+    /** OSD renders no volumes. */
+    getVolumeResolution() {
+        return null;
     }
-    /**
-     * The viewport a contributed plot mode draws over. One stable object per
-     * service: every method reads the CURRENT viewer, so it stays valid across a
-     * viewer rebuild and reports `isReady() === false` while none is mounted
-     * (conversions then return NaN rather than throwing).
-     */
+    /** The viewport a contributed plot mode draws over: one stable object that
+     *  always reads the current viewer (see OsdViewportAdapter.plotModeViewportFor). */
     getPlotModeViewport() {
-        if (this.plotModeViewport)
-            return this.plotModeViewport;
-        const nan = { x: NaN, y: NaN };
-        const ready = () => !!this.coordTransform?.isReady();
-        this.plotModeViewport = {
-            getOverlayContainer: () => this.getOverlayContainer(),
-            dataToClient: (x, y) => (ready() ? this.coordTransform.dataToClient(x, y) : nan),
-            clientToData: (cx, cy) => (ready() ? this.coordTransform.clientToData(cx, cy) : nan),
-            dataLengthToScreen: (len) => (ready() ? this.coordTransform.dataLengthToScreen(len) : NaN),
-            isReady: ready,
-            // Both start with the current visible rect when the viewport is ready: a mode
-            // activates after the base render has gone idle, so without it an overlay
-            // following `frame$.subscribe(redraw)` would stay blank until the next pan/zoom.
-            frame$: this.withCurrentRect(this.frame$, ready),
-            settled$: this.withCurrentRect(this.viewportChange$, ready),
-            fitBounds: (rect, options) => {
-                const viewer = this.viewer;
-                if (!viewer || !ready() || !(rect.width > 0) || !(rect.height > 0))
-                    return;
-                const vpRect = imageRectToViewport(viewer, rect.x, rect.y, rect.width, rect.height);
-                viewer.viewport.fitBoundsWithConstraints(vpRect, !!options?.immediately);
-            },
-        };
-        return this.plotModeViewport;
-    }
-    /** `source`, preceded by the current visible rect for each subscriber (when ready). */
-    withCurrentRect(source, ready) {
-        return defer(() => {
-            const rect = ready() ? this.visibleImageRect() : null;
-            return rect ? source.pipe(startWith(rect)) : source.asObservable();
-        });
+        return this.viewport.plotModeViewportFor();
     }
     /** 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
@@ -1508,439 +622,45 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
     // 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.setOptions((options ?? {}));
-    }
-    setVertexEraserMode(active) {
-        if (active) {
-            this.viewer?.setMouseNavEnabled(false); // tool takes the pointer
+    // setActiveTool and the per-tool setters run in BaseStoreVisualizer over
+    // this.canvasTools; OSD gates mouse-nav and its readback here.
+    /**
+     * Mouse-nav is off while a canvas tool holds the pointer (its drag must draw,
+     * not pan) and on otherwise — also when a region draw mode is armed on the
+     * overlay, as the old per-tool fan-out left it (its setZoomToBoxMode(false)
+     * re-enabled nav after the overlay's setMode). A pixel tool samples the
+     * rendered viewport, read back lazily on first use.
+     */
+    beforeToolChange(next) {
+        this.viewer?.setMouseNavEnabled(next === null);
+        if (next !== null && next !== 'zoomToBox')
             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);
+        return true;
     }
-    /** Box-prompted SAM: segment the drawn rectangles. The SAM tool reuses the
-     *  wand host (viewport readback + coordinate transform + region store). */
+    /** Box-prompted SAM: segment the drawn rectangles against our tool 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();
+        return this.samTool.segmentBoxes(this.toolHost);
     }
     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);
+        return this.cellSegmentTool.segmentBoxes(this.toolHost, 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.
-     */
+    /** The pixel tools' frame: the rendered viewport, read back once and cached
+     *  until the viewport changes (see readbackViewportFrame). */
     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 token = this.displayToken;
-        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
-        // A newer display round has already restored this tile — writing now would
-        // hand OSD a superseded canvas and destroy the cache record.
-        if (token !== this.displayToken)
-            return;
-        ctx.putImageData(img, 0, 0);
-        // The tile's cache can still be evicted between the awaits above and here (a
-        // slice change), 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 token = this.displayToken;
-        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;
-        // A newer display round (the next tick of a slider drag) has already restored
-        // this tile. Writing a superseded context back makes OSD's conversion throw
-        // DOMException, which destroys the cache record and unloads the tile — do
-        // nothing and let the newer round repaint it.
-        if (token !== this.displayToken)
-            return;
-        ctx.putImageData(img, 0, 0);
-        // See recolorTile: the tile cache can still die between the awaits and here.
-        try {
-            await event.setData(ctx, 'context2d');
-        }
-        catch { /* tile evicted */ }
+        return (this.viewportPixels ??= readbackViewportFrame(this.viewer));
     }
     /** 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
@@ -1974,100 +694,34 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
     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);
-        }
+        const states = this.recolor.channelStates;
+        const visible = states.filter((c) => c.visible).map((c) => c.index);
+        const url = exportTiffUrl(this.api, this.infoB64, this.currentZ, visible, states.length);
+        const saveName = exportTiffFilename(this.currentFileName);
+        const blob = await fetchTiffExport(this.http, url);
+        if (blob)
+            saveAs(blob, saveName);
     }
     /**
      * 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.
+     * active display settings, the way it is drawn (see renderCompositePng).
      */
     async exportComposite() {
-        const desc = this.descriptor;
-        const levels = desc?.levels ?? [];
-        if (!desc || !this.infoB64 || !levels.length)
+        if (!this.descriptor)
             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;
+        const blob = await renderCompositePng({
+            http: this.http,
+            api: this.api,
+            descriptor: this.descriptor,
+            infoB64: this.infoB64,
+            z: this.currentZ,
+            multiChannel: this.isMultiChannel,
+            realLevels: this.realLevels,
+            channelStates: this.recolor.channelStates,
+            display: this.recolor.display,
+        });
+        if (blob)
+            saveAs(blob, `${fileStem(this.currentFileName)}_composite.png`);
     }
     // ── IDisplayOptions ──────────────────────────────────────────────────
     // Inherited from BaseStoreVisualizer — pure delegations to the shared
@@ -2076,19 +730,13 @@ export class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
     // colormap subscription), not in setColormap.
     // ── IVisualizer ──────────────────────────────────────────────────────
     unsubscribe() {
-        this.colormapSub?.unsubscribe();
-        this.colormapSub = null;
-        // Drop a queued invalidation so it can't fire against a torn-down viewer.
-        if (this.invalidateHandle !== null) {
-            if (typeof cancelAnimationFrame === 'function')
-                cancelAnimationFrame(this.invalidateHandle);
-            else
-                clearTimeout(this.invalidateHandle);
-            this.invalidateHandle = null;
-        }
+        // The store subscription, and a queued invalidation that must not fire
+        // against a torn-down viewer.
+        this.recolor.unsubscribe();
         this.destroyViewer();
+        this.simple.reset();
     }
-    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.ɵ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.WandService }, { token: i3.SamToolService }, { token: i4.SamPointToolService }, { token: i5.CellSegmentToolService }, { token: CELL_SEGMENTER, optional: true }, { token: i6.VisualizerStore }, { token: i7.RegionStore }, { token: i8.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: [{
@@ -2097,13 +745,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
         }], 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: i2.WandService }, { type: i3.SamToolService }, { type: i4.SamPointToolService }, { type: i5.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: i6.VisualizerStore }, { type: i7.RegionStore }, { type: i8.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, defer, firstValueFrom, of } from 'rxjs';\nimport { startWith, timeout } from 'rxjs/operators';\nimport { Image } from 'image-js';\nimport * as OpenSeadragon from 'openseadragon';\nimport { OSD } from './osd-lib';\nimport { OSD_ZOOM_PER_SCROLL } from './osd-zoom';\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 { PlotModeRect, PlotModeViewport } from '../../contracts/plot-type-contribution.contract';\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  /** SERVERLESS multichannel (tiled:false + channelCount>1): the stack's\n   *  per-slice per-channel plane URLs, the current slice's decoded planes, and\n   *  the last composite blob URL. Composited client-side via display.channelRgbLut\n   *  (no tile server); kept OFF the tiled isMultiChannel path. */\n  private simpleMultichannel = false;\n  private simpleChannelUrls: string[][] = [];\n  private simpleChannelPlanes: Array<{ data: Uint8ClampedArray; width: number; height: number }> = [];\n  private simpleCompositeUrl: string | null = null;\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: OsdCoordinateTransform | 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  /** Bumped by every display invalidation. A recolor round captures it and, after\n   *  each `await`, abandons the tile once a newer round has started. Writing a\n   *  superseded context back is not merely wasted work: OSD's conversion sees a\n   *  canvas the newer round already replaced, throws `DOMException`, and\n   *  `_handleConversionError` DESTROYS the cache record and unloads the tile\n   *  (unlike the drawer's rasterBlob path, it does not re-prepare). Enough of\n   *  those and the viewer goes white mid-drag. */\n  private displayToken = 0;\n  /** Pending coalesced invalidation (see {@link scheduleInvalidate}). */\n  private invalidateHandle: number | 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  /** The visible rect on every redraw, coalesced to one emission per animation\n   *  frame. Feeds {@link PlotModeViewport.frame$}. */\n  private readonly frame$ = new Subject<PlotModeRect>();\n  private frameRaf: number | null = null;\n  private plotModeViewport: PlotModeViewport | null = null;\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      // Serverless multichannel: re-composite the current slice from its cached\n      // planes with the new channel states + re-open (no tile-invalidate path).\n      if (this.simpleMultichannel) { void this.recompositeAndOpen(); return; }\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. Coalesced: PrimeNG's slider fires (onChange) continuously, so\n      // a single drag would otherwise queue dozens of overlapping restore +\n      // re-process rounds over every channel image.\n      this.scheduleInvalidate();\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 meta = imageInfo.imageMeta?.[0];\n    // SERVERLESS MULTICHANNEL: composite the slice's per-channel planes\n    // client-side (no tile server), driven by the channel pane. Kept OFF the\n    // tiled isMultiChannel path (see compositeSimpleMultichannel).\n    const chUrls = imageInfo.channelUrls;\n    this.simpleMultichannel = !!chUrls?.length && (meta?.channelCount ?? 1) > 1;\n    let url: string | undefined;\n    if (this.simpleMultichannel) {\n      this.simpleChannelUrls = chUrls as string[][];\n      try {\n        await this.loadSimpleChannelPlanes(chUrls![z] ?? chUrls![0]);\n        url = await this.compositeSimpleMultichannel();\n        // NB: histograms are binned in plot(), AFTER destroyViewer clears the\n        // sampler — computing them here would be wiped by that clear.\n      } catch (err) {\n        console.warn('[OSD] simple multichannel composite failed', err);\n      }\n    } else {\n      this.simpleChannelUrls = [];\n      this.simpleChannelPlanes = [];\n      const rawUrl = this.simpleStack.urlFor(imageInfo, z);\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    }\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', filename);\n      return { descriptor: null, infoB64: '', z, filename };\n    }\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  /** Sample a SIMPLE-mode slice's own decoded pixels into the histogram — the\n   *  serverless analog of the tiled samplers (no tile server). Fire-and-forget;\n   *  a decode failure just leaves the pane empty rather than throwing. */\n  private async sampleSimpleHistogram(url: string | undefined, z: number): Promise<void> {\n    if (!url) return;\n    try {\n      const img = await this.loadImageEl(url);\n      const w = img.naturalWidth, h = img.naturalHeight;\n      if (!w || !h) return;\n      const c = document.createElement('canvas');\n      c.width = w; c.height = h;\n      const ctx = c.getContext('2d', { willReadFrequently: true });\n      if (!ctx) return;\n      ctx.drawImage(img, 0, 0);\n      const data = ctx.getImageData(0, 0, w, h).data;\n      this.sampler.computeSimpleHistogram(z, data, this.isGrayscaleImage);\n    } catch (err) {\n      console.warn('[OSD] simple-mode histogram sample failed', err);\n    }\n  }\n\n  /** Fetch + decode a slice's per-channel planes (single-band grayscale) into\n   *  pixel buffers, for the SERVERLESS multichannel compositor. Auth-safe: goes\n   *  through SimpleSliceAccessService (blob:/data: as-is; http via HttpClient). */\n  private async loadSimpleChannelPlanes(urls: string[] | undefined): Promise<void> {\n    const planes: Array<{ data: Uint8ClampedArray; width: number; height: number }> = [];\n    for (const u of urls ?? []) {\n      try {\n        const previewUrl = await this.simpleStack.fetchAsBlobUrl(u);\n        const img = await this.loadImageEl(previewUrl);\n        const w = img.naturalWidth, h = img.naturalHeight;\n        if (!w || !h) { planes.push({ data: new Uint8ClampedArray(0), width: 0, height: 0 }); continue; }\n        const c = document.createElement('canvas');\n        c.width = w; c.height = h;\n        const ctx = c.getContext('2d', { willReadFrequently: true });\n        if (!ctx) { planes.push({ data: new Uint8ClampedArray(0), width: 0, height: 0 }); continue; }\n        ctx.drawImage(img, 0, 0);\n        planes.push({ data: ctx.getImageData(0, 0, w, h).data, width: w, height: h });\n      } catch (err) {\n        console.warn('[OSD] channel plane decode failed', err);\n        planes.push({ data: new Uint8ClampedArray(0), width: 0, height: 0 });\n      }\n    }\n    this.simpleChannelPlanes = planes;\n  }\n\n  /** Composite the cached per-channel planes into ONE RGBA image using the\n   *  current channel states (colour/window/gamma/visibility) — the client-side,\n   *  serverless analog of the tiled per-channel 'lighter' compositor\n   *  (same display.channelRgbLut math as recolorChannelTile, applied per-plane).\n   *  Returns a blob: URL of the composite PNG, revoking the previous one. */\n  private async compositeSimpleMultichannel(): Promise<string | undefined> {\n    const planes = this.simpleChannelPlanes;\n    if (!planes.length) return undefined;\n    const w = planes[0].width, h = planes[0].height;\n    if (!w || !h) return undefined;\n    const states = this.store.currentChannelStates();\n    const out = new Uint8ClampedArray(w * h * 4);\n    for (let c = 0; c < planes.length; c++) {\n      const st = states[c];\n      if (st && st.visible === false) continue; // hidden channel contributes nothing\n      const plane = planes[c];\n      if (plane.width !== w || plane.height !== h || !plane.data.length) continue;\n      const { r, g, b } = this.display.channelRgbLut(st);\n      const pd = plane.data;\n      for (let i = 0; i < out.length; i += 4) {\n        if (pd[i + 3] === 0) continue;\n        const lum = pd[i]; // single-band plane (R=G=B)\n        out[i] += r[lum];          // Uint8ClampedArray clamps → additive ('lighter')\n        out[i + 1] += g[lum];\n        out[i + 2] += b[lum];\n      }\n    }\n    for (let i = 3; i < out.length; i += 4) out[i] = 255; // opaque\n    const canvas = document.createElement('canvas');\n    canvas.width = w; canvas.height = h;\n    const ctx = canvas.getContext('2d');\n    if (!ctx) return undefined;\n    ctx.putImageData(new ImageData(out, w, h), 0, 0);\n    const blob = await new Promise<Blob | null>((res) => canvas.toBlob(res, 'image/png'));\n    if (!blob) return undefined;\n    if (this.simpleCompositeUrl) URL.revokeObjectURL(this.simpleCompositeUrl);\n    this.simpleCompositeUrl = URL.createObjectURL(blob);\n    return this.simpleCompositeUrl;\n  }\n\n  /** Re-composite the current slice from its cached planes (new channel states)\n   *  and re-open — the serverless analog of the tiled invalidate-on-channel-change. */\n  private async recompositeAndOpen(): Promise<void> {\n    const url = await this.compositeSimpleMultichannel();\n    if (!url || !this.viewer) return;\n    try { this.viewer.open({ type: 'image', url } as any); } catch { /* viewer gone */ }\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    if (this.simpleCompositeUrl) { URL.revokeObjectURL(this.simpleCompositeUrl); this.simpleCompositeUrl = null; }\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      // Serverless histogram — AFTER destroyViewer (its last act is sampler.clear()).\n      // Multichannel bins each cached channel plane; single-band / RGB bins the\n      // decoded frame's own pixels.\n      if (this.simpleMultichannel) {\n        this.sampler.computeSimpleMultichannelHistograms(loaded.z, this.simpleChannelPlanes);\n      } else {\n        void this.sampleSimpleHistogram(loaded.url, loaded.z);\n      }\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. Shared with the\n      // region overlay, which takes the wheel over while a tool is active.\n      zoomPerScroll: OSD_ZOOM_PER_SCROLL,\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      // OSD's stock value, restored. DO NOT RAISE IT: the name reads like\n      // \"minimum sharpness\" but it is the opposite. From OSD's own\n      // TiledImage._getLevelsInterval:\n      //\n      //   highestLevel = floor( log2( currentZeroRatio / minPixelRatio ) )\n      //\n      // minPixelRatio is a floor on how small a tile pixel may shrink, and it\n      // DIVIDES into the ratio - so raising it lowers the chosen level, i.e.\n      // picks a COARSER image. OSD's own comment on the default says as much:\n      // \"closer to 0 draws tiles meant for a higher zoom at this zoom\".\n      //\n      // Measured on a flat 22304x24528 image (levels 697/1394/2788/5576/11152/\n      // 22304), predicted level matching actual in all nine trials:\n      //\n      //            zoom 2        zoom 8        ~1:1\n      //   1.0      1.34x up      1.34x up      1.86x up\n      //   0.5      0.67x (none)  0.67x (none)  0.93x -> full res\n      //   0.25     0.33x         0.33x         0.93x\n      //\n      // 0.5 is what gives \"never upscaled below native, full resolution at 1:1\".\n      // 0.25 is not better - it jumps two rungs finer and fetches ~4x the tiles\n      // for no visible gain, and tiles are not cached by the ingress.\n      minPixelRatio: 0.5,\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        // Every redraw (pan/zoom animation frames, resize) — for a contributed\n        // plot mode's overlay, which has to move with the image, not after it.\n        this.viewer!.addHandler('update-viewport', () => this.scheduleFrame());\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  /** Collapse a burst of display-state changes into ONE invalidation on the next\n   *  frame. Dragging a window slider emits per pixel of travel, and each round\n   *  restores and re-processes every tile of every channel — so the burst is both\n   *  wasted work and the race that breaks cache records (see {@link displayToken}).\n   *  The store write stays live, so the pane itself remains responsive. */\n  private scheduleInvalidate(): void {\n    if (this.invalidateHandle !== null) return; // already queued for this frame\n    const raf =\n      typeof requestAnimationFrame === 'function'\n        ? requestAnimationFrame\n        : (cb: FrameRequestCallback) => setTimeout(() => cb(0), 16) as unknown as number;\n    this.invalidateHandle = raf(() => {\n      this.invalidateHandle = null;\n      this.invalidateDisplay();\n    });\n  }\n\n  private invalidateDisplay(): void {\n    // Supersede any in-flight recolor round before restarting one (see displayToken).\n    this.displayToken++;\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    if (this.frameRaf !== null) {\n      cancelAnimationFrame(this.frameRaf);\n      this.frameRaf = null;\n    }\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      if (this.simpleMultichannel) {\n        const urls = this.simpleChannelUrls[z] ?? this.simpleChannelUrls[0];\n        if (!urls) return;\n        this.currentZ = z;\n        this.viewportPixels = null;\n        void (async () => {\n          await this.loadSimpleChannelPlanes(urls);\n          if (this.currentZ !== z || !this.viewer) return;\n          this.sampler.computeSimpleMultichannelHistograms(z, this.simpleChannelPlanes);\n          const url = await this.compositeSimpleMultichannel();\n          if (this.currentZ !== z || !this.viewer || !url) return;\n          this.viewer.open({ type: 'image', url } as any);\n        })();\n        return;\n      }\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          void this.sampleSimpleHistogram(url, z); // re-bin the scrubbed slice\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 rect = this.visibleImageRect();\n    if (rect) this.viewportChange$.next(rect);\n  }\n\n  /** The current viewport's image-pixel rectangle, clamped to the image, or\n   *  null when there is no laid-out viewport. */\n  private visibleImageRect(): PlotModeRect | null {\n    const vp: any = this.viewer?.viewport;\n    if (!vp || !this.descriptor) return null;\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      return { x, y, width, height };\n    } catch {\n      return null; /* viewport not ready */\n    }\n  }\n\n  /** Coalesce redraws into one {@link frame$} emission per animation frame.\n   *  Skipped entirely while nothing listens. */\n  private scheduleFrame(): void {\n    if (this.frameRaf !== null || !this.frame$.observed) return;\n    this.frameRaf = requestAnimationFrame(() => {\n      this.frameRaf = null;\n      const rect = this.visibleImageRect();\n      if (rect) this.frame$.next(rect);\n    });\n  }\n\n  /**\n   * The viewport a contributed plot mode draws over. One stable object per\n   * service: every method reads the CURRENT viewer, so it stays valid across a\n   * viewer rebuild and reports `isReady() === false` while none is mounted\n   * (conversions then return NaN rather than throwing).\n   */\n  getPlotModeViewport(): PlotModeViewport {\n    if (this.plotModeViewport) return this.plotModeViewport;\n    const nan = { x: NaN, y: NaN };\n    const ready = () => !!this.coordTransform?.isReady();\n    this.plotModeViewport = {\n      getOverlayContainer: () => this.getOverlayContainer(),\n      dataToClient: (x, y) => (ready() ? this.coordTransform!.dataToClient(x, y) : nan),\n      clientToData: (cx, cy) => (ready() ? this.coordTransform!.clientToData(cx, cy) : nan),\n      dataLengthToScreen: (len) => (ready() ? this.coordTransform!.dataLengthToScreen(len) : NaN),\n      isReady: ready,\n      // Both start with the current visible rect when the viewport is ready: a mode\n      // activates after the base render has gone idle, so without it an overlay\n      // following `frame$.subscribe(redraw)` would stay blank until the next pan/zoom.\n      frame$: this.withCurrentRect(this.frame$, ready),\n      settled$: this.withCurrentRect(this.viewportChange$, ready),\n      fitBounds: (rect, options) => {\n        const viewer = this.viewer;\n        if (!viewer || !ready() || !(rect.width > 0) || !(rect.height > 0)) return;\n        const vpRect = imageRectToViewport(viewer, rect.x, rect.y, rect.width, rect.height);\n        viewer.viewport.fitBoundsWithConstraints(vpRect, !!options?.immediately);\n      },\n    };\n    return this.plotModeViewport;\n  }\n\n  /** `source`, preceded by the current visible rect for each subscriber (when ready). */\n  private withCurrentRect(source: Subject<PlotModeRect>, ready: () => boolean): Observable<PlotModeRect> {\n    return defer(() => {\n      const rect = ready() ? this.visibleImageRect() : null;\n      return rect ? source.pipe(startWith(rect)) : source.asObservable();\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.setOptions((options ?? {}) as BrushOptions);\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 token = this.displayToken;\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    // A newer display round has already restored this tile — writing now would\n    // hand OSD a superseded canvas and destroy the cache record.\n    if (token !== this.displayToken) return;\n    ctx.putImageData(img, 0, 0);\n    // The tile's cache can still be evicted between the awaits above and here (a\n    // slice change), making setData throw a DOMException on a dead canvas.\n    // 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 token = this.displayToken;\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    // A newer display round (the next tick of a slider drag) has already restored\n    // this tile. Writing a superseded context back makes OSD's conversion throw\n    // DOMException, which destroys the cache record and unloads the tile — do\n    // nothing and let the newer round repaint it.\n    if (token !== this.displayToken) return;\n    ctx.putImageData(img, 0, 0);\n    // See recolorTile: the tile cache can still 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    // Drop a queued invalidation so it can't fire against a torn-down viewer.\n    if (this.invalidateHandle !== null) {\n      if (typeof cancelAnimationFrame === 'function') cancelAnimationFrame(this.invalidateHandle);\n      else clearTimeout(this.invalidateHandle as unknown as ReturnType<typeof setTimeout>);\n      this.invalidateHandle = null;\n    }\n    this.destroyViewer();\n  }\n}\n"]}
+//# 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, EMPTY, Observable, of } from 'rxjs';\nimport { Image } from 'image-js';\nimport * as OpenSeadragon from 'openseadragon';\nimport { buildViewerOptions } from './openseadragon-viewer-options';\nimport { createViewer, openViewer } from './osd-viewer-mount';\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 {\n  IViewerBackend,\n  PixelData,\n  IIsosurfaceControls,\n  IIntensityControls,\n  ISurface3dControls,\n  IOsdViewOptions,\n  IIntensityViewportSource,\n} 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 { OsdViewportAdapter } from './osd-viewport';\nimport { OsdNavigatorChrome } from './osd-navigator-chrome';\nimport { PlotModeViewport } from '../../contracts/plot-type-contribution.contract';\nimport { elementToImage } from './osd-coords';\nimport { buildOsdTileSource, planTiledMount } from './osd-tile-source';\nimport { SliceCache } from './slice-cache';\nimport { OsdTileRecolorer } from './tile-recolor';\nimport { OsdLoaded, OsdSimpleSource } from './simple-source';\nimport { readDrawerPixels, readbackViewportFrame, saveDrawerSnapshot } from './osd-pixel-readback';\nimport { fetchTiffExport, fileStem, renderCompositePng } from './osd-export';\nimport { HistogramSampler } from './histogram-sampler';\nimport {\n  TileDescriptor,\n  exportTiffFilename,\n  exportTiffUrl,\n  httpFetchJson,\n  pollDescriptor,\n  throwIfAborted,\n  tilesInfoUrl,\n} from '../tile-server';\nimport { BaseStoreVisualizer } from '../base-store-visualizer';\nimport { CanvasToolId } from '../../contracts/display-types';\nimport { SimpleSliceAccessService } from '../simple-slice-access.service';\nimport { CachedImageData, CanvasToolHost } from '../../toolbar/tool-kit/canvas-tool';\nimport { CanvasToolManager } from '../../toolbar/tool-kit/canvas-tool-manager';\nimport { createCanvasToolManager } from '../../toolbar/canvas-tools';\nimport { WandService } from '../../toolbar/wand/wand.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 { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { saveAs } from 'file-saver';\n\n/** Wait between two `/tiles/info` polls while the server answers 202. */\nconst OSD_TILES_INFO_POLL_INTERVAL_MS = 1500;\n\n/** The drag modes the SVG region overlay handles itself (see setDragMode). */\nconst OVERLAY_MODES = new Set<RegionToolMode>([\n  'drawrect',\n  'drawclosedpath',\n  'drawopenpath',\n  'drawpolygon',\n  'addpoint',\n  'deletepoint',\n  'move',\n  'select',\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), or — for a `tiled: false` image — by\n * self-contained per-slice URLs. 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 * Display settings (window/gamma/colormap/invert, per-channel tints) are applied\n * client-side by recoloring tiles; regions are drawn by {@link OsdRegionOverlay}\n * and the canvas tools read back the rendered viewport. The collaborators\n * (slice cache, display pipeline, histogram sampler, tile client) and the\n * recolor invariant are described in this folder's README.\n */\n@Injectable({ providedIn: 'root' })\nexport class OpenSeadragonVisualizerService extends BaseStoreVisualizer implements IViewerBackend {\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  private coordTransform: OsdCoordinateTransform | null = null;\n  /** What this backend's canvas tools read and write (one host for every tool). */\n  private readonly toolHost: CanvasToolHost;\n  /** This backend's own wand, brush, eraser, zoom-to-box and SAM point tools. */\n  protected readonly canvasTools: CanvasToolManager;\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  /** Only grayscale images get a colormap (RGB tiles pass through untouched). */\n  private isGrayscaleImage = false;\n  /** True for multichannel fluorescence drawn per channel: one single-band\n   *  TiledImage per channel, tinted by the recolorer (see planTiledMount). */\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  /** 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  /** Navigator, smoothing, initial fit and the toolbar repaint workaround\n   *  (see OsdNavigatorChrome). */\n  private readonly chrome = new OsdNavigatorChrome({\n    viewer: () => this.viewer,\n    plotDiv: () => this.plotDiv,\n  });\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. Generous because each poll is cheap; on expiry the router\n   *  falls back to Plotly. (napari-js waits less — it falls back to a single tile.) */\n  private readonly tilesInfoTimeoutMs = 600000; // 10 min\n\n  /** Window/gamma/colormap/invert and per-channel tints, applied to the tiles\n   *  through OSD's pixel pipeline (see OsdTileRecolorer and the README's recolor\n   *  invariant). Its DisplayPipeline also drives the compositor and the export. */\n  private readonly recolor: OsdTileRecolorer = new OsdTileRecolorer(\n    {\n      viewer: () => this.viewer,\n      isGrayscale: () => this.isGrayscaleImage,\n      isMultiChannel: () => this.isMultiChannel,\n      isSimpleMultichannel: () => this.simple.multichannel,\n      currentZ: () => this.currentZ,\n      revealChannelSlice: (z) => this.cache.revealChannelSlice(z),\n      invalidateChannelDisplay: (z) => this.cache.invalidateChannelDisplay(z),\n      recomposite: (token) => void this.simple.recompositeAndOpen(token),\n    },\n    this.store,\n  );\n\n  /** The serverless (`tiled: false`) image source and all its state (see\n   *  OsdSimpleSource). */\n  private readonly simple: OsdSimpleSource = new OsdSimpleSource(\n    {\n      viewer: () => this.viewer,\n      descriptor: () => this.descriptor,\n      isGrayscale: () => this.isGrayscaleImage,\n      currentZ: () => this.currentZ,\n      setCurrentZ: (z) => {\n        this.currentZ = z;\n        this.viewportPixels = null; // the readback is slice-specific\n      },\n      sampler: () => this.sampler,\n      display: () => this.recolor.display,\n      channelStates: () => this.store.currentChannelStates(),\n      isCurrentDisplay: (token) => this.recolor.isCurrent(token),\n      scheduleInvalidate: () => this.recolor.scheduleInvalidate(),\n    },\n    this.simpleStack,\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). */\n  private readonly cache: SliceCache = 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.recolor.channelStates.length || (this.descriptor?.channels ?? 1)),\n    channelVisible: (c: number) => this.recolor.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    wandService: WandService,\n    private samTool: SamToolService,\n    private samPointTool: SamPointToolService,\n    private cellSegmentTool: CellSegmentToolService,\n    @Optional() @Inject(CELL_SEGMENTER) private cellSegmenter: ICellSegmenter | null,\n    store: VisualizerStore,\n    regionStore: RegionStore,\n    private simpleStack: SimpleSliceAccessService,\n    @Inject(VIZ_CONFIG) config: VizConfig,\n  ) {\n    super(regionStore, store);\n    // The canvas tools run over OSD through the shared coordinate transform and a\n    // viewport readback, and read/write the shared RegionStore. This backend owns\n    // its own tool instances (RT-21); the host reads live state, so it is built once.\n    this.toolHost = {\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      // Zoom-to-box: overlay pixels -> image coords, and fit the viewport to the box.\n      pixelToData: (px, py) => elementToImage(this.viewer!, px, py),\n      applyZoomToBox: (coords) => this.viewport.applyZoomToBox(coords),\n    };\n    this.canvasTools = createCanvasToolManager(this.toolHost, {\n      wandService,\n      regionStore,\n      samPoint: samPointTool,\n    });\n    this.api = config.slideCropServer;\n    this.sampler = new HistogramSampler(this.http, this.api, {\n      realLevels: () => this.realLevels,\n      channelCount: (d) => this.recolor.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      // Background-preloaded slices are sampled too (histograms per slice), but\n      // only the displayed slice's window may seed or re-invalidate the display.\n      onGrayWindowSampled: (min, max, z) => {\n        if (z === this.currentZ) this.recolor.seedGrayWindow(min, max);\n      },\n    });\n    this.recolor.ensureSubscription();\n  }\n\n  private readonly stackLoading$ = new BehaviorSubject<boolean>(false);\n  /** The viewport as the library sees it: visible rects, the plot-mode\n   *  viewport, zoom/fit (see OsdViewportAdapter). */\n  private readonly viewport = new OsdViewportAdapter({\n    viewer: () => this.viewer,\n    descriptor: () => this.descriptor,\n    coordTransform: () => this.coordTransform,\n    overlayContainer: () => this.getOverlayContainer(),\n  });\n  // Region state (regions, selection, the update event) lives in the shared\n  // RegionStore; image metadata and classification colours in the shared\n  // VisualizerStore — the inherited IRegionStore/display methods delegate there.\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   * `signal` (the host's render supersession) cancels the `/tiles/info` poll and\n   * the simple-image fetches: the load then rejects with an `AbortError`.\n   */\n  async load(imageInfo: IImageInfo, zIndex: number, signal?: AbortSignal): Promise<OsdLoaded> {\n    throwIfAborted(signal);\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.simple.revokeUrls();\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      this.authHeaders = {};\n      return this.simple.load(imageInfo, zIndex, signal);\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    throwIfAborted(signal);\n    // Poll /tiles/info (the shared jit-service client): the backend returns 202\n    // while the source file is still being cached (GCS->PVC) — it kicks the\n    // download off in the background, so each request is short (no long-held\n    // connection to trip ingress/proxy or client timeouts), and 200 with the\n    // descriptor once it's ready. The cache-progress overlay shows progress\n    // during the wait. Transport failures (a proxy hiccup, a slow metadata read\n    // timing a request out) are retried until the deadline; a non-202 status\n    // means this server won't describe the file.\n    //\n    // No descriptor (deadline, or a status other than 202) is a load failure, so\n    // the router falls back to Plotly for this image, as before. Not committed to\n    // `this.descriptor` here: the previous image stays mounted (and keeps using\n    // its own descriptor) until plot().\n    const descriptor = await pollDescriptor(httpFetchJson(this.http), tilesInfoUrl(this.api, infoB64), {\n      deadlineMs: this.tilesInfoTimeoutMs,\n      intervalMs: OSD_TILES_INFO_POLL_INTERVAL_MS,\n      signal,\n      tag: '[OSD]',\n    });\n    if (!descriptor) throw new Error('tiles/info gave no descriptor — file still caching or not tileable');\n    return { descriptor, infoB64, z: zIndex || 0, filename };\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.recolor.ensureSubscription();\n    // A new image: a stroke or SAM prompt in progress belonged to the old one.\n    if (!inPlace) this.canvasTools.resetAll();\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      this.simple.refreshInPlace(loaded, imageInfo);\n      return Promise.resolve(true);\n    }\n    this.plotDiv = plotDiv;\n    this.chrome.onMount(); // the toolbar is re-located for this mount\n    this.currentFileName = imageInfo?.fileName;\n    this.descriptor = d;\n    this.infoB64 = loaded.infoB64;\n    this.currentZ = loaded.z;\n    this.simple.commit(loaded, imageInfo);\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      // Take over the composite URL and bin the histograms — AFTER destroyViewer\n      // (its last act is sampler.clear()).\n      this.simple.mount(loaded);\n    } else {\n      // A tiled image is going on screen: no simple-mode state may survive it\n      // (load() normally cleared it already; plot() is what mounts the image).\n      this.simple.reset();\n      const plan = planTiledMount(d);\n      this.realLevels = plan.realLevels;\n      this.isMultiChannel = plan.multiChannel;\n      this.cache.clearChannelGroups();\n      this.destroyViewer();\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.) Started\n      // AFTER destroyViewer: its sampler.clear() supersedes every run in flight.\n      if (this.isMultiChannel) {\n        void this.sampler.computeMultiChannelHistograms(d, loaded.infoB64, loaded.z);\n      } else {\n        void this.sampler.computeImageWindow(d, loaded.infoB64, loaded.z);\n      }\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, plan.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    const options = buildViewerOptions({\n      id: plotDiv,\n      navigatorVisible: this.chrome.navigatorVisible,\n      smoothing: this.chrome.smoothingEnabled,\n      authHeaders: this.authHeaders,\n      sliceCount: d.z ?? 1,\n      maxSlices: this.cache.maxSlices(),\n    });\n    this.viewer = createViewer(options);\n    return openViewer(this.viewer, tileSource, (v) => this.onViewerOpened(v, d, simple, plotDiv));\n  }\n\n  /** Wire a freshly opened viewer: the region overlay, coordinate transform and\n   *  scale bar, the slice cache, the recolor pipeline, the viewport streams and\n   *  the chrome. */\n  private onViewerOpened(viewer: OpenSeadragon.Viewer, d: TileDescriptor, simple: boolean, plotDiv: string): void {\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(viewer, this.regionStore);\n    this.coordTransform = new OsdCoordinateTransform(viewer);\n    this.scaleBar = new OsdScaleBar(viewer, d.mppX ?? 0);\n    if (simple) {\n      // A single, self-contained image — no slice cache to seed. Its z-scrub and\n      // recomposite re-open the viewer; one persistent handler reports a failed\n      // re-open (a once-handler per scrub would pile up).\n      viewer.addHandler('open-failed', (e) => {\n        console.warn('[OSD] slice re-open failed', this.currentZ, (e as { message?: string })?.message ?? e);\n      });\n    } else {\n      this.cache.adoptOpenedSlice(this.currentZ);\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    viewer.addHandler('viewport-change', () => {\n      this.viewportPixels = null;\n    });\n    // Recolor every tile (main viewer and navigator) through the display pipeline.\n    this.recolor.attach(viewer);\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) 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    viewer.addHandler('animation-finish', () => this.viewport.emitViewportChange());\n    // Every redraw (pan/zoom animation frames, resize) — for a contributed\n    // plot mode's overlay, which has to move with the image, not after it.\n    viewer.addHandler('update-viewport', () => this.viewport.scheduleFrame());\n    if (!simple) this.cache.schedulePrefetch();\n    // Toolbar nudges, fit-to-view as the layout settles, navigator sizing.\n    this.chrome.attach(viewer, plotDiv);\n  }\n\n  /** The `GET /tile` source for slice `z` (one channel's, when given) — see\n   *  {@link buildOsdTileSource}. Multichannel draws off the real levels only. */\n  private buildTileSource(\n    d: TileDescriptor,\n    infoB64: string,\n    z: number,\n    channel?: number,\n  ): Record<string, unknown> {\n    return buildOsdTileSource(d, {\n      api: this.api,\n      infoB64,\n      z,\n      channel,\n      realLevelsOnly: this.isMultiChannel ? this.realLevels : undefined,\n    });\n  }\n\n  private destroyViewer(): void {\n    this.cache.cancelBackgroundLoad();\n    this.viewport.cancelFrame();\n    // Tear down an armed pixel tool's overlay (zoom-to-box stays armed, as before).\n    if (this.canvasTools.activeId !== 'zoomToBox') this.canvasTools.deactivate();\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    return OVERLAY_MODES.has(mode as RegionToolMode) ? (mode as RegionToolMode) : 'none';\n  }\n\n  reloadAndPlot(): void {\n    /* host re-drives plot() via the image-info stream */\n  }\n  reset(): void {\n    this.destroyViewer();\n    this.simple.reset();\n  }\n  relayout(_trueImageSize?: number[]): void {\n    this.viewport.keepViewAcrossResize();\n  }\n  resetAxes(): void {\n    this.viewport.goHome();\n  }\n  autoscale(): void {\n    this.viewport.goHome();\n  }\n  zoomIn(): void {\n    this.viewport.zoomBy(1);\n  }\n  zoomOut(): void {\n    this.viewport.zoomBy(-1);\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 (now, and for the next viewer). */\n  setNavigatorVisible(visible: boolean): void {\n    this.chrome.setNavigatorVisible(visible);\n  }\n\n  /** Toggle bilinear smoothing vs nearest-neighbour (now, and for the next viewer). */\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.chrome.setImageSmoothingEnabled(enabled);\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.simple.active) {\n      this.simple.setZIndex(z);\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 of(0); // OSD loads a stack's slices lazily (SliceCache); no progress to report\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    return readDrawerPixels(this.viewer);\n  }\n\n  /** Image-pixel rectangle the drawer canvas (what {@link getDisplayedPixelData}\n   *  reads) currently covers — unclamped, see OsdViewportAdapter.displayedSourceRect. */\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    return this.viewport.displayedSourceRect();\n  }\n\n  /** Snapshot the currently rendered view as a PNG (WYSIWYG) — the parallel to\n   *  Plotly's downloadImage. The drawer canvas already carries the display\n   *  settings (the recolor pipeline bakes them into the tiles); the full-resolution\n   *  stitched export is exportComposite(). */\n  downloadImage(): void {\n    saveDrawerSnapshot(this.viewer, (blob) => saveAs(blob, `${fileStem(this.currentFileName)}.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  /** The router reads the autoscale event from Plotly only. */\n  getAutoscaleEvent(): Observable<any> {\n    return EMPTY;\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  getIntensitySampling(): IIntensityViewportSource {\n    return this.viewportSource;\n  }\n  private readonly viewportSource: IIntensityViewportSource = {\n    getViewportChange$: () => this.viewport.viewportChange$.asObservable(),\n  };\n\n  /** The navigator and image smoothing (see {@link setNavigatorVisible}). */\n  getOsdViewOptions(): IOsdViewOptions {\n    return this.viewOptions;\n  }\n  private readonly viewOptions: IOsdViewOptions = {\n    setNavigatorVisible: (visible) => this.setNavigatorVisible(visible),\n    setImageSmoothingEnabled: (enabled) => this.setImageSmoothingEnabled(enabled),\n  };\n\n  /** OSD renders no volumes. */\n  getVolumeResolution(): null {\n    return null;\n  }\n\n  /** The viewport a contributed plot mode draws over: one stable object that\n   *  always reads the current viewer (see OsdViewportAdapter.plotModeViewportFor). */\n  getPlotModeViewport(): PlotModeViewport {\n    return this.viewport.plotModeViewportFor();\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  // ── 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  // setActiveTool and the per-tool setters run in BaseStoreVisualizer over\n  // this.canvasTools; OSD gates mouse-nav and its readback here.\n\n  /**\n   * Mouse-nav is off while a canvas tool holds the pointer (its drag must draw,\n   * not pan) and on otherwise — also when a region draw mode is armed on the\n   * overlay, as the old per-tool fan-out left it (its setZoomToBoxMode(false)\n   * re-enabled nav after the overlay's setMode). A pixel tool samples the\n   * rendered viewport, read back lazily on first use.\n   */\n  protected override beforeToolChange(next: CanvasToolId | null): boolean {\n    this.viewer?.setMouseNavEnabled(next === null);\n    if (next !== null && next !== 'zoomToBox') this.viewportPixels = null;\n    return true;\n  }\n  /** Box-prompted SAM: segment the drawn rectangles against our tool host\n   *  (viewport readback + coordinate transform + region store). */\n  segmentRectangles(): Promise<number> {\n    this.viewportPixels = null; // segment against the current viewport readback\n    return this.samTool.segmentBoxes(this.toolHost);\n  }\n  segmentRectanglesCellpose(): Promise<number> {\n    if (!this.cellSegmenter) return Promise.resolve(0);\n    this.viewportPixels = null; // crop against the current viewport readback\n    return this.cellSegmentTool.segmentBoxes(this.toolHost, this.cellSegmenter);\n  }\n  setSamModel(id: string): void {\n    this.samTool.setModel(id);\n    this.samPointTool.setModel(id);\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  /** The pixel tools' frame: the rendered viewport, read back once and cached\n   *  until the viewport changes (see readbackViewportFrame). */\n  private readbackViewport(): CachedImageData | null {\n    return (this.viewportPixels ??= readbackViewportFrame(this.viewer));\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 states = this.recolor.channelStates;\n    const visible = states.filter((c) => c.visible).map((c) => c.index);\n    const url = exportTiffUrl(this.api, this.infoB64, this.currentZ, visible, states.length);\n    const saveName = exportTiffFilename(this.currentFileName);\n    const blob = await fetchTiffExport(this.http, url);\n    if (blob) saveAs(blob, saveName);\n  }\n\n  /**\n   * Export the current slice as a publication-ready PNG composited with the\n   * active display settings, the way it is drawn (see renderCompositePng).\n   */\n  async exportComposite(): Promise<void> {\n    if (!this.descriptor) return;\n    const blob = await renderCompositePng({\n      http: this.http,\n      api: this.api,\n      descriptor: this.descriptor,\n      infoB64: this.infoB64,\n      z: this.currentZ,\n      multiChannel: this.isMultiChannel,\n      realLevels: this.realLevels,\n      channelStates: this.recolor.channelStates,\n      display: this.recolor.display,\n    });\n    if (blob) saveAs(blob, `${fileStem(this.currentFileName)}_composite.png`);\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    // The store subscription, and a queued invalidation that must not fire\n    // against a torn-down viewer.\n    this.recolor.unsubscribe();\n    this.destroyViewer();\n    this.simple.reset();\n  }\n}\n"]}