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

package/esm2022/lib/routing-visualizer.service.mjs

@@ -1,18 +1,25 @@
 import { Inject, Injectable, Optional } from '@angular/core';
-import { EMPTY, combineLatest, merge } from 'rxjs';
+import { EMPTY, Subject, Subscription, combineLatest, merge, BehaviorSubject } from 'rxjs';
 import { map } from 'rxjs/operators';
+import { resolveColormap } from 'napari-js';
 import { PlotlyService } from './implementations/plotly/plotly.service';
 import { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';
-import { PlotType, isNapari3d, isNapariScatter, isSpatialOmics, isSpatialOmics3d, } from './contracts/plot-type';
+import { PlotType, isNapari3d, isNapariScatter, isSpatialOmics, isSpatialOmics3d, isNapariIsosurface, isNapariVolume, } from './contracts/plot-type';
 import { SPATIAL_DATA_PORT } from './contracts/ports/spatial-data.port';
 import { SpatialControlsFacade } from './spatial/spatial-controls.facade';
 import { RegionStore } from './store/region-store.service';
+import { RegionScopeCache } from './store/region-scope-cache';
+import { REGION_SOURCE_MIN_CHARS } from './region-source/region-source';
+import { openGeoJsonRegionSource } from './region-source/worker-region-source';
 import { SpatialSelectionStore } from './store/spatial-selection.service';
 import { autoWindowFromHistogram } from './contracts/intensity';
 import { VisualizerStore } from './store/visualizer-store.service';
 import { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';
+import { channelTintColormap, volumeColormap } from './implementations/napari-js/napari-display-state';
 import { VIZ_CONFIG } from './contracts/viz-config';
 import { IntensityProfileService } from './intensity/intensity-profile.service';
+import { changedClasses, classSignatures } from './store/class-signatures';
+import { VolumeSections } from './visualizer/volume-sections';
 import * as i0 from "@angular/core";
 import * as i1 from "./implementations/plotly/plotly.service";
 import * as i2 from "./implementations/osd/openseadragon-visualizer.service";
@@ -21,6 +28,8 @@ import * as i4 from "./store/visualizer-store.service";
 import * as i5 from "./store/region-store.service";
 import * as i6 from "./store/spatial-selection.service";
 import * as i7 from "./intensity/intensity-profile.service";
+/** How long after the last edit the surfaces of the classes it touched are rebuilt (ms). */
+export const REGION_SURFACE_REBUILD_MS = 600;
 /** Intensity-profile line ROIs are owned by the intensity tool, not the editor.
  *  Package-internal predicate (property-based so it also matches plain objects
  *  after a drag round-trip). */
@@ -75,6 +84,43 @@ export class RoutingVisualizerService {
         this.napariFellBack = false;
         /** The div the backends render into (every backend shares it); '' before the first plot. */
         this.plotDiv = '';
+        /** Whether a napari volume view is the current plot type. */
+        this.volumeView$ = new BehaviorSubject(false);
+        /** Whether the volume view's slice pane is wanted (see {@link setSliceEditor}). */
+        this.sliceEditor$ = new BehaviorSubject(false);
+        /** Whether the volume view draws the region reconstructions through the volume. */
+        this.regionsThroughVolume$ = new BehaviorSubject(false);
+        /** Region reconstructions built so far, by image, resolution and classes (with those classes). */
+        this.meshCache = new Map();
+        /** Bumped per {@link showRegionClasses3d} (and per new image), so only the latest one shows. */
+        this.meshRequest = 0;
+        /** The class groups shown in 3D, and the image they belong to. */
+        this.classes3d$ = new BehaviorSubject([]);
+        /** The groups last asked for in 3D, with their colours: what an edit's rebuild shows again. */
+        this.shown3d = [];
+        /**
+         * Each class's fingerprint on the live slice (see classSignatures), which image and slice, and
+         * what the region sources hold (see RegionStore.getSourceStateKey). Null while nothing follows
+         * the edits (no surface built, no sections).
+         */
+        this.liveClasses = null;
+        /** The pending rebuild of the surfaces an edit touched. */
+        this.rebuildTimer = null;
+        // ── The slice pane (the volume view's split): OSD editing one slice beside the 3D view ──
+        /** The div the slice pane renders into while it is wanted (null: no split). */
+        this.sliceDiv = null;
+        /** Whether OSD is mounted in the slice pane: region, tool and overlay calls go to it. */
+        this.sliceMounted = false;
+        /** Bumped per slice-pane mount or teardown, so only the latest one lands. */
+        this.sliceRequest = 0;
+        /** The z plane dragged in the volume: the slice to show (see {@link getSliceDrag$}). */
+        this.sliceDrag$ = new Subject();
+        this.sectionSubs = new Subscription();
+        /** The image info and screen height of the last plot (what the slice pane mounts). */
+        this.plottedInfo = null;
+        /** The current region import (see regionImportTicket): its id and the image it was taken for. */
+        this.importTicket = { id: 0, image: undefined };
+        this.plottedHeight = 0;
         this.viewOptions = {
             setNavigatorVisible: (visible) => {
                 for (const b of this.backends())
@@ -104,6 +150,57 @@ export class RoutingVisualizerService {
             },
             getViewportChange$: () => merge(...this.backends().map((b) => b.getIntensitySampling()?.getViewportChange$() ?? EMPTY)),
         };
+        this.regionUpdates = this.regionStore.getRegionUpdateEvent().subscribe(() => this.onRegionsChanged());
+        this.sections = new VolumeSections({
+            volume: () => this.napari.volumeVoxels(),
+            image: () => this.plottedFileName,
+            showPlanes: (planes) => this.napari.setSlicePlanes(planes),
+            outlinesByClass: (level) => this.regionStore.outlinesByClass(level),
+            isClassHidden: (label) => this.regionStore.isClassHidden(label),
+            colorOf: (label) => this.classColor(label),
+            channelStates: () => this.store.currentChannelStates(),
+            colormap: (st, multichannel) => {
+                // As the volume scene colours the channel (invert is applied before the colormap).
+                const display = {
+                    colormap: this.store.currentColormap(),
+                    reverse: this.store.currentReverseScale(),
+                    invert: false,
+                };
+                return resolveColormap(multichannel ? channelTintColormap(st?.color ?? '#ffffff', display) : volumeColormap(st, display));
+            },
+            invert: () => this.store.currentInvert(),
+            slice: () => this.currentZIndex,
+        });
+        // A plane dragged in the volume: the z plane picks the slice (through the host's slider, so
+        // the store and the slice pane follow), the others move their section.
+        this.sectionSubs.add(this.napari.getSlicePlaneMove$().subscribe(({ axis, value }) => {
+            if (axis === 'z')
+                this.sliceDrag$.next(Math.round(value));
+            else
+                this.sections.setPlane(axis, value);
+        }));
+        this.sectionSubs.add(this.store.getChannelStates().subscribe(() => this.sections.schedule()));
+        this.sectionSubs.add(this.store.getInvert().subscribe(() => this.sections.schedule()));
+        this.sectionSubs.add(this.store.getColormap().subscribe(() => this.sections.schedule()));
+        this.sectionSubs.add(this.store.getReverseScale().subscribe(() => this.sections.schedule()));
+    }
+    /** A class's colour: its classification colour, else its region source's, else a default. */
+    classColor(label) {
+        return (this.store.getClassificationColors().get(label) ??
+            this.regionStore.getRegionSourceView()?.colorOf({ label, color: null }) ??
+            '#ffcc00');
+    }
+    /** The sections beside the split volume view (nulls while it is not split). */
+    getSectionViews$() {
+        return this.sections.getViews$();
+    }
+    /** Move a section's plane to `at` (image px). */
+    setSectionPlane(axis, at) {
+        this.sections.setPlane(axis, at);
+    }
+    /** The slice picked by dragging the z plane in the volume: the host shows it (its slider). */
+    getSliceDrag$() {
+        return this.sliceDrag$.asObservable();
     }
     isImageType(t) {
         return t === PlotType.IMAGE;
@@ -155,6 +252,14 @@ export class RoutingVisualizerService {
     renderer() {
         return this.lastRendered ?? this.plotly;
     }
+    /**
+     * Backend region, tool and overlay calls act on: the slice pane's OSD while the volume view is
+     * split (regions are edited there), else the backend on screen. View calls (zoom, fit, colour,
+     * export) stay with {@link renderer}.
+     */
+    regionBackend() {
+        return this.sliceMounted ? this.osd : this.renderer();
+    }
     // System capabilities are Plotly's (the full-featured backend) so the UI
     // keeps offering every plot type regardless of which one is on screen.
     get capabilities() {
@@ -206,7 +311,17 @@ export class RoutingVisualizerService {
     }
     plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace) {
         this.currentPlotType = plotType;
+        this.volumeView$.next(isNapariVolume(plotType) || isNapariIsosurface(plotType));
         this.plottedFileName = imageInfo?.fileName;
+        this.plottedInfo = imageInfo ?? null;
+        this.plottedHeight = screenHeight;
+        // The slice pane belongs to the volume view: another plot type takes it down (OSD may be
+        // about to draw the main view, which must not find the pane's viewer still mounted).
+        if (!this.volumeView$.value)
+            this.unmountSlice();
+        // Region surfaces belong to the image they were built from: another image drops them.
+        if (this.classes3d$.value.length && this.plottedFileName !== this.classes3dImage)
+            this.clearRegionClasses3d();
         this.plotDiv = plotDiv;
         // Apply the per-image region cache (snapshot old regions, restore the new
         // image's, clear selection) for whichever backend renders — Plotly does
@@ -224,7 +339,74 @@ export class RoutingVisualizerService {
                 this.lastRendered.reset();
         }
         this.lastRendered = next;
-        return next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);
+        const plotted = next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);
+        if (!this.sliceDiv || !this.volumeView$.value)
+            return plotted;
+        // The split volume view: the slice pane follows the image (a new one, or its sharper pass).
+        return plotted.then((ok) => {
+            if (ok && (!this.sliceMounted || this.sliceFile !== imageInfo?.fileName || inPlace)) {
+                void this.mountSlice(!!inPlace && this.sliceMounted && this.sliceFile === imageInfo?.fileName);
+            }
+            // The volume was assembled again (another image, or resolution): cut the sections from it.
+            if (ok)
+                this.sections.schedule();
+            return ok;
+        });
+    }
+    /**
+     * Split the volume view: show the slice being edited in `div` (OpenSeadragon, with every region
+     * tool) beside the 3D view, or stop (null). Kept across re-plots of a volume view; another plot
+     * type takes the pane down and a volume view brings it back. Resolves whether the pane shows.
+     */
+    async setSliceEditor(div) {
+        this.sliceDiv = div;
+        if (this.sliceEditor$.value !== !!div)
+            this.sliceEditor$.next(!!div);
+        if (!div) {
+            this.unmountSlice();
+            return false;
+        }
+        return this.mountSlice(false);
+    }
+    /** Mount (or refresh in place) OSD in the slice pane on the displayed slice. */
+    async mountSlice(inPlace) {
+        const div = this.sliceDiv;
+        const info = this.plottedInfo;
+        if (!div || !info?.urls?.length || !this.volumeView$.value)
+            return false;
+        const request = ++this.sliceRequest;
+        try {
+            const loaded = await this.osd.load(info, this.currentZIndex);
+            if (request !== this.sliceRequest)
+                return false;
+            const ok = await this.osd.plot(div, loaded, info, this.plottedHeight, PlotType.IMAGE, inPlace);
+            if (request !== this.sliceRequest)
+                return false;
+            this.sliceMounted = ok;
+            this.sliceFile = info.fileName;
+            if (ok) {
+                // The slice may have moved while the pane loaded.
+                this.osd.setZIndex(this.currentZIndex);
+                this.trackLiveClasses();
+                this.sections.start();
+            }
+            return ok;
+        }
+        catch (err) {
+            if (request === this.sliceRequest)
+                console.warn('[visualizer] The slice pane could not show the image.', err);
+            return false;
+        }
+    }
+    /** Take the slice pane's viewer down (the split stays wanted while {@link sliceDiv} is set). */
+    unmountSlice() {
+        this.sliceRequest++;
+        if (this.sliceMounted) {
+            this.osd.reset();
+            this.sections.stop();
+        }
+        this.sliceMounted = false;
+        this.sliceFile = undefined;
     }
     reloadAndPlot() {
         this.plotly.reloadAndPlot();
@@ -257,6 +439,8 @@ export class RoutingVisualizerService {
     }
     setDragMode(mode) {
         this.renderer().setDragMode(mode);
+        if (this.sliceMounted)
+            this.osd.setDragMode(mode);
     }
     /** Every backend, on screen or not. */
     backends() {
@@ -285,6 +469,10 @@ export class RoutingVisualizerService {
     setZIndex(zIndex) {
         this.currentZIndex = zIndex;
         this.renderer().setZIndex(zIndex);
+        if (this.sliceMounted) {
+            this.osd.setZIndex(zIndex);
+            this.sections.schedule();
+        }
     }
     getTrueImageSize() {
         return this.renderer().getTrueImageSize();
@@ -306,6 +494,7 @@ export class RoutingVisualizerService {
     }
     setPlotType(plotType) {
         this.currentPlotType = plotType;
+        this.volumeView$.next(isNapariVolume(plotType) || isNapariIsosurface(plotType));
         this.plotly.setPlotType(plotType);
     }
     /** @deprecated Use `getSurface3dControls()`. */
@@ -482,6 +671,290 @@ export class RoutingVisualizerService {
     getGeoJsonString(regions) {
         return this.regionStore.getGeoJsonString(regions);
     }
+    /** Hold a large region set as a tiled region source (see RegionStore.attachRegionSource). */
+    attachRegionSource(source, slices) {
+        this.regionStore.attachRegionSource(source, slices);
+    }
+    async importRegionSource(geoJsonStr) {
+        if (geoJsonStr.length < (this.config?.regionSourceMinChars ?? REGION_SOURCE_MIN_CHARS))
+            return false;
+        let opened = await openGeoJsonRegionSource(geoJsonStr);
+        // The first open is the one just made; a source closed to save memory parses again.
+        this.regionStore.attachRegionSource(() => {
+            const source = opened;
+            opened = null;
+            return source ? Promise.resolve(source) : openGeoJsonRegionSource(geoJsonStr);
+        });
+        return true;
+    }
+    dropRegionSource() {
+        return this.regionStore.dropSliceRegionSource();
+    }
+    /**
+     * A ticket for a region import that is about to read or decode its files: the import methods
+     * given it change nothing once it is stale — another import took a ticket since, another image
+     * was plotted, or the service was destroyed — so an import that finishes late never lands on an
+     * image it was not started for.
+     */
+    regionImportTicket() {
+        this.importTicket = { id: this.importTicket.id + 1, image: this.importImageKey() };
+        return this.importTicket.id;
+    }
+    /** Whether `ticket` is still the current import's, on the image it was taken for. */
+    importTicketValid(ticket) {
+        return ticket === this.importTicket.id && this.importTicket.image === this.importImageKey();
+    }
+    importImageKey() {
+        return RegionScopeCache.imageKey(this.plottedInfo ?? undefined);
+    }
+    /**
+     * Replace the image's regions and region sources with one source per slice, as an imported label
+     * volume or folder of per-slice region files gives them: `openers` by slice index, each opened
+     * the first time its slice is shown. A single image takes slice 0's. Returns how many slices
+     * have a source, or null (changing nothing) when `ticket` is stale (see
+     * {@link regionImportTicket}). The sources are marked imported, so a save writes every slice.
+     */
+    importSliceRegionSources(openers, ticket) {
+        if (ticket !== undefined && !this.importTicketValid(ticket))
+            return null;
+        this.regionImportTicket(); // supersedes any import still in flight
+        const info = this.plottedInfo;
+        this.regionStore.detachRegionSources();
+        if (!info?.isStack) {
+            const first = openers.get(0) ?? openers.values().next().value;
+            this.regionStore.setRegions([]);
+            this.regionStore.resetUndoHistory();
+            if (!first)
+                return 0;
+            this.regionStore.attachRegionSource(first, { slice: 0 }, true);
+            return 1;
+        }
+        this.enterImportedStack(info);
+        for (const [z, open] of openers)
+            this.regionStore.attachRegionSource(open, { slice: z }, true);
+        return openers.size;
+    }
+    /**
+     * Replace the image's regions and region sources with one imported source (a region set the
+     * host's server serves): over every slice of a stack when it is z-indexed, else on the slice
+     * shown, as {@link applyImageRois} lays out an image's own. Resolves false, changing nothing
+     * (and disposing the source), when the import went stale while it opened: another import, or
+     * another image (see {@link regionImportTicket}; one is taken here when `ticket` is not given).
+     */
+    async importRegionSourceOpener(open, ticket) {
+        const mine = ticket ?? this.regionImportTicket();
+        if (!this.importTicketValid(mine))
+            return false;
+        let first = await open();
+        if (!this.importTicketValid(mine)) {
+            first.dispose();
+            return false;
+        }
+        const reuse = () => {
+            const source = first;
+            first = null;
+            return source ? Promise.resolve(source) : open();
+        };
+        const info = this.plottedInfo;
+        const planes = first.info.planes;
+        const zIndexed = !!info?.isStack && planes.some((p) => p !== 0);
+        this.regionStore.detachRegionSources();
+        if (zIndexed) {
+            this.enterImportedStack(info);
+            this.regionStore.attachRegionSource(reuse, 'planes', [...planes]);
+            return true;
+        }
+        this.regionStore.setRegions([]);
+        this.regionStore.resetUndoHistory();
+        this.regionStore.attachRegionSource(reuse, { slice: this.regionStore.getDisplaySlice() }, true);
+        return true;
+    }
+    /** Empty every slice of a stack (its regions and undo history) for regions imported over it. */
+    enterImportedStack(info) {
+        const layout = this.regionStore.isStackMode()
+            ? this.regionStore.getStackSaveLayout()
+            : info.tiled === false
+                ? 'per-slice-file'
+                : 'combined';
+        this.regionStore.enterStackMode(new Map(), this.regionStore.getDisplaySlice(), layout);
+    }
+    getRegionSourceView$() {
+        return this.regionStore.getRegionSourceView$();
+    }
+    getRegionSourceIndex(query) {
+        return this.regionStore.getRegionSourceIndex(query);
+    }
+    selectSourceFeatures(ids, additive) {
+        return this.regionStore.selectSourceFeatures(ids, additive);
+    }
+    deleteSourceFeatures(ids) {
+        this.regionStore.deleteSourceFeatures(ids);
+    }
+    getRegionStyle$() {
+        return this.regionStore.getRegionStyle$();
+    }
+    setRegionStyle(patch) {
+        this.regionStore.setRegionStyle(patch);
+    }
+    // ── Regions in 3D: their reconstructions shown in the volume view ─────
+    /** Whether a napari volume (or isosurface) view is on screen: regions can be shown in 3D. */
+    getVolumeView$() {
+        return this.volumeView$.asObservable();
+    }
+    /** Whether the volume view's slice pane is wanted (it shows while a volume view is on screen). */
+    getSliceEditor$() {
+        return this.sliceEditor$.asObservable();
+    }
+    /** Whether the volume view draws the region reconstructions through the volume. */
+    getRegionsThroughVolume$() {
+        return this.regionsThroughVolume$.asObservable();
+    }
+    /**
+     * Draw the region reconstructions through the volume (it hides none of them: surfaces inside its
+     * bright structures, an OCT's layer boundaries) or hidden behind what it shows (the default).
+     */
+    setRegionsThroughVolume(through) {
+        if (this.regionsThroughVolume$.value === through)
+            return;
+        this.regionsThroughVolume$.next(through);
+        this.napari.setRegionsThroughVolume(through);
+    }
+    /** The class groups shown in 3D on this image ([] after a switch to another image). */
+    getRegionClasses3d$() {
+        return this.classes3d$.asObservable();
+    }
+    /** Hide every region surface and forget them (a build still running is dropped). */
+    clearRegionClasses3d() {
+        this.meshRequest++;
+        this.shown3d = [];
+        this.classes3d$.next([]);
+        this.classes3dImage = undefined;
+        this.napari.setRegionMeshes([], undefined);
+        this.napari.setRegionHighlight([]);
+    }
+    /** Highlight the surfaces of these group keys in the volume view (none: all as usual). */
+    highlightRegionClasses3d(keys) {
+        this.napari.setRegionHighlight(keys);
+    }
+    /** A surface clicked in the volume view with the selection tool (its group key), or none (null). */
+    getRegionPicked3d$() {
+        return this.napari.getRegionMeshPick$();
+    }
+    /**
+     * Show these groups of classes in the volume view as 3D reconstructions (each group one surface
+     * in its colour: an atlas structure with its substructures), and only these; [] hides them.
+     * Reconstructed from every slice's outlines at the volume's resolution, cached per image.
+     */
+    async showRegionClasses3d(groups) {
+        const request = ++this.meshRequest;
+        this.classes3dImage = this.plottedFileName;
+        this.shown3d = groups;
+        // What an edit from now on is compared with (the live slice may not have changed yet).
+        this.liveClasses = null;
+        this.trackLiveClasses();
+        this.classes3d$.next(groups.map((g) => ({ key: g.key, classes: g.classes })));
+        const width = this.getTrueImageSize()?.width ?? 1024;
+        const step = this.napari.regionVoxelStep() ?? Math.max(1, width / 256);
+        const image = this.plottedFileName ?? '';
+        const cacheKey = (g) => `${image}|${step.toFixed(3)}|${g.classes.join(',')}`;
+        const missing = groups.filter((g) => !this.meshCache.has(cacheKey(g)));
+        if (missing.length) {
+            const names = missing.map((g) => g.key);
+            const what = names.length > 3 ? `${names.length} regions` : names.join(', ');
+            const done = this.napari.beginTask(`Building ${what} in 3D…`);
+            try {
+                const built = await this.regionStore.reconstructClasses(missing.map((g) => ({ key: cacheKey(g), classes: g.classes })), step);
+                const classesOf = new Map(missing.map((g) => [cacheKey(g), g.classes]));
+                for (const b of built)
+                    this.meshCache.set(b.key, { mesh: b.mesh, classes: classesOf.get(b.key) ?? [] });
+            }
+            finally {
+                done();
+            }
+        }
+        if (request !== this.meshRequest)
+            return;
+        this.napari.setRegionMeshes(groups.map((g) => {
+            const mesh = this.meshCache.get(cacheKey(g)).mesh;
+            return { key: g.key, color: g.color, label: g.label, vertices: mesh.vertices, faces: mesh.faces };
+        }), this.plottedFileName);
+    }
+    /**
+     * The regions changed: when the live slice's regions of some classes did (an edit, an undo, not
+     * a slice or image switch), their reconstructions are stale. They are dropped, and those shown
+     * in 3D are rebuilt once the edits pause.
+     */
+    onRegionsChanged() {
+        // Nothing follows the edits (no surface built or shown, no sections): skip the fingerprints.
+        if (!this.sliceMounted && !this.shown3d.length && !this.meshCache.size) {
+            this.liveClasses = null;
+            return;
+        }
+        const before = this.liveClasses;
+        this.liveClasses = null;
+        const now = this.trackLiveClasses();
+        // Another slice or image came up: no region changed (the sections recut for the slice).
+        if (!before || before.at !== now.at)
+            return;
+        const changed = changedClasses(before.signatures, now.signatures);
+        // Source features deleted (or that undone) change no live region, and which classes they were
+        // is not known here: every class is stale. A feature taken shows as its class's change.
+        const everyClass = !changed.size && before.sources !== now.sources;
+        if (!changed.size && !everyClass)
+            return;
+        const touched = (c) => everyClass || changed.has(c);
+        if (this.sliceMounted)
+            this.sections.regionsChanged();
+        for (const [key, entry] of [...this.meshCache]) {
+            if (entry.classes.some(touched))
+                this.meshCache.delete(key);
+        }
+        if (!this.shown3d.some((g) => g.classes.some(touched)))
+            return;
+        if (this.rebuildTimer)
+            clearTimeout(this.rebuildTimer);
+        this.rebuildTimer = setTimeout(() => {
+            this.rebuildTimer = null;
+            if (this.shown3d.length && this.classes3dImage === this.plottedFileName) {
+                void this.showRegionClasses3d(this.shown3d);
+            }
+        }, REGION_SURFACE_REBUILD_MS);
+    }
+    /** Fingerprint the live slice's classes, unless already: what the next edit is compared with. */
+    trackLiveClasses() {
+        this.liveClasses ??= {
+            at: this.liveSliceKey(),
+            signatures: classSignatures(this.regionStore.getRegions()),
+            sources: this.regionStore.getSourceStateKey(),
+        };
+        return this.liveClasses;
+    }
+    /** Which slice of which image the live regions are. */
+    liveSliceKey() {
+        return `${this.regionStore.getDisplaySlice()}\n${this.plottedFileName ?? ''}`;
+    }
+    /** Each class's volume over the whole stack, in px² × slices (see RegionStore.classVolumes). */
+    async getClassVolumes(classes) {
+        return Object.fromEntries(await this.regionStore.classVolumes(classes));
+    }
+    getRegionSourceClassCounts(stack) {
+        return this.regionStore.getRegionSourceClassCounts(stack);
+    }
+    getHiddenClasses$() {
+        return this.regionStore.getHiddenClasses$();
+    }
+    setClassesHidden(classes, hidden) {
+        this.regionStore.setClassesHidden(classes, hidden);
+        // A surface is its class's (its group key is the class name).
+        this.napari.setRegionHidden([...this.regionStore.getHiddenClasses()]);
+        this.sections.schedule();
+    }
+    async selectRegionClasses(classes, additive) {
+        await this.regionStore.selectClasses(classes, additive);
+    }
+    getGeoJsonStringWithSource(regions, slice) {
+        return this.regionStore.getGeoJsonWithSource(regions, slice);
+    }
     // ── Per-slice z-stack regions (jit-ui#93), from the shared RegionStore. ──
     enterStackMode(slices, initialZ, saveLayout) {
         this.regionStore.enterStackMode(slices, initialZ, saveLayout);
@@ -492,6 +965,10 @@ export class RoutingVisualizerService {
     isStackMode() {
         return this.regionStore.isStackMode();
     }
+    /** The slice the regions are shown for (recorded outside stack mode too). */
+    getDisplaySlice() {
+        return this.regionStore.getDisplaySlice();
+    }
     getStackSaveLayout() {
         return this.regionStore.getStackSaveLayout();
     }
@@ -568,56 +1045,56 @@ export class RoutingVisualizerService {
     // ── tools → active renderer (run on either backend) ─────────────────
     // The wand, vertex eraser and zoom-to-box are implemented on both backends
     // via ICoordinateTransform (+ a viewport pixel readback for the wand), so they
-    // follow the active renderer.
+    // follow the active renderer — the slice pane's while the volume view is split.
     setActiveTool(id, options) {
-        this.renderer().setActiveTool(id, options);
+        this.regionBackend().setActiveTool(id, options);
     }
     /** @deprecated Use {@link setActiveTool}. */
     setWandMode(active, options) {
-        this.renderer().setWandMode(active, options);
+        this.regionBackend().setWandMode(active, options);
     }
     setWandOptions(options) {
-        this.renderer().setWandOptions(options);
+        this.regionBackend().setWandOptions(options);
     }
     clearActiveWandRegion() {
-        this.renderer().clearActiveWandRegion();
+        this.regionBackend().clearActiveWandRegion();
     }
     /** @deprecated Use {@link setActiveTool}. */
     setBrushMode(active, options) {
-        this.renderer().setBrushMode(active, options);
+        this.regionBackend().setBrushMode(active, options);
     }
     setBrushOptions(options) {
-        this.renderer().setBrushOptions(options);
+        this.regionBackend().setBrushOptions(options);
     }
     /** @deprecated Use {@link setActiveTool}. */
     setVertexEraserMode(active) {
-        this.renderer().setVertexEraserMode(active);
+        this.regionBackend().setVertexEraserMode(active);
     }
     setVertexEraserRadius(radius) {
-        this.renderer().setVertexEraserRadius(radius);
+        this.regionBackend().setVertexEraserRadius(radius);
     }
     /** @deprecated Use {@link setActiveTool}. */
     setZoomToBoxMode(active) {
-        this.renderer().setZoomToBoxMode(active);
+        this.regionBackend().setZoomToBoxMode(active);
     }
     segmentRectangles() {
-        return this.renderer().segmentRectangles();
+        return this.regionBackend().segmentRectangles();
     }
     segmentRectanglesCellpose() {
-        return this.renderer().segmentRectanglesCellpose();
+        return this.regionBackend().segmentRectanglesCellpose();
     }
     setSamModel(id) {
-        this.renderer().setSamModel(id);
+        this.regionBackend().setSamModel(id);
     }
     /** @deprecated Use {@link setActiveTool}. */
     setSamPointMode(active) {
-        this.renderer().setSamPointMode(active);
+        this.regionBackend().setSamPointMode(active);
     }
     commitSamPoints() {
-        this.renderer().commitSamPoints();
+        this.regionBackend().commitSamPoints();
     }
     clearSamPoints() {
-        this.renderer().clearSamPoints();
+        this.regionBackend().clearSamPoints();
     }
     // ── display options ──────────────────────────────────────────────────
     // State lives in the shared VisualizerStore — reads go straight to it.
@@ -699,12 +1176,13 @@ export class RoutingVisualizerService {
         this.store.setInvert(on);
     }
     /**
-     * The active backend's region overlay. Falls back to Plotly's when the active backend
+     * The active backend's region overlay (the slice pane's while the volume view is split). Falls
+     * back to Plotly's when the active backend
      * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a
      * usable overlay.
      */
     getRegionOverlay() {
-        const r = this.renderer();
+        const r = this.regionBackend();
         if (r === this.osd) {
             return this.osd.getRegionOverlay() ?? this.plotly.getRegionOverlay();
         }
@@ -750,8 +1228,14 @@ export class RoutingVisualizerService {
      *  component for a `provideVisualization()` chain. The dataset subscription would
      *  otherwise keep the whole isolated chain reachable from the root data port. */
     ngOnDestroy() {
+        this.importTicket = { id: this.importTicket.id + 1, image: undefined }; // a late import changes nothing
         this.spatialFacade?.dispose();
         this.spatialFacade = null;
+        this.regionUpdates.unsubscribe();
+        this.sectionSubs.unsubscribe();
+        this.sections.stop();
+        if (this.rebuildTimer)
+            clearTimeout(this.rebuildTimer);
     }
     /**
      * Intensity-profile sampling, whichever backend is on screen: the sampling is the
@@ -784,6 +1268,10 @@ export class RoutingVisualizerService {
      *  buffers would otherwise outlive the view (for a component-scoped chain, forever).
      *  Nothing is on screen afterwards, so the next plot starts from the default backend. */
     detach() {
+        this.sliceRequest++;
+        this.sections.stop();
+        this.sliceMounted = false;
+        this.sliceDiv = null;
         this.plotly.detach();
         this.osd.detach();
         this.napari.detach();
@@ -808,4 +1296,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
                     type: Inject,
                     args: [SPATIAL_DATA_PORT]
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routing-visualizer.service.js","sourceRoot":"","sources":["../../../src/lib/routing-visualizer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, OnDestroy, Optional } from '@angular/core';\nimport { EMPTY, Observable, combineLatest, merge } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { Image } from 'image-js';\n\nimport { IImageInfo, IImageMetadata } from './contracts/image.contract';\nimport { Polygon, Region } from './models/region';\nimport { ClassPreset, PresetSet } from './models/class-preset';\nimport { PlotlyService } from './implementations/plotly/plotly.service';\nimport { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';\nimport {\n  PlotType,\n  PlotTypeDescriptor,\n  isNapari3d,\n  isNapariScatter,\n  isSpatialOmics,\n  isSpatialOmics3d,\n} from './contracts/plot-type';\nimport {\n  IViewerBackend,\n  IVisualizer,\n  LoadedImage,\n  PixelData,\n  IntensityProfile,\n  IIsosurfaceControls,\n  IIntensityControls,\n  ISurface3dControls,\n  ISpatialControls,\n  IIntensitySampling,\n  IOsdViewOptions,\n  IVolumeResolution,\n} from './contracts/visualizer.contract';\nimport { SPATIAL_DATA_PORT, SpatialDataPort } from './contracts/ports/spatial-data.port';\nimport { CanvasToolOptions, ColormapNode, IBrushOptions, IWandOptions } from './contracts/display-types';\nimport { SpatialControlsFacade } from './spatial/spatial-controls.facade';\nimport { RegionStore } from './store/region-store.service';\nimport { SpatialSelectionStore } from './store/spatial-selection.service';\nimport { ViewerCapabilities } from './contracts/capabilities.contract';\nimport { IRegionOverlay } from './contracts/region-overlay.contract';\nimport { IRegionEditorApi } from './contracts/region-editor-api.contract';\nimport { IChannelHistogramApi, IChannelState, IHistogram } from './contracts/channel-histogram-api.contract';\nimport { autoWindowFromHistogram } from './contracts/intensity';\nimport { VisualizerStore } from './store/visualizer-store.service';\nimport { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';\nimport { VIZ_CONFIG, VizConfig } from './contracts/viz-config';\nimport { PlotModeViewport } from './contracts/plot-type-contribution.contract';\nimport { IntensityProfileService } from './intensity/intensity-profile.service';\n\n/** Intensity-profile line ROIs are owned by the intensity tool, not the editor.\n *  Package-internal predicate (property-based so it also matches plain objects\n *  after a drag round-trip). */\nfunction isProfileRegion(r: { kind?: string } | null | undefined): boolean {\n  return r?.kind === 'profile';\n}\n\n/**\n * The visualizer chain's front door: implements `IVisualizer`, `IRegionEditorApi`\n * and `IChannelHistogramApi` (bound to the `VISUALIZER` / `REGION_EDITOR_API` /\n * `CHANNEL_HISTOGRAM_API` tokens) over three rendering backends, chosen per plot type:\n *  - **Image** renders through OpenSeadragon (natively tiled, region tools,\n *    client-side colormap), or through napari-js when `VizConfig.useNapariRenderer`\n *    opts in; the napari image types and the 2D spatial-omics mode render through\n *    napari-js. A failed load falls back napari-js → OSD → Plotly for that image only\n *    (see `napariFellBack` / `osdFellBack`, cleared by `reset()`).\n *  - the napari 3D types (volume, isosurface, surface, 3D scatter, the 3D spatial\n *    cloud) render through napari-js, falling back to Plotly.\n *  - every other plot type (heatmap, contour, surface, scatter, line, …) renders\n *    through Plotly.\n *\n * Only rendering and the viewport are routed to the backend on screen. Region state\n * lives in the shared `RegionStore` and display state (colormap, channels, presets,\n * spatial view) in the shared `VisualizerStore`, so every backend sees the same\n * values; the backends subscribe to them to redraw.\n *\n * Package-internal: hosts depend on the tokens, not on this class.\n */\n@Injectable({ providedIn: 'root' })\nexport class RoutingVisualizerService implements IVisualizer, IRegionEditorApi, IChannelHistogramApi, OnDestroy {\n  private currentPlotType: PlotType = PlotType.IMAGE;\n  private lastRendered: IViewerBackend | null = null;\n  /** OSD failed for the *current* render cycle (e.g. a fresh file still caching\n   *  past the deadline) → fall back to Plotly for this image only. Reset by\n   *  reset() at the start of every render cycle, so the next file — or a\n   *  re-select once the file is cached — retries OSD. (Was a permanent flag,\n   *  which left the whole session stuck on Plotly after one slow load.) */\n  private osdFellBack = false;\n  /** napari-js failed for the current render cycle → fall back to OSD (then Plotly).\n   *  Reset by reset() at the start of every cycle, like {@link osdFellBack}. */\n  private napariFellBack = false;\n  /** The file name of the image last plotted (names a GeoJSON export). */\n  private plottedFileName: string | undefined;\n  /** The div the backends render into (every backend shares it); '' before the first plot. */\n  private plotDiv = '';\n\n  constructor(\n    private plotly: PlotlyService,\n    private osd: OpenSeadragonVisualizerService,\n    private napari: NapariVisualizerService,\n    private store: VisualizerStore,\n    @Inject(VIZ_CONFIG) private config: VizConfig,\n    // Optional: a host that serves no spatial-omics data binds nothing,\n    // and `getSpatialControls()` then returns null.\n    private regionStore: RegionStore,\n    private selectionStore: SpatialSelectionStore,\n    private intensity: IntensityProfileService,\n    @Optional()\n    @Inject(SPATIAL_DATA_PORT)\n    private spatialData: SpatialDataPort | null = null,\n  ) {}\n\n  private isImageType(t: PlotType): boolean {\n    return t === PlotType.IMAGE;\n  }\n\n  /** The 2D napari types (image, region-centroid scatter, spatial omics) — a 2D fallback chain\n   *  (OSD, then Plotly).\n   *\n   *  NOTE for SPATIAL_OMICS: only napari-js draws the observation markers. If it fails (no WebGPU,\n   *  device loss) the fallback renders the tissue image ALONE — the spatial layer is absent, not\n   *  degraded. That is deliberate for now: showing the slide beats showing nothing, and a Plotly\n   *  `scattergl` spatial mode is the planned real fallback (see the plot-mode design doc). */\n  private isNapariImageType(t: PlotType): boolean {\n    return t === PlotType.NAPARI_IMAGE || isNapariScatter(t) || isSpatialOmics(t);\n  }\n\n  /** The 3D napari types (volume/isosurface/surface/scatter, plus the 3D spatial cloud) — no 2D\n   *  fallback exists (OSD is image-only), so they fall straight to Plotly. */\n  private isNapari3dType(t: PlotType): boolean {\n    return isNapari3d(t) || isSpatialOmics3d(t);\n  }\n\n  /**\n   * Backend to attempt for the current plot type this render. The fallback chains below are\n   * mirrored exactly by {@link load} so the handle `plot()` receives always comes from the\n   * backend `plot()` selects (no load/plot backend mismatch):\n   *  - 2D image (explicit `NAPARI_IMAGE`, or `IMAGE` with the WebGPU opt-in): napari-js → OSD → Plotly.\n   *  - plain `IMAGE` (no opt-in): OSD → Plotly.\n   *  - 3D napari (`NAPARI_VOLUME`/`NAPARI_ISOSURFACE`): napari-js → Plotly (OSD can't render 3D).\n   */\n  private imageBackend(): IViewerBackend {\n    const t = this.currentPlotType;\n    // 2D image with a napari-js attempt (explicit napari image, or opt-in on the Image type).\n    if (this.isNapariImageType(t) || (this.isImageType(t) && this.config.useNapariRenderer)) {\n      if (!this.napariFellBack) return this.napari;\n      if (!this.osdFellBack) return this.osd;\n      return this.plotly;\n    }\n    // Plain Image type (no napari opt-in): OSD, then Plotly.\n    if (this.isImageType(t)) {\n      return this.osdFellBack ? this.plotly : this.osd;\n    }\n    // 3D napari types: napari-js, with Plotly as the only viable fallback.\n    if (this.isNapari3dType(t)) {\n      return this.napariFellBack ? this.plotly : this.napari;\n    }\n    return this.plotly;\n  }\n\n  /** Backend currently on screen — what ongoing zoom/tool/region ops act on. */\n  private renderer(): IViewerBackend {\n    return this.lastRendered ?? this.plotly;\n  }\n\n  // System capabilities are Plotly's (the full-featured backend) so the UI\n  // keeps offering every plot type regardless of which one is on screen.\n  get capabilities(): ViewerCapabilities {\n    return this.plotly.capabilities;\n  }\n\n  // ── render / viewport → active renderer ──────────────────────────────\n  async load(imageInfo: IImageInfo, zIndex: number, signal?: AbortSignal): Promise<LoadedImage> {\n    // A stack can open away from slice 0 (`initialZIndex` — a volume opens\n    // mid-specimen), and that arrives here rather than through setZIndex.\n    this.currentZIndex = zIndex;\n    const backend = this.imageBackend();\n    if (backend === this.napari) {\n      try {\n        return await this.napari.load(imageInfo, zIndex, signal);\n      } catch (err) {\n        // Aborted: nobody wants this image any more, so don't go on to load it elsewhere.\n        if (signal?.aborted) throw err;\n        this.napariFellBack = true;\n        // Mirror imageBackend()'s fallback so load + plot pick the same backend:\n        //  - 3D napari types have no 2D fallback → straight to Plotly.\n        //  - 2D image → OSD, then Plotly.\n        if (this.isNapari3dType(this.currentPlotType)) {\n          console.warn('[visualizer] napari-js load failed — falling back to Plotly.', err);\n          return this.plotly.load(imageInfo, zIndex, signal);\n        }\n        console.warn('[visualizer] napari-js load failed — falling back to OpenSeadragon.', err);\n        return this.loadViaOsdThenPlotly(imageInfo, zIndex, signal);\n      }\n    }\n    if (backend === this.osd) {\n      return this.loadViaOsdThenPlotly(imageInfo, zIndex, signal);\n    }\n    return this.plotly.load(imageInfo, zIndex, signal);\n  }\n\n  /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */\n  private async loadViaOsdThenPlotly(\n    imageInfo: IImageInfo,\n    zIndex: number,\n    signal?: AbortSignal,\n  ): Promise<LoadedImage> {\n    try {\n      return await this.osd.load(imageInfo, zIndex, signal);\n    } catch (err) {\n      if (signal?.aborted) throw err;\n      console.warn('[visualizer] OpenSeadragon load failed — falling back to Plotly for this image.', err);\n      this.osdFellBack = true;\n      return this.plotly.load(imageInfo, zIndex, signal);\n    }\n  }\n  plot(\n    plotDiv: string,\n    imageLoaded: unknown,\n    imageInfo: IImageInfo,\n    screenHeight: number,\n    plotType: PlotType,\n    inPlace?: boolean,\n  ): Promise<boolean> {\n    this.currentPlotType = plotType;\n    this.plottedFileName = imageInfo?.fileName;\n    this.plotDiv = plotDiv;\n    // Apply the per-image region cache (snapshot old regions, restore the new\n    // image's, clear selection) for whichever backend renders — Plotly does\n    // this inside its own plot(), but OSD doesn't, so drive it here. Idempotent\n    // for the same image, so it's safe to call on every (re)plot.\n    this.plotly.setActiveImage(imageInfo);\n    const next = this.imageBackend();\n    // Both backends share the same div — tear down the outgoing one on switch.\n    // Plotly must be *purged* (not reset, which re-draws empty axes) before OSD\n    // takes the div.\n    if (this.lastRendered && this.lastRendered !== next) {\n      if (this.lastRendered === this.plotly) this.plotly.purgePlot();\n      else this.lastRendered.reset();\n    }\n    this.lastRendered = next;\n    return next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);\n  }\n  reloadAndPlot(): void {\n    this.plotly.reloadAndPlot();\n  }\n  reset(): void {\n    // Start of a render cycle: re-enable napari-js/OSD attempts (clear any prior\n    // per-image fallback) and tear down whatever's on screen.\n    this.osdFellBack = false;\n    this.napariFellBack = false;\n    this.renderer().reset();\n  }\n  relayout(trueImageSize?: number[]): void {\n    this.renderer().relayout(trueImageSize);\n  }\n  resetAxes(): void {\n    this.renderer().resetAxes();\n  }\n  fitToView(): void {\n    this.renderer().fitToView();\n  }\n  /** @deprecated Use {@link fitToView}. */\n  autoscale(): void {\n    this.fitToView();\n  }\n  zoomIn(): void {\n    this.renderer().zoomIn();\n  }\n  zoomOut(): void {\n    this.renderer().zoomOut();\n  }\n  setDragMode(mode: string | false): void {\n    this.renderer().setDragMode(mode);\n  }\n  /** Every backend, on screen or not. */\n  private backends(): IViewerBackend[] {\n    return [this.plotly, this.osd, this.napari];\n  }\n\n  /**\n   * The navigator / smoothing options, applied to EVERY backend that has them (not\n   * just the active renderer): consumers set them before the first render, when\n   * `renderer()` is still the Plotly default, and OSD/napari-js must receive them\n   * to honour them at viewer creation.\n   */\n  getOsdViewOptions(): IOsdViewOptions {\n    return this.viewOptions;\n  }\n  private readonly viewOptions: IOsdViewOptions = {\n    setNavigatorVisible: (visible) => {\n      for (const b of this.backends()) b.getOsdViewOptions()?.setNavigatorVisible(visible);\n    },\n    setImageSmoothingEnabled: (enabled) => {\n      for (const b of this.backends()) b.getOsdViewOptions()?.setImageSmoothingEnabled(enabled);\n    },\n  };\n  /** @deprecated Use `getOsdViewOptions().setNavigatorVisible()`. */\n  setNavigatorVisible(visible: boolean): void {\n    this.viewOptions.setNavigatorVisible(visible);\n  }\n  /** @deprecated Use `getOsdViewOptions().setImageSmoothingEnabled()`. */\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.viewOptions.setImageSmoothingEnabled(enabled);\n  }\n  setShowStack(showstack: boolean): void {\n    this.renderer().setShowStack(showstack);\n  }\n  setZIndex(zIndex: number): void {\n    this.currentZIndex = zIndex;\n    this.renderer().setZIndex(zIndex);\n  }\n  getTrueImageSize(): { width: number; height: number } | null {\n    return this.renderer().getTrueImageSize();\n  }\n  getCurrentImage(): Promise<Image | null> {\n    return this.renderer().getCurrentImage();\n  }\n  getDisplayedPixelData(): PixelData | null {\n    return this.renderer().getDisplayedPixelData();\n  }\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    return this.renderer().getDisplayedSourceRect();\n  }\n  downloadImage(): void {\n    this.renderer().downloadImage();\n  }\n  exportComposite(): void {\n    this.renderer().exportComposite();\n  }\n\n  setPlotType(plotType: PlotType): void {\n    this.currentPlotType = plotType;\n    this.plotly.setPlotType(plotType);\n  }\n  /** @deprecated Use `getSurface3dControls()`. */\n  setSurfaceDragMode(mode: string): void {\n    this.getSurface3dControls()?.setSurfaceDragMode(mode);\n  }\n  /** @deprecated Use `getSurface3dControls()`. */\n  resetSurfaceCamera(): void {\n    this.getSurface3dControls()?.resetSurfaceCamera();\n  }\n  /** The 3D decimate factor of the backend on screen (napari-js), else null. */\n  getVolumeResolution(): IVolumeResolution | null {\n    return this.renderer().getVolumeResolution();\n  }\n  /** @deprecated Use `getVolumeResolution()?.set()`. */\n  setResolutionScale(scale: number): void {\n    this.getVolumeResolution()?.set(scale);\n  }\n  /** @deprecated Use `getVolumeResolution()?.get()`. */\n  getResolutionScale(): number {\n    return this.getVolumeResolution()?.get() ?? 1;\n  }\n  /** The viewport of the backend on screen, for a contributed plot mode. Null\n   *  when that backend cannot provide one (e.g. OSD fell back to Plotly). */\n  getPlotModeViewport(): PlotModeViewport | null {\n    return this.renderer().getPlotModeViewport?.() ?? null;\n  }\n  getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    // Plotly enumerates the full PLOT_TYPE_DESCRIPTORS map, which already includes the\n    // napari-js WebGPU types (jit-ui#102) — so this single source covers them (no duplicates).\n    return this.plotly.getPlotTypeDescriptors();\n  }\n\n  // ── long-lived observables + stack flags ──────────────────────────────────\n  setStackLoading(b: boolean): void {\n    this.plotly.setStackLoading(b);\n  }\n  // Cancel in-flight loading on every backend — the user's Cancel shouldn't depend on which one is\n  // active. Only backends that stream frames (napari-js) do real work; the rest no-op. The concrete\n  // backend classes don't all declare the optional contract method, so call it via IViewerBackend.\n  cancelLoading(): void {\n    for (const backend of [this.plotly, this.osd, this.napari] as IViewerBackend[]) {\n      backend.cancelLoading?.();\n    }\n  }\n  // Loading state is surfaced from whichever backend is doing the work: OSD and napari-js (volume\n  // assembly) drive their own subjects, so merge all three into one stable stream the host\n  // subscribes to once. (Previously hardcoded to Plotly, so napari/OSD progress never showed.)\n  isStackLoading(): Observable<boolean> {\n    return combineLatest([\n      this.plotly.isStackLoading(),\n      this.osd.isStackLoading(),\n      this.napari.isStackLoading(),\n    ]).pipe(map((flags) => flags.some(Boolean)));\n  }\n  getStackLoadingProgress(): Observable<number> {\n    // Report the progress of whichever backend is ACTIVELY loading (max across active ones). A plain\n    // merge let an idle backend's stale value win the stream on a re-load — leaving the bar below the\n    // active backend's real progress (e.g. stuck ~⅓ while the % read 100). Gating by the loading flag\n    // ignores idle backends, so the bar tracks the one doing the work and reaches 100%.\n    const track = (v: IViewerBackend): Observable<[number, boolean]> =>\n      combineLatest([v.getStackLoadingProgress(), v.isStackLoading()]);\n    return combineLatest([track(this.plotly), track(this.osd), track(this.napari)]).pipe(\n      map((pairs) => {\n        const active = pairs.filter(([, loading]) => loading).map(([p]) => p);\n        return active.length ? Math.max(...active) : 0;\n      }),\n    );\n  }\n  // Every backend fits to view on its own (Plotly's autoscale, OSD's goHome, napari's camera\n  // fit) and each emits from its own subject, so merge all three: listening to Plotly alone\n  // missed the context-menu Autoscale on the Image and napari views.\n  getAutoscaleEvent(): Observable<void> {\n    return merge(\n      this.plotly.getAutoscaleEvent(),\n      this.osd.getAutoscaleEvent(),\n      this.napari.getAutoscaleEvent(),\n    ).pipe(map(() => undefined));\n  }\n  /** The line-ROI profiles: sampled by the backend-neutral IntensityProfileService. */\n  getIntensityProfile$(): Observable<IntensityProfile[]> {\n    return this.intensity.getIntensityProfile$();\n  }\n  // The intensity inset is a Plotly LINE chart — render it through Plotly whichever\n  // backend draws the main image.\n  renderIntensityInset(divId: string, profiles: IntensityProfile[]): void {\n    this.plotly.renderIntensityInset(divId, profiles);\n  }\n\n  // ── regions ──────────────────────────────────────────────────────────\n  // Region state lives in the shared RegionStore, so every read and write goes\n  // straight to it. Every backend draws from the store's events: the OSD and\n  // napari-js overlays and Plotly's shape projection redraw on its region-update\n  // and selection streams, and the canvas tools reset on getRegionSetReplaced$\n  // (undo, redo, a slice switch).\n  setRegions(\n    regions: Region[],\n    showRegionLabel?: boolean,\n    isRegionSaveOn?: boolean,\n    fillColor?: string,\n    append?: boolean,\n  ): void {\n    this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);\n  }\n  getRegions(): Region[] {\n    return this.regionStore.getRegions();\n  }\n  getRegionPolygons(): Polygon[] {\n    return this.regionStore.getRegionPolygons();\n  }\n  getRegionUpdateEvent(): Observable<Region[]> {\n    return this.regionStore.getRegionUpdateEvent();\n  }\n  setSelectedShapeIndices(indices: number[]): void {\n    this.regionStore.setSelectedShapeIndices(indices);\n  }\n  selectRegion(region: Region): void {\n    this.regionStore.selectRegion(region);\n  }\n  getSelectedShapeIndices$(): Observable<number[]> {\n    return this.regionStore.getSelectedShapeIndices$();\n  }\n  deleteActiveShape(): void {\n    this.regionStore.deleteActiveShape();\n  }\n  getShowShapeLabel(): boolean {\n    return this.regionStore.getShowShapeLabel();\n  }\n  getShapeColor(): string {\n    return this.regionStore.getShapeColor();\n  }\n  getFillColor(): string {\n    return this.regionStore.getFillColor();\n  }\n  getClassificationColors(): Map<string, string> {\n    return this.store.getClassificationColors();\n  }\n  setClassificationColor(label: string, color: string): void {\n    this.store.setClassificationColor(label, color);\n  }\n  // Annotation-class presets live in the shared VisualizerStore (backend-neutral\n  // session state), so route straight to it rather than through renderer(). (jit-ui#70)\n  getPresetSet(): PresetSet {\n    return this.store.getPresetSet();\n  }\n  getPresetSet$(): Observable<PresetSet> {\n    return this.store.getPresetSet$();\n  }\n  setPresetSet(set: PresetSet): void {\n    this.store.setPresetSet(set);\n  }\n  upsertClass(preset: ClassPreset): void {\n    this.store.upsertClass(preset);\n  }\n  removeClass(name: string): void {\n    this.store.removeClass(name);\n  }\n  resetPresets(): void {\n    this.store.resetPresets();\n  }\n  undo(): void {\n    this.regionStore.undo();\n  }\n  redo(): void {\n    this.regionStore.redo();\n  }\n  canUndo(): boolean {\n    return this.regionStore.canUndo();\n  }\n  canRedo(): boolean {\n    return this.regionStore.canRedo();\n  }\n  getCanUndo$(): Observable<boolean> {\n    return this.regionStore.getCanUndo$();\n  }\n  getCanRedo$(): Observable<boolean> {\n    return this.regionStore.getCanRedo$();\n  }\n  resetUndoHistory(): void {\n    this.regionStore.resetUndoHistory();\n  }\n  importRegions(geoJsonStr: string): Region[] {\n    return this.regionStore.importRegions(geoJsonStr);\n  }\n  /** Download `regions` as GeoJSON, named after the image last plotted. */\n  exportRegions(regions: Region[]): void {\n    this.regionStore.exportRegions(regions, this.plottedFileName);\n  }\n  getGeoJsonString(regions: Region[]): string {\n    return this.regionStore.getGeoJsonString(regions);\n  }\n\n  // ── Per-slice z-stack regions (jit-ui#93), from the shared RegionStore. ──\n  enterStackMode(\n    slices: Map<number, Region[]>,\n    initialZ?: number,\n    saveLayout?: 'combined' | 'per-slice-file',\n  ): void {\n    this.regionStore.enterStackMode(slices, initialZ, saveLayout);\n  }\n  exitStackMode(): void {\n    this.regionStore.exitStackMode();\n  }\n  isStackMode(): boolean {\n    return this.regionStore.isStackMode();\n  }\n  getStackSaveLayout(): 'combined' | 'per-slice-file' {\n    return this.regionStore.getStackSaveLayout();\n  }\n  setDisplaySlice(z: number): void {\n    this.regionStore.setDisplaySlice(z);\n  }\n  getSliceRegions(): Region[] {\n    return this.regionStore.getSliceRegions();\n  }\n  getStackSaveSlices(): Map<number, Region[]> {\n    return this.regionStore.getStackSaveSlices();\n  }\n  /** All slices' ANNOTATION regions for a z-stack save (jit-ui#93), each tagged\n   *  with its zero-based Region.z; profile lines excluded. Flat annotation set\n   *  outside stack mode. */\n  getSliceAnnotationRegions(): Region[] {\n    return this.regionStore.getSliceRegions().filter((r) => !isProfileRegion(r));\n  }\n  /** Per-slice annotation regions to write on a folder-stack save (jit-ui#93):\n   *  slice index → that slice's annotation regions (profile lines excluded),\n   *  including now-empty slices that were loaded non-empty (so they overwrite). */\n  getStackSaveAnnotationSlices(): Map<number, Region[]> {\n    const out = new Map<number, Region[]>();\n    for (const [z, regs] of this.regionStore.getStackSaveSlices()) {\n      out.set(\n        z,\n        regs.filter((r) => !isProfileRegion(r)),\n      );\n    }\n    return out;\n  }\n\n  /** Authoritative full-resolution image size for mask export. Prefers the\n   *  active renderer's reported size, falling back to the image metadata (x/y\n   *  are the full-res pixel dimensions used across the app). Rejects non-finite\n   *  or non-positive sizes — the Plotly bounds can yield NaN before a plot is\n   *  fully laid out, which would otherwise crash mask creation. */\n  getMaskImageSize(): { width: number; height: number } | null {\n    const valid = (s: { width: number; height: number } | null | undefined) =>\n      s && Number.isFinite(s.width) && Number.isFinite(s.height) && s.width >= 1 && s.height >= 1\n        ? { width: Math.round(s.width), height: Math.round(s.height) }\n        : null;\n\n    const fromRenderer = valid(this.getTrueImageSize());\n    if (fromRenderer) return fromRenderer;\n\n    let meta: IImageMetadata[] = [];\n    this.getImageMeta()\n      .subscribe((m) => (meta = m))\n      .unsubscribe();\n    const m0 = meta?.[0];\n    return m0 ? valid({ width: m0.x, height: m0.y }) : null;\n  }\n\n  // ── IRegionEditorApi: annotation-only surface for the Region Editor ───\n  // Intensity-profile lines (kind='profile') belong to the intensity tool, not\n  // the editor. These methods give external consumers an annotation-only view\n  // and guarantee profile lines are preserved. The writes land in the store like\n  // any other, and every backend redraws from its events.\n\n  getAnnotationRegions(): Region[] {\n    return this.regionStore.getRegions().filter((r) => !isProfileRegion(r));\n  }\n  setAnnotationRegions(\n    regions: Region[],\n    showRegionLabel?: boolean,\n    isRegionSaveOn?: boolean,\n    fillColor?: string,\n  ): void {\n    // Re-append the store's profile lines so an editor save/delete can't drop them.\n    const profiles = this.regionStore.getRegions().filter((r) => isProfileRegion(r));\n    const annotations = (regions || []).filter((r) => !isProfileRegion(r));\n    this.setRegions([...annotations, ...profiles], showRegionLabel, isRegionSaveOn, fillColor, false);\n  }\n  getSelectedRegions$(): Observable<Region[]> {\n    // Map the internal index-based selection to the selected annotation regions.\n    return this.getSelectedShapeIndices$().pipe(\n      map((idxs) => {\n        const regs = this.regionStore.getRegions();\n        return idxs.map((i) => regs[i]).filter((r): r is Region => !!r && !isProfileRegion(r));\n      }),\n    );\n  }\n  setSelectedRegions(regions: Region[]): void {\n    const regs = this.regionStore.getRegions();\n    const indices = (regions || []).map((r) => regs.findIndex((x) => x.id === r.id)).filter((i) => i >= 0);\n    this.setSelectedShapeIndices(indices);\n  }\n\n  // ── tools → active renderer (run on either backend) ─────────────────\n  // The wand, vertex eraser and zoom-to-box are implemented on both backends\n  // via ICoordinateTransform (+ a viewport pixel readback for the wand), so they\n  // follow the active renderer.\n  setActiveTool(id: string | null, options?: CanvasToolOptions): void {\n    this.renderer().setActiveTool(id, options);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setWandMode(active: boolean, options?: IWandOptions): void {\n    this.renderer().setWandMode(active, options);\n  }\n  setWandOptions(options: IWandOptions): void {\n    this.renderer().setWandOptions(options);\n  }\n  clearActiveWandRegion(): void {\n    this.renderer().clearActiveWandRegion();\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setBrushMode(active: boolean, options?: IBrushOptions): void {\n    this.renderer().setBrushMode(active, options);\n  }\n  setBrushOptions(options: IBrushOptions): void {\n    this.renderer().setBrushOptions(options);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setVertexEraserMode(active: boolean): void {\n    this.renderer().setVertexEraserMode(active);\n  }\n  setVertexEraserRadius(radius: number): void {\n    this.renderer().setVertexEraserRadius(radius);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setZoomToBoxMode(active: boolean): void {\n    this.renderer().setZoomToBoxMode(active);\n  }\n  segmentRectangles(): Promise<number> {\n    return this.renderer().segmentRectangles();\n  }\n  segmentRectanglesCellpose(): Promise<number> {\n    return this.renderer().segmentRectanglesCellpose();\n  }\n  setSamModel(id: string): void {\n    this.renderer().setSamModel(id);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setSamPointMode(active: boolean): void {\n    this.renderer().setSamPointMode(active);\n  }\n  commitSamPoints(): void {\n    this.renderer().commitSamPoints();\n  }\n  clearSamPoints(): void {\n    this.renderer().clearSamPoints();\n  }\n\n  // ── display options ──────────────────────────────────────────────────\n  // State lives in the shared VisualizerStore — reads go straight to it.\n  // The two SETTERS still route through Plotly because its implementations\n  // carry render glue beyond the store write (a live Plotly.restyle of\n  // colorscale/reversescale on the mounted heatmap); OSD recolors via its own\n  // store subscription either way.\n  getColormap(): Observable<ColormapNode | null> {\n    return this.store.getColormap();\n  }\n  setColormap(colormap: ColormapNode): void {\n    this.plotly.setColormap(colormap);\n  }\n  getColormapOptions(): ColormapNode[] {\n    return this.store.getColormapOptions();\n  }\n  getReverseScale(): Observable<boolean> {\n    return this.store.getReverseScale();\n  }\n  setReverseScale(reverse: boolean): void {\n    this.plotly.setReverseScale(reverse);\n  }\n  setImageMeta(imageMeta: IImageMetadata[], imageKey?: string): void {\n    this.store.setImageMeta(imageMeta, imageKey);\n  }\n  getImageMeta(): Observable<IImageMetadata[]> {\n    return this.store.getImageMeta();\n  }\n\n  // ── IChannelHistogramApi: Channels & Histogram pane surface ───────────\n  // Channel/grayscale/invert state lives in the shared VisualizerStore; both\n  // backends subscribe and recolor live, so setters just write the store. The\n  // histogram comes from whichever backend is on screen (its native pixels).\n  getHistogram(channelIndex: number, bins: number): IHistogram | null {\n    return this.renderer().getHistogram(channelIndex, bins);\n  }\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    return this.renderer().getHistogram$(channelIndex, bins);\n  }\n  /** Export the underlying data (16-bit multi-band TIFF) via the active backend. */\n  exportData(): void {\n    this.renderer().exportData();\n  }\n  getChannels$(): Observable<IChannelState[]> {\n    return this.store.getChannelStates();\n  }\n  setSelectedChannel(index: number): void {\n    this.store.setSelectedChannel(index);\n  }\n  setChannelState(index: number, partial: Partial<IChannelState>): void {\n    this.store.setChannelState(index, partial);\n  }\n  resetContrast(indices: number[]): void {\n    // Full reset: window (0..255), gamma (1) AND the channel's default tint.\n    for (const i of indices) this.store.resetChannelState(i);\n  }\n  /** Auto-window each channel by saturating `saturation` (0..1) of pixels at each\n   *  end of its histogram (skipping outlier first/last bins). */\n  autoContrast(indices: number[], saturation: number): void {\n    for (const i of indices) {\n      const h = this.renderer().getHistogram(i, 256);\n      if (!h) continue;\n      const [min, max] = autoWindowFromHistogram(h, saturation, [0, 255]);\n      if (max > min) this.store.setChannelState(i, { min, max });\n    }\n  }\n  getGrayscale$(): Observable<boolean> {\n    return this.store.getGrayscale();\n  }\n  setGrayscale(on: boolean): void {\n    this.store.setGrayscale(on);\n  }\n  getInvert$(): Observable<boolean> {\n    return this.store.getInvert();\n  }\n  setInvert(on: boolean): void {\n    this.store.setInvert(on);\n  }\n\n  /**\n   * The active backend's region overlay. Falls back to Plotly's when the active backend\n   * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a\n   * usable overlay.\n   */\n  getRegionOverlay(): IRegionOverlay {\n    const r = this.renderer();\n    if (r === this.osd) {\n      return this.osd.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    if (r === this.napari) {\n      return this.napari.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    return this.plotly.getRegionOverlay();\n  }\n\n  /** Isosurface controls of the backend on screen, when it renders isosurfaces. */\n  getIsosurfaceControls(): IIsosurfaceControls | null {\n    return this.renderer().getIsosurfaceControls();\n  }\n\n  /** 3D scene controls of the backend on screen (Plotly or napari-js), or null on a\n   *  2D-only one. */\n  getSurface3dControls(): ISurface3dControls | null {\n    return this.renderer().getSurface3dControls();\n  }\n\n  /** Intensity (line-ROI) controls, whichever backend draws the image: the\n   *  IntensityProfileService adds the line to the store, and every backend\n   *  (Plotly included) draws it from the store's update event. */\n  getIntensityControls(): IIntensityControls | null {\n    return this.intensity;\n  }\n\n  /**\n   * Spatial-omics controls, or null when no `SPATIAL_DATA_PORT` is bound. Served by a\n   * backend-neutral {@link SpatialControlsFacade} (state in the shared stores), so the\n   * controls work across a plot-type switch and before any backend has mounted.\n   */\n  getSpatialControls(): ISpatialControls | null {\n    if (!this.spatialData) return null;\n    this.spatialFacade ??= new SpatialControlsFacade(this.spatialData, {\n      store: this.store,\n      regionStore: this.regionStore,\n      selectionStore: this.selectionStore,\n      napari: this.napari,\n      plotType: () => this.currentPlotType,\n      zIndex: () => this.currentZIndex,\n    });\n    return this.spatialFacade.controls;\n  }\n\n  /** Created on first use; owns the dataset subscription. */\n  private spatialFacade: SpatialControlsFacade | null = null;\n  /** Displayed slice. Only a volume-backed spatial dataset reads it, to keep a\n   *  region drawn over one section from selecting the whole depth behind it. */\n  private currentZIndex = 0;\n\n  /** Angular calls this when the injector providing the router is destroyed — the host\n   *  component for a `provideVisualization()` chain. The dataset subscription would\n   *  otherwise keep the whole isolated chain reachable from the root data port. */\n  ngOnDestroy(): void {\n    this.spatialFacade?.dispose();\n    this.spatialFacade = null;\n  }\n\n  /**\n   * Intensity-profile sampling, whichever backend is on screen: the sampling is the\n   * backend-neutral IntensityProfileService's; the viewport changes come from every\n   * backend that reports them (OpenSeadragon, napari-js), merged into one stable\n   * stream the inset subscribes to once.\n   */\n  getIntensitySampling(): IIntensitySampling {\n    return this.intensitySampling;\n  }\n  private readonly intensitySampling: IIntensitySampling = {\n    // Load the displayed slice's pixels for a backend that has no frames of its own\n    // (OpenSeadragon, napari-js; Plotly feeds its frames to the service when it plots).\n    ensureIntensitySampling: (imageInfo, zIndex) => {\n      this.pointSamplingAtPlot();\n      return this.intensity.ensureIntensitySampling(imageInfo, zIndex);\n    },\n    // Re-sample from a fresh crop of the image-pixel ROI at display resolution.\n    refreshIntensitySamplingForRoi: (x, y, width, height, zIndex) => {\n      this.pointSamplingAtPlot();\n      this.intensity.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);\n    },\n    getViewportChange$: () =>\n      merge(...this.backends().map((b) => b.getIntensitySampling()?.getViewportChange$() ?? EMPTY)),\n  };\n  /** @deprecated Use `getIntensitySampling().ensureIntensitySampling()`. */\n  ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void> {\n    return this.intensitySampling.ensureIntensitySampling(imageInfo, zIndex);\n  }\n\n  /** Crops for sampling are sized from the plot div (whichever backend renders into it). */\n  private pointSamplingAtPlot(): void {\n    if (this.plotDiv) this.intensity.setSamplingElement(this.plotDiv);\n  }\n\n  /** @deprecated Use `getIntensitySampling().getViewportChange$()`. */\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return this.intensitySampling.getViewportChange$();\n  }\n\n  /** @deprecated Use `getIntensitySampling().refreshIntensitySamplingForRoi()`. */\n  refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number, zIndex: number): void {\n    this.intensitySampling.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);\n  }\n\n  /** The visualizer view is going away: detach every backend — dropping their view-bound\n   *  subscriptions and disposing the napari-js viewer, whose canvas, render loop and GPU\n   *  buffers would otherwise outlive the view (for a component-scoped chain, forever).\n   *  Nothing is on screen afterwards, so the next plot starts from the default backend. */\n  detach(): void {\n    this.plotly.detach();\n    this.osd.detach();\n    this.napari.detach();\n    this.lastRendered = null;\n  }\n\n  /** @deprecated Use {@link detach}. */\n  unsubscribe(): void {\n    this.detach();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routing-visualizer.service.js","sourceRoot":"","sources":["../../../src/lib/routing-visualizer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, OnDestroy, Optional } from '@angular/core';\nimport { EMPTY, Observable, Subject, Subscription, combineLatest, merge, BehaviorSubject } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { Image } from 'image-js';\nimport { resolveColormap } from 'napari-js';\n\nimport { IImageInfo, IImageMetadata } from './contracts/image.contract';\nimport { Polygon, Region } from './models/region';\nimport { ClassPreset, PresetSet } from './models/class-preset';\nimport { PlotlyService } from './implementations/plotly/plotly.service';\nimport { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';\nimport {\n  PlotType,\n  PlotTypeDescriptor,\n  isNapari3d,\n  isNapariScatter,\n  isSpatialOmics,\n  isSpatialOmics3d,\n  isNapariIsosurface,\n  isNapariVolume,\n} from './contracts/plot-type';\nimport {\n  IViewerBackend,\n  IVisualizer,\n  LoadedImage,\n  PixelData,\n  IntensityProfile,\n  IIsosurfaceControls,\n  IIntensityControls,\n  ISurface3dControls,\n  ISpatialControls,\n  IIntensitySampling,\n  IOsdViewOptions,\n  IVolumeResolution,\n} from './contracts/visualizer.contract';\nimport { SPATIAL_DATA_PORT, SpatialDataPort } from './contracts/ports/spatial-data.port';\nimport { CanvasToolOptions, ColormapNode, IBrushOptions, IWandOptions } from './contracts/display-types';\nimport { SpatialControlsFacade } from './spatial/spatial-controls.facade';\nimport { RegionStore } from './store/region-store.service';\nimport { RegionScopeCache } from './store/region-scope-cache';\nimport { REGION_SOURCE_MIN_CHARS, RegionSource, RegionSourceView } from './region-source/region-source';\nimport type { RegionIndexPage, RegionIndexQuery } from './region-source/region-tiles';\nimport type { RegionStyle } from './region-overlay/region-style';\nimport type { Mesh } from 'napari-js/geometry';\nimport { openGeoJsonRegionSource } from './region-source/worker-region-source';\nimport type { RegionSourceOpener, RegionSourceSlices } from './store/region-source-scope';\nimport { SpatialSelectionStore } from './store/spatial-selection.service';\nimport { ViewerCapabilities } from './contracts/capabilities.contract';\nimport { IRegionOverlay } from './contracts/region-overlay.contract';\nimport { IRegionEditorApi } from './contracts/region-editor-api.contract';\nimport { IChannelHistogramApi, IChannelState, IHistogram } from './contracts/channel-histogram-api.contract';\nimport { autoWindowFromHistogram } from './contracts/intensity';\nimport { VisualizerStore } from './store/visualizer-store.service';\nimport { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';\nimport { channelTintColormap, volumeColormap } from './implementations/napari-js/napari-display-state';\nimport { VIZ_CONFIG, VizConfig } from './contracts/viz-config';\nimport { PlotModeViewport } from './contracts/plot-type-contribution.contract';\nimport { IntensityProfileService } from './intensity/intensity-profile.service';\nimport { changedClasses, classSignatures } from './store/class-signatures';\nimport { VolumeSections } from './visualizer/volume-sections';\nimport type { SectionAxis, SectionViews } from './contracts/section-view.contract';\n\n/** How long after the last edit the surfaces of the classes it touched are rebuilt (ms). */\nexport const REGION_SURFACE_REBUILD_MS = 600;\n\n/** Intensity-profile line ROIs are owned by the intensity tool, not the editor.\n *  Package-internal predicate (property-based so it also matches plain objects\n *  after a drag round-trip). */\nfunction isProfileRegion(r: { kind?: string } | null | undefined): boolean {\n  return r?.kind === 'profile';\n}\n\n/**\n * The visualizer chain's front door: implements `IVisualizer`, `IRegionEditorApi`\n * and `IChannelHistogramApi` (bound to the `VISUALIZER` / `REGION_EDITOR_API` /\n * `CHANNEL_HISTOGRAM_API` tokens) over three rendering backends, chosen per plot type:\n *  - **Image** renders through OpenSeadragon (natively tiled, region tools,\n *    client-side colormap), or through napari-js when `VizConfig.useNapariRenderer`\n *    opts in; the napari image types and the 2D spatial-omics mode render through\n *    napari-js. A failed load falls back napari-js → OSD → Plotly for that image only\n *    (see `napariFellBack` / `osdFellBack`, cleared by `reset()`).\n *  - the napari 3D types (volume, isosurface, surface, 3D scatter, the 3D spatial\n *    cloud) render through napari-js, falling back to Plotly.\n *  - every other plot type (heatmap, contour, surface, scatter, line, …) renders\n *    through Plotly.\n *\n * Only rendering and the viewport are routed to the backend on screen. Region state\n * lives in the shared `RegionStore` and display state (colormap, channels, presets,\n * spatial view) in the shared `VisualizerStore`, so every backend sees the same\n * values; the backends subscribe to them to redraw.\n *\n * Package-internal: hosts depend on the tokens, not on this class.\n */\n@Injectable({ providedIn: 'root' })\nexport class RoutingVisualizerService implements IVisualizer, IRegionEditorApi, IChannelHistogramApi, OnDestroy {\n  private currentPlotType: PlotType = PlotType.IMAGE;\n  private lastRendered: IViewerBackend | null = null;\n  /** OSD failed for the *current* render cycle (e.g. a fresh file still caching\n   *  past the deadline) → fall back to Plotly for this image only. Reset by\n   *  reset() at the start of every render cycle, so the next file — or a\n   *  re-select once the file is cached — retries OSD. (Was a permanent flag,\n   *  which left the whole session stuck on Plotly after one slow load.) */\n  private osdFellBack = false;\n  /** napari-js failed for the current render cycle → fall back to OSD (then Plotly).\n   *  Reset by reset() at the start of every cycle, like {@link osdFellBack}. */\n  private napariFellBack = false;\n  /** The file name of the image last plotted (names a GeoJSON export). */\n  private plottedFileName: string | undefined;\n  /** The div the backends render into (every backend shares it); '' before the first plot. */\n  private plotDiv = '';\n  /** Whether a napari volume view is the current plot type. */\n  private readonly volumeView$ = new BehaviorSubject<boolean>(false);\n  /** Whether the volume view's slice pane is wanted (see {@link setSliceEditor}). */\n  private readonly sliceEditor$ = new BehaviorSubject<boolean>(false);\n  /** Whether the volume view draws the region reconstructions through the volume. */\n  private readonly regionsThroughVolume$ = new BehaviorSubject<boolean>(false);\n  /** Region reconstructions built so far, by image, resolution and classes (with those classes). */\n  private readonly meshCache = new Map<string, { mesh: Mesh; classes: readonly string[] }>();\n  /** Bumped per {@link showRegionClasses3d} (and per new image), so only the latest one shows. */\n  private meshRequest = 0;\n  /** The class groups shown in 3D, and the image they belong to. */\n  private readonly classes3d$ = new BehaviorSubject<ReadonlyArray<{ key: string; classes: readonly string[] }>>(\n    [],\n  );\n  private classes3dImage: string | undefined;\n  /** The groups last asked for in 3D, with their colours: what an edit's rebuild shows again. */\n  private shown3d: ReadonlyArray<{ key: string; classes: readonly string[]; color: string; label?: string }> = [];\n  /**\n   * Each class's fingerprint on the live slice (see classSignatures), which image and slice, and\n   * what the region sources hold (see RegionStore.getSourceStateKey). Null while nothing follows\n   * the edits (no surface built, no sections).\n   */\n  private liveClasses: { at: string; signatures: Map<string, number>; sources: string } | null = null;\n  /** The pending rebuild of the surfaces an edit touched. */\n  private rebuildTimer: ReturnType<typeof setTimeout> | null = null;\n  private readonly regionUpdates: Subscription;\n\n  // ── The slice pane (the volume view's split): OSD editing one slice beside the 3D view ──\n  /** The div the slice pane renders into while it is wanted (null: no split). */\n  private sliceDiv: string | null = null;\n  /** Whether OSD is mounted in the slice pane: region, tool and overlay calls go to it. */\n  private sliceMounted = false;\n  /** The image the slice pane shows. */\n  private sliceFile: string | undefined;\n  /** Bumped per slice-pane mount or teardown, so only the latest one lands. */\n  private sliceRequest = 0;\n  /** The sections beside the split volume view (the planes x and y through the stack). */\n  private readonly sections: VolumeSections;\n  /** The z plane dragged in the volume: the slice to show (see {@link getSliceDrag$}). */\n  private readonly sliceDrag$ = new Subject<number>();\n  private readonly sectionSubs = new Subscription();\n  /** The image info and screen height of the last plot (what the slice pane mounts). */\n  private plottedInfo: IImageInfo | null = null;\n  /** The current region import (see regionImportTicket): its id and the image it was taken for. */\n  private importTicket: { id: number; image: string | undefined } = { id: 0, image: undefined };\n  private plottedHeight = 0;\n\n  constructor(\n    private plotly: PlotlyService,\n    private osd: OpenSeadragonVisualizerService,\n    private napari: NapariVisualizerService,\n    private store: VisualizerStore,\n    @Inject(VIZ_CONFIG) private config: VizConfig,\n    // Optional: a host that serves no spatial-omics data binds nothing,\n    // and `getSpatialControls()` then returns null.\n    private regionStore: RegionStore,\n    private selectionStore: SpatialSelectionStore,\n    private intensity: IntensityProfileService,\n    @Optional()\n    @Inject(SPATIAL_DATA_PORT)\n    private spatialData: SpatialDataPort | null = null,\n  ) {\n    this.regionUpdates = this.regionStore.getRegionUpdateEvent().subscribe(() => this.onRegionsChanged());\n    this.sections = new VolumeSections({\n      volume: () => this.napari.volumeVoxels(),\n      image: () => this.plottedFileName,\n      showPlanes: (planes) => this.napari.setSlicePlanes(planes),\n      outlinesByClass: (level) => this.regionStore.outlinesByClass(level),\n      isClassHidden: (label) => this.regionStore.isClassHidden(label),\n      colorOf: (label) => this.classColor(label),\n      channelStates: () => this.store.currentChannelStates(),\n      colormap: (st, multichannel) => {\n        // As the volume scene colours the channel (invert is applied before the colormap).\n        const display = {\n          colormap: this.store.currentColormap(),\n          reverse: this.store.currentReverseScale(),\n          invert: false,\n        };\n        return resolveColormap(\n          multichannel ? channelTintColormap(st?.color ?? '#ffffff', display) : volumeColormap(st, display),\n        );\n      },\n      invert: () => this.store.currentInvert(),\n      slice: () => this.currentZIndex,\n    });\n    // A plane dragged in the volume: the z plane picks the slice (through the host's slider, so\n    // the store and the slice pane follow), the others move their section.\n    this.sectionSubs.add(\n      this.napari.getSlicePlaneMove$().subscribe(({ axis, value }) => {\n        if (axis === 'z') this.sliceDrag$.next(Math.round(value));\n        else this.sections.setPlane(axis, value);\n      }),\n    );\n    this.sectionSubs.add(this.store.getChannelStates().subscribe(() => this.sections.schedule()));\n    this.sectionSubs.add(this.store.getInvert().subscribe(() => this.sections.schedule()));\n    this.sectionSubs.add(this.store.getColormap().subscribe(() => this.sections.schedule()));\n    this.sectionSubs.add(this.store.getReverseScale().subscribe(() => this.sections.schedule()));\n  }\n\n  /** A class's colour: its classification colour, else its region source's, else a default. */\n  private classColor(label: string): string {\n    return (\n      this.store.getClassificationColors().get(label) ??\n      this.regionStore.getRegionSourceView()?.colorOf({ label, color: null }) ??\n      '#ffcc00'\n    );\n  }\n\n  /** The sections beside the split volume view (nulls while it is not split). */\n  getSectionViews$(): Observable<SectionViews> {\n    return this.sections.getViews$();\n  }\n\n  /** Move a section's plane to `at` (image px). */\n  setSectionPlane(axis: SectionAxis, at: number): void {\n    this.sections.setPlane(axis, at);\n  }\n\n  /** The slice picked by dragging the z plane in the volume: the host shows it (its slider). */\n  getSliceDrag$(): Observable<number> {\n    return this.sliceDrag$.asObservable();\n  }\n\n  private isImageType(t: PlotType): boolean {\n    return t === PlotType.IMAGE;\n  }\n\n  /** The 2D napari types (image, region-centroid scatter, spatial omics) — a 2D fallback chain\n   *  (OSD, then Plotly).\n   *\n   *  NOTE for SPATIAL_OMICS: only napari-js draws the observation markers. If it fails (no WebGPU,\n   *  device loss) the fallback renders the tissue image ALONE — the spatial layer is absent, not\n   *  degraded. That is deliberate for now: showing the slide beats showing nothing, and a Plotly\n   *  `scattergl` spatial mode is the planned real fallback (see the plot-mode design doc). */\n  private isNapariImageType(t: PlotType): boolean {\n    return t === PlotType.NAPARI_IMAGE || isNapariScatter(t) || isSpatialOmics(t);\n  }\n\n  /** The 3D napari types (volume/isosurface/surface/scatter, plus the 3D spatial cloud) — no 2D\n   *  fallback exists (OSD is image-only), so they fall straight to Plotly. */\n  private isNapari3dType(t: PlotType): boolean {\n    return isNapari3d(t) || isSpatialOmics3d(t);\n  }\n\n  /**\n   * Backend to attempt for the current plot type this render. The fallback chains below are\n   * mirrored exactly by {@link load} so the handle `plot()` receives always comes from the\n   * backend `plot()` selects (no load/plot backend mismatch):\n   *  - 2D image (explicit `NAPARI_IMAGE`, or `IMAGE` with the WebGPU opt-in): napari-js → OSD → Plotly.\n   *  - plain `IMAGE` (no opt-in): OSD → Plotly.\n   *  - 3D napari (`NAPARI_VOLUME`/`NAPARI_ISOSURFACE`): napari-js → Plotly (OSD can't render 3D).\n   */\n  private imageBackend(): IViewerBackend {\n    const t = this.currentPlotType;\n    // 2D image with a napari-js attempt (explicit napari image, or opt-in on the Image type).\n    if (this.isNapariImageType(t) || (this.isImageType(t) && this.config.useNapariRenderer)) {\n      if (!this.napariFellBack) return this.napari;\n      if (!this.osdFellBack) return this.osd;\n      return this.plotly;\n    }\n    // Plain Image type (no napari opt-in): OSD, then Plotly.\n    if (this.isImageType(t)) {\n      return this.osdFellBack ? this.plotly : this.osd;\n    }\n    // 3D napari types: napari-js, with Plotly as the only viable fallback.\n    if (this.isNapari3dType(t)) {\n      return this.napariFellBack ? this.plotly : this.napari;\n    }\n    return this.plotly;\n  }\n\n  /** Backend currently on screen — what ongoing zoom/tool/region ops act on. */\n  private renderer(): IViewerBackend {\n    return this.lastRendered ?? this.plotly;\n  }\n\n  /**\n   * Backend region, tool and overlay calls act on: the slice pane's OSD while the volume view is\n   * split (regions are edited there), else the backend on screen. View calls (zoom, fit, colour,\n   * export) stay with {@link renderer}.\n   */\n  private regionBackend(): IViewerBackend {\n    return this.sliceMounted ? this.osd : this.renderer();\n  }\n\n  // System capabilities are Plotly's (the full-featured backend) so the UI\n  // keeps offering every plot type regardless of which one is on screen.\n  get capabilities(): ViewerCapabilities {\n    return this.plotly.capabilities;\n  }\n\n  // ── render / viewport → active renderer ──────────────────────────────\n  async load(imageInfo: IImageInfo, zIndex: number, signal?: AbortSignal): Promise<LoadedImage> {\n    // A stack can open away from slice 0 (`initialZIndex` — a volume opens\n    // mid-specimen), and that arrives here rather than through setZIndex.\n    this.currentZIndex = zIndex;\n    const backend = this.imageBackend();\n    if (backend === this.napari) {\n      try {\n        return await this.napari.load(imageInfo, zIndex, signal);\n      } catch (err) {\n        // Aborted: nobody wants this image any more, so don't go on to load it elsewhere.\n        if (signal?.aborted) throw err;\n        this.napariFellBack = true;\n        // Mirror imageBackend()'s fallback so load + plot pick the same backend:\n        //  - 3D napari types have no 2D fallback → straight to Plotly.\n        //  - 2D image → OSD, then Plotly.\n        if (this.isNapari3dType(this.currentPlotType)) {\n          console.warn('[visualizer] napari-js load failed — falling back to Plotly.', err);\n          return this.plotly.load(imageInfo, zIndex, signal);\n        }\n        console.warn('[visualizer] napari-js load failed — falling back to OpenSeadragon.', err);\n        return this.loadViaOsdThenPlotly(imageInfo, zIndex, signal);\n      }\n    }\n    if (backend === this.osd) {\n      return this.loadViaOsdThenPlotly(imageInfo, zIndex, signal);\n    }\n    return this.plotly.load(imageInfo, zIndex, signal);\n  }\n\n  /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */\n  private async loadViaOsdThenPlotly(\n    imageInfo: IImageInfo,\n    zIndex: number,\n    signal?: AbortSignal,\n  ): Promise<LoadedImage> {\n    try {\n      return await this.osd.load(imageInfo, zIndex, signal);\n    } catch (err) {\n      if (signal?.aborted) throw err;\n      console.warn('[visualizer] OpenSeadragon load failed — falling back to Plotly for this image.', err);\n      this.osdFellBack = true;\n      return this.plotly.load(imageInfo, zIndex, signal);\n    }\n  }\n  plot(\n    plotDiv: string,\n    imageLoaded: unknown,\n    imageInfo: IImageInfo,\n    screenHeight: number,\n    plotType: PlotType,\n    inPlace?: boolean,\n  ): Promise<boolean> {\n    this.currentPlotType = plotType;\n    this.volumeView$.next(isNapariVolume(plotType) || isNapariIsosurface(plotType));\n    this.plottedFileName = imageInfo?.fileName;\n    this.plottedInfo = imageInfo ?? null;\n    this.plottedHeight = screenHeight;\n    // The slice pane belongs to the volume view: another plot type takes it down (OSD may be\n    // about to draw the main view, which must not find the pane's viewer still mounted).\n    if (!this.volumeView$.value) this.unmountSlice();\n    // Region surfaces belong to the image they were built from: another image drops them.\n    if (this.classes3d$.value.length && this.plottedFileName !== this.classes3dImage) this.clearRegionClasses3d();\n    this.plotDiv = plotDiv;\n    // Apply the per-image region cache (snapshot old regions, restore the new\n    // image's, clear selection) for whichever backend renders — Plotly does\n    // this inside its own plot(), but OSD doesn't, so drive it here. Idempotent\n    // for the same image, so it's safe to call on every (re)plot.\n    this.plotly.setActiveImage(imageInfo);\n    const next = this.imageBackend();\n    // Both backends share the same div — tear down the outgoing one on switch.\n    // Plotly must be *purged* (not reset, which re-draws empty axes) before OSD\n    // takes the div.\n    if (this.lastRendered && this.lastRendered !== next) {\n      if (this.lastRendered === this.plotly) this.plotly.purgePlot();\n      else this.lastRendered.reset();\n    }\n    this.lastRendered = next;\n    const plotted = next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);\n    if (!this.sliceDiv || !this.volumeView$.value) return plotted;\n    // The split volume view: the slice pane follows the image (a new one, or its sharper pass).\n    return plotted.then((ok) => {\n      if (ok && (!this.sliceMounted || this.sliceFile !== imageInfo?.fileName || inPlace)) {\n        void this.mountSlice(!!inPlace && this.sliceMounted && this.sliceFile === imageInfo?.fileName);\n      }\n      // The volume was assembled again (another image, or resolution): cut the sections from it.\n      if (ok) this.sections.schedule();\n      return ok;\n    });\n  }\n\n  /**\n   * Split the volume view: show the slice being edited in `div` (OpenSeadragon, with every region\n   * tool) beside the 3D view, or stop (null). Kept across re-plots of a volume view; another plot\n   * type takes the pane down and a volume view brings it back. Resolves whether the pane shows.\n   */\n  async setSliceEditor(div: string | null): Promise<boolean> {\n    this.sliceDiv = div;\n    if (this.sliceEditor$.value !== !!div) this.sliceEditor$.next(!!div);\n    if (!div) {\n      this.unmountSlice();\n      return false;\n    }\n    return this.mountSlice(false);\n  }\n\n  /** Mount (or refresh in place) OSD in the slice pane on the displayed slice. */\n  private async mountSlice(inPlace: boolean): Promise<boolean> {\n    const div = this.sliceDiv;\n    const info = this.plottedInfo;\n    if (!div || !info?.urls?.length || !this.volumeView$.value) return false;\n    const request = ++this.sliceRequest;\n    try {\n      const loaded = await this.osd.load(info, this.currentZIndex);\n      if (request !== this.sliceRequest) return false;\n      const ok = await this.osd.plot(div, loaded, info, this.plottedHeight, PlotType.IMAGE, inPlace);\n      if (request !== this.sliceRequest) return false;\n      this.sliceMounted = ok;\n      this.sliceFile = info.fileName;\n      if (ok) {\n        // The slice may have moved while the pane loaded.\n        this.osd.setZIndex(this.currentZIndex);\n        this.trackLiveClasses();\n        this.sections.start();\n      }\n      return ok;\n    } catch (err) {\n      if (request === this.sliceRequest)\n        console.warn('[visualizer] The slice pane could not show the image.', err);\n      return false;\n    }\n  }\n\n  /** Take the slice pane's viewer down (the split stays wanted while {@link sliceDiv} is set). */\n  private unmountSlice(): void {\n    this.sliceRequest++;\n    if (this.sliceMounted) {\n      this.osd.reset();\n      this.sections.stop();\n    }\n    this.sliceMounted = false;\n    this.sliceFile = undefined;\n  }\n  reloadAndPlot(): void {\n    this.plotly.reloadAndPlot();\n  }\n  reset(): void {\n    // Start of a render cycle: re-enable napari-js/OSD attempts (clear any prior\n    // per-image fallback) and tear down whatever's on screen.\n    this.osdFellBack = false;\n    this.napariFellBack = false;\n    this.renderer().reset();\n  }\n  relayout(trueImageSize?: number[]): void {\n    this.renderer().relayout(trueImageSize);\n  }\n  resetAxes(): void {\n    this.renderer().resetAxes();\n  }\n  fitToView(): void {\n    this.renderer().fitToView();\n  }\n  /** @deprecated Use {@link fitToView}. */\n  autoscale(): void {\n    this.fitToView();\n  }\n  zoomIn(): void {\n    this.renderer().zoomIn();\n  }\n  zoomOut(): void {\n    this.renderer().zoomOut();\n  }\n  setDragMode(mode: string | false): void {\n    this.renderer().setDragMode(mode);\n    if (this.sliceMounted) this.osd.setDragMode(mode);\n  }\n  /** Every backend, on screen or not. */\n  private backends(): IViewerBackend[] {\n    return [this.plotly, this.osd, this.napari];\n  }\n\n  /**\n   * The navigator / smoothing options, applied to EVERY backend that has them (not\n   * just the active renderer): consumers set them before the first render, when\n   * `renderer()` is still the Plotly default, and OSD/napari-js must receive them\n   * to honour them at viewer creation.\n   */\n  getOsdViewOptions(): IOsdViewOptions {\n    return this.viewOptions;\n  }\n  private readonly viewOptions: IOsdViewOptions = {\n    setNavigatorVisible: (visible) => {\n      for (const b of this.backends()) b.getOsdViewOptions()?.setNavigatorVisible(visible);\n    },\n    setImageSmoothingEnabled: (enabled) => {\n      for (const b of this.backends()) b.getOsdViewOptions()?.setImageSmoothingEnabled(enabled);\n    },\n  };\n  /** @deprecated Use `getOsdViewOptions().setNavigatorVisible()`. */\n  setNavigatorVisible(visible: boolean): void {\n    this.viewOptions.setNavigatorVisible(visible);\n  }\n  /** @deprecated Use `getOsdViewOptions().setImageSmoothingEnabled()`. */\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.viewOptions.setImageSmoothingEnabled(enabled);\n  }\n  setShowStack(showstack: boolean): void {\n    this.renderer().setShowStack(showstack);\n  }\n  setZIndex(zIndex: number): void {\n    this.currentZIndex = zIndex;\n    this.renderer().setZIndex(zIndex);\n    if (this.sliceMounted) {\n      this.osd.setZIndex(zIndex);\n      this.sections.schedule();\n    }\n  }\n  getTrueImageSize(): { width: number; height: number } | null {\n    return this.renderer().getTrueImageSize();\n  }\n  getCurrentImage(): Promise<Image | null> {\n    return this.renderer().getCurrentImage();\n  }\n  getDisplayedPixelData(): PixelData | null {\n    return this.renderer().getDisplayedPixelData();\n  }\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    return this.renderer().getDisplayedSourceRect();\n  }\n  downloadImage(): void {\n    this.renderer().downloadImage();\n  }\n  exportComposite(): void {\n    this.renderer().exportComposite();\n  }\n\n  setPlotType(plotType: PlotType): void {\n    this.currentPlotType = plotType;\n    this.volumeView$.next(isNapariVolume(plotType) || isNapariIsosurface(plotType));\n    this.plotly.setPlotType(plotType);\n  }\n  /** @deprecated Use `getSurface3dControls()`. */\n  setSurfaceDragMode(mode: string): void {\n    this.getSurface3dControls()?.setSurfaceDragMode(mode);\n  }\n  /** @deprecated Use `getSurface3dControls()`. */\n  resetSurfaceCamera(): void {\n    this.getSurface3dControls()?.resetSurfaceCamera();\n  }\n  /** The 3D decimate factor of the backend on screen (napari-js), else null. */\n  getVolumeResolution(): IVolumeResolution | null {\n    return this.renderer().getVolumeResolution();\n  }\n  /** @deprecated Use `getVolumeResolution()?.set()`. */\n  setResolutionScale(scale: number): void {\n    this.getVolumeResolution()?.set(scale);\n  }\n  /** @deprecated Use `getVolumeResolution()?.get()`. */\n  getResolutionScale(): number {\n    return this.getVolumeResolution()?.get() ?? 1;\n  }\n  /** The viewport of the backend on screen, for a contributed plot mode. Null\n   *  when that backend cannot provide one (e.g. OSD fell back to Plotly). */\n  getPlotModeViewport(): PlotModeViewport | null {\n    return this.renderer().getPlotModeViewport?.() ?? null;\n  }\n  getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    // Plotly enumerates the full PLOT_TYPE_DESCRIPTORS map, which already includes the\n    // napari-js WebGPU types (jit-ui#102) — so this single source covers them (no duplicates).\n    return this.plotly.getPlotTypeDescriptors();\n  }\n\n  // ── long-lived observables + stack flags ──────────────────────────────────\n  setStackLoading(b: boolean): void {\n    this.plotly.setStackLoading(b);\n  }\n  // Cancel in-flight loading on every backend — the user's Cancel shouldn't depend on which one is\n  // active. Only backends that stream frames (napari-js) do real work; the rest no-op. The concrete\n  // backend classes don't all declare the optional contract method, so call it via IViewerBackend.\n  cancelLoading(): void {\n    for (const backend of [this.plotly, this.osd, this.napari] as IViewerBackend[]) {\n      backend.cancelLoading?.();\n    }\n  }\n  // Loading state is surfaced from whichever backend is doing the work: OSD and napari-js (volume\n  // assembly) drive their own subjects, so merge all three into one stable stream the host\n  // subscribes to once. (Previously hardcoded to Plotly, so napari/OSD progress never showed.)\n  isStackLoading(): Observable<boolean> {\n    return combineLatest([\n      this.plotly.isStackLoading(),\n      this.osd.isStackLoading(),\n      this.napari.isStackLoading(),\n    ]).pipe(map((flags) => flags.some(Boolean)));\n  }\n  getStackLoadingProgress(): Observable<number> {\n    // Report the progress of whichever backend is ACTIVELY loading (max across active ones). A plain\n    // merge let an idle backend's stale value win the stream on a re-load — leaving the bar below the\n    // active backend's real progress (e.g. stuck ~⅓ while the % read 100). Gating by the loading flag\n    // ignores idle backends, so the bar tracks the one doing the work and reaches 100%.\n    const track = (v: IViewerBackend): Observable<[number, boolean]> =>\n      combineLatest([v.getStackLoadingProgress(), v.isStackLoading()]);\n    return combineLatest([track(this.plotly), track(this.osd), track(this.napari)]).pipe(\n      map((pairs) => {\n        const active = pairs.filter(([, loading]) => loading).map(([p]) => p);\n        return active.length ? Math.max(...active) : 0;\n      }),\n    );\n  }\n  // Every backend fits to view on its own (Plotly's autoscale, OSD's goHome, napari's camera\n  // fit) and each emits from its own subject, so merge all three: listening to Plotly alone\n  // missed the context-menu Autoscale on the Image and napari views.\n  getAutoscaleEvent(): Observable<void> {\n    return merge(\n      this.plotly.getAutoscaleEvent(),\n      this.osd.getAutoscaleEvent(),\n      this.napari.getAutoscaleEvent(),\n    ).pipe(map(() => undefined));\n  }\n  /** The line-ROI profiles: sampled by the backend-neutral IntensityProfileService. */\n  getIntensityProfile$(): Observable<IntensityProfile[]> {\n    return this.intensity.getIntensityProfile$();\n  }\n  // The intensity inset is a Plotly LINE chart — render it through Plotly whichever\n  // backend draws the main image.\n  renderIntensityInset(divId: string, profiles: IntensityProfile[]): void {\n    this.plotly.renderIntensityInset(divId, profiles);\n  }\n\n  // ── regions ──────────────────────────────────────────────────────────\n  // Region state lives in the shared RegionStore, so every read and write goes\n  // straight to it. Every backend draws from the store's events: the OSD and\n  // napari-js overlays and Plotly's shape projection redraw on its region-update\n  // and selection streams, and the canvas tools reset on getRegionSetReplaced$\n  // (undo, redo, a slice switch).\n  setRegions(\n    regions: Region[],\n    showRegionLabel?: boolean,\n    isRegionSaveOn?: boolean,\n    fillColor?: string,\n    append?: boolean,\n  ): void {\n    this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);\n  }\n  getRegions(): Region[] {\n    return this.regionStore.getRegions();\n  }\n  getRegionPolygons(): Polygon[] {\n    return this.regionStore.getRegionPolygons();\n  }\n  getRegionUpdateEvent(): Observable<Region[]> {\n    return this.regionStore.getRegionUpdateEvent();\n  }\n  setSelectedShapeIndices(indices: number[]): void {\n    this.regionStore.setSelectedShapeIndices(indices);\n  }\n  selectRegion(region: Region): void {\n    this.regionStore.selectRegion(region);\n  }\n  getSelectedShapeIndices$(): Observable<number[]> {\n    return this.regionStore.getSelectedShapeIndices$();\n  }\n  deleteActiveShape(): void {\n    this.regionStore.deleteActiveShape();\n  }\n  getShowShapeLabel(): boolean {\n    return this.regionStore.getShowShapeLabel();\n  }\n  getShapeColor(): string {\n    return this.regionStore.getShapeColor();\n  }\n  getFillColor(): string {\n    return this.regionStore.getFillColor();\n  }\n  getClassificationColors(): Map<string, string> {\n    return this.store.getClassificationColors();\n  }\n  setClassificationColor(label: string, color: string): void {\n    this.store.setClassificationColor(label, color);\n  }\n  // Annotation-class presets live in the shared VisualizerStore (backend-neutral\n  // session state), so route straight to it rather than through renderer(). (jit-ui#70)\n  getPresetSet(): PresetSet {\n    return this.store.getPresetSet();\n  }\n  getPresetSet$(): Observable<PresetSet> {\n    return this.store.getPresetSet$();\n  }\n  setPresetSet(set: PresetSet): void {\n    this.store.setPresetSet(set);\n  }\n  upsertClass(preset: ClassPreset): void {\n    this.store.upsertClass(preset);\n  }\n  removeClass(name: string): void {\n    this.store.removeClass(name);\n  }\n  resetPresets(): void {\n    this.store.resetPresets();\n  }\n  undo(): void {\n    this.regionStore.undo();\n  }\n  redo(): void {\n    this.regionStore.redo();\n  }\n  canUndo(): boolean {\n    return this.regionStore.canUndo();\n  }\n  canRedo(): boolean {\n    return this.regionStore.canRedo();\n  }\n  getCanUndo$(): Observable<boolean> {\n    return this.regionStore.getCanUndo$();\n  }\n  getCanRedo$(): Observable<boolean> {\n    return this.regionStore.getCanRedo$();\n  }\n  resetUndoHistory(): void {\n    this.regionStore.resetUndoHistory();\n  }\n  importRegions(geoJsonStr: string): Region[] {\n    return this.regionStore.importRegions(geoJsonStr);\n  }\n  /** Download `regions` as GeoJSON, named after the image last plotted. */\n  exportRegions(regions: Region[]): void {\n    this.regionStore.exportRegions(regions, this.plottedFileName);\n  }\n  getGeoJsonString(regions: Region[]): string {\n    return this.regionStore.getGeoJsonString(regions);\n  }\n\n  /** Hold a large region set as a tiled region source (see RegionStore.attachRegionSource). */\n  attachRegionSource(source: RegionSource | RegionSourceOpener, slices?: RegionSourceSlices): void {\n    this.regionStore.attachRegionSource(source, slices);\n  }\n  async importRegionSource(geoJsonStr: string): Promise<boolean> {\n    if (geoJsonStr.length < (this.config?.regionSourceMinChars ?? REGION_SOURCE_MIN_CHARS)) return false;\n    let opened: RegionSource | null = await openGeoJsonRegionSource(geoJsonStr);\n    // The first open is the one just made; a source closed to save memory parses again.\n    this.regionStore.attachRegionSource(() => {\n      const source = opened;\n      opened = null;\n      return source ? Promise.resolve(source) : openGeoJsonRegionSource(geoJsonStr);\n    });\n    return true;\n  }\n  dropRegionSource(): Promise<void> {\n    return this.regionStore.dropSliceRegionSource();\n  }\n\n  /**\n   * A ticket for a region import that is about to read or decode its files: the import methods\n   * given it change nothing once it is stale — another import took a ticket since, another image\n   * was plotted, or the service was destroyed — so an import that finishes late never lands on an\n   * image it was not started for.\n   */\n  regionImportTicket(): number {\n    this.importTicket = { id: this.importTicket.id + 1, image: this.importImageKey() };\n    return this.importTicket.id;\n  }\n\n  /** Whether `ticket` is still the current import's, on the image it was taken for. */\n  private importTicketValid(ticket: number): boolean {\n    return ticket === this.importTicket.id && this.importTicket.image === this.importImageKey();\n  }\n\n  private importImageKey(): string | undefined {\n    return RegionScopeCache.imageKey(this.plottedInfo ?? undefined);\n  }\n\n  /**\n   * Replace the image's regions and region sources with one source per slice, as an imported label\n   * volume or folder of per-slice region files gives them: `openers` by slice index, each opened\n   * the first time its slice is shown. A single image takes slice 0's. Returns how many slices\n   * have a source, or null (changing nothing) when `ticket` is stale (see\n   * {@link regionImportTicket}). The sources are marked imported, so a save writes every slice.\n   */\n  importSliceRegionSources(openers: ReadonlyMap<number, RegionSourceOpener>, ticket?: number): number | null {\n    if (ticket !== undefined && !this.importTicketValid(ticket)) return null;\n    this.regionImportTicket(); // supersedes any import still in flight\n    const info = this.plottedInfo;\n    this.regionStore.detachRegionSources();\n    if (!info?.isStack) {\n      const first = openers.get(0) ?? openers.values().next().value;\n      this.regionStore.setRegions([]);\n      this.regionStore.resetUndoHistory();\n      if (!first) return 0;\n      this.regionStore.attachRegionSource(first, { slice: 0 }, true);\n      return 1;\n    }\n    this.enterImportedStack(info);\n    for (const [z, open] of openers) this.regionStore.attachRegionSource(open, { slice: z }, true);\n    return openers.size;\n  }\n\n  /**\n   * Replace the image's regions and region sources with one imported source (a region set the\n   * host's server serves): over every slice of a stack when it is z-indexed, else on the slice\n   * shown, as {@link applyImageRois} lays out an image's own. Resolves false, changing nothing\n   * (and disposing the source), when the import went stale while it opened: another import, or\n   * another image (see {@link regionImportTicket}; one is taken here when `ticket` is not given).\n   */\n  async importRegionSourceOpener(open: RegionSourceOpener, ticket?: number): Promise<boolean> {\n    const mine = ticket ?? this.regionImportTicket();\n    if (!this.importTicketValid(mine)) return false;\n    let first: RegionSource | null = await open();\n    if (!this.importTicketValid(mine)) {\n      first.dispose();\n      return false;\n    }\n    const reuse: RegionSourceOpener = () => {\n      const source = first;\n      first = null;\n      return source ? Promise.resolve(source) : open();\n    };\n    const info = this.plottedInfo;\n    const planes = first.info.planes;\n    const zIndexed = !!info?.isStack && planes.some((p) => p !== 0);\n    this.regionStore.detachRegionSources();\n    if (zIndexed) {\n      this.enterImportedStack(info as IImageInfo);\n      this.regionStore.attachRegionSource(reuse, 'planes', [...planes]);\n      return true;\n    }\n    this.regionStore.setRegions([]);\n    this.regionStore.resetUndoHistory();\n    this.regionStore.attachRegionSource(reuse, { slice: this.regionStore.getDisplaySlice() }, true);\n    return true;\n  }\n\n  /** Empty every slice of a stack (its regions and undo history) for regions imported over it. */\n  private enterImportedStack(info: IImageInfo): void {\n    const layout = this.regionStore.isStackMode()\n      ? this.regionStore.getStackSaveLayout()\n      : info.tiled === false\n        ? 'per-slice-file'\n        : 'combined';\n    this.regionStore.enterStackMode(new Map(), this.regionStore.getDisplaySlice(), layout);\n  }\n  getRegionSourceView$(): Observable<RegionSourceView | null> {\n    return this.regionStore.getRegionSourceView$();\n  }\n  getRegionSourceIndex(query: Omit<RegionIndexQuery, 'exclude'>): Promise<RegionIndexPage> {\n    return this.regionStore.getRegionSourceIndex(query);\n  }\n  selectSourceFeatures(ids: readonly string[], additive?: boolean): Promise<number[]> {\n    return this.regionStore.selectSourceFeatures(ids, additive);\n  }\n  deleteSourceFeatures(ids: readonly string[]): void {\n    this.regionStore.deleteSourceFeatures(ids);\n  }\n  getRegionStyle$(): Observable<RegionStyle> {\n    return this.regionStore.getRegionStyle$();\n  }\n  setRegionStyle(patch: Partial<RegionStyle>): void {\n    this.regionStore.setRegionStyle(patch);\n  }\n  // ── Regions in 3D: their reconstructions shown in the volume view ─────\n\n  /** Whether a napari volume (or isosurface) view is on screen: regions can be shown in 3D. */\n  getVolumeView$(): Observable<boolean> {\n    return this.volumeView$.asObservable();\n  }\n\n  /** Whether the volume view's slice pane is wanted (it shows while a volume view is on screen). */\n  getSliceEditor$(): Observable<boolean> {\n    return this.sliceEditor$.asObservable();\n  }\n\n  /** Whether the volume view draws the region reconstructions through the volume. */\n  getRegionsThroughVolume$(): Observable<boolean> {\n    return this.regionsThroughVolume$.asObservable();\n  }\n\n  /**\n   * Draw the region reconstructions through the volume (it hides none of them: surfaces inside its\n   * bright structures, an OCT's layer boundaries) or hidden behind what it shows (the default).\n   */\n  setRegionsThroughVolume(through: boolean): void {\n    if (this.regionsThroughVolume$.value === through) return;\n    this.regionsThroughVolume$.next(through);\n    this.napari.setRegionsThroughVolume(through);\n  }\n\n  /** The class groups shown in 3D on this image ([] after a switch to another image). */\n  getRegionClasses3d$(): Observable<ReadonlyArray<{ key: string; classes: readonly string[] }>> {\n    return this.classes3d$.asObservable();\n  }\n\n  /** Hide every region surface and forget them (a build still running is dropped). */\n  private clearRegionClasses3d(): void {\n    this.meshRequest++;\n    this.shown3d = [];\n    this.classes3d$.next([]);\n    this.classes3dImage = undefined;\n    this.napari.setRegionMeshes([], undefined);\n    this.napari.setRegionHighlight([]);\n  }\n\n  /** Highlight the surfaces of these group keys in the volume view (none: all as usual). */\n  highlightRegionClasses3d(keys: readonly string[]): void {\n    this.napari.setRegionHighlight(keys);\n  }\n\n  /** A surface clicked in the volume view with the selection tool (its group key), or none (null). */\n  getRegionPicked3d$(): Observable<{ key: string | null; additive: boolean }> {\n    return this.napari.getRegionMeshPick$();\n  }\n\n  /**\n   * Show these groups of classes in the volume view as 3D reconstructions (each group one surface\n   * in its colour: an atlas structure with its substructures), and only these; [] hides them.\n   * Reconstructed from every slice's outlines at the volume's resolution, cached per image.\n   */\n  async showRegionClasses3d(\n    groups: ReadonlyArray<{ key: string; classes: readonly string[]; color: string; label?: string }>,\n  ): Promise<void> {\n    const request = ++this.meshRequest;\n    this.classes3dImage = this.plottedFileName;\n    this.shown3d = groups;\n    // What an edit from now on is compared with (the live slice may not have changed yet).\n    this.liveClasses = null;\n    this.trackLiveClasses();\n    this.classes3d$.next(groups.map((g) => ({ key: g.key, classes: g.classes })));\n    const width = this.getTrueImageSize()?.width ?? 1024;\n    const step = this.napari.regionVoxelStep() ?? Math.max(1, width / 256);\n    const image = this.plottedFileName ?? '';\n    const cacheKey = (g: { classes: readonly string[] }) => `${image}|${step.toFixed(3)}|${g.classes.join(',')}`;\n    const missing = groups.filter((g) => !this.meshCache.has(cacheKey(g)));\n    if (missing.length) {\n      const names = missing.map((g) => g.key);\n      const what = names.length > 3 ? `${names.length} regions` : names.join(', ');\n      const done = this.napari.beginTask(`Building ${what} in 3D…`);\n      try {\n        const built = await this.regionStore.reconstructClasses(\n          missing.map((g) => ({ key: cacheKey(g), classes: g.classes })),\n          step,\n        );\n        const classesOf = new Map(missing.map((g) => [cacheKey(g), g.classes]));\n        for (const b of built) this.meshCache.set(b.key, { mesh: b.mesh, classes: classesOf.get(b.key) ?? [] });\n      } finally {\n        done();\n      }\n    }\n    if (request !== this.meshRequest) return;\n    this.napari.setRegionMeshes(\n      groups.map((g) => {\n        const mesh = this.meshCache.get(cacheKey(g))!.mesh;\n        return { key: g.key, color: g.color, label: g.label, vertices: mesh.vertices, faces: mesh.faces };\n      }),\n      this.plottedFileName,\n    );\n  }\n\n  /**\n   * The regions changed: when the live slice's regions of some classes did (an edit, an undo, not\n   * a slice or image switch), their reconstructions are stale. They are dropped, and those shown\n   * in 3D are rebuilt once the edits pause.\n   */\n  private onRegionsChanged(): void {\n    // Nothing follows the edits (no surface built or shown, no sections): skip the fingerprints.\n    if (!this.sliceMounted && !this.shown3d.length && !this.meshCache.size) {\n      this.liveClasses = null;\n      return;\n    }\n    const before = this.liveClasses;\n    this.liveClasses = null;\n    const now = this.trackLiveClasses();\n    // Another slice or image came up: no region changed (the sections recut for the slice).\n    if (!before || before.at !== now.at) return;\n    const changed = changedClasses(before.signatures, now.signatures);\n    // Source features deleted (or that undone) change no live region, and which classes they were\n    // is not known here: every class is stale. A feature taken shows as its class's change.\n    const everyClass = !changed.size && before.sources !== now.sources;\n    if (!changed.size && !everyClass) return;\n    const touched = (c: string) => everyClass || changed.has(c);\n    if (this.sliceMounted) this.sections.regionsChanged();\n    for (const [key, entry] of [...this.meshCache]) {\n      if (entry.classes.some(touched)) this.meshCache.delete(key);\n    }\n    if (!this.shown3d.some((g) => g.classes.some(touched))) return;\n    if (this.rebuildTimer) clearTimeout(this.rebuildTimer);\n    this.rebuildTimer = setTimeout(() => {\n      this.rebuildTimer = null;\n      if (this.shown3d.length && this.classes3dImage === this.plottedFileName) {\n        void this.showRegionClasses3d(this.shown3d);\n      }\n    }, REGION_SURFACE_REBUILD_MS);\n  }\n\n  /** Fingerprint the live slice's classes, unless already: what the next edit is compared with. */\n  private trackLiveClasses(): { at: string; signatures: Map<string, number>; sources: string } {\n    this.liveClasses ??= {\n      at: this.liveSliceKey(),\n      signatures: classSignatures(this.regionStore.getRegions()),\n      sources: this.regionStore.getSourceStateKey(),\n    };\n    return this.liveClasses;\n  }\n\n  /** Which slice of which image the live regions are. */\n  private liveSliceKey(): string {\n    return `${this.regionStore.getDisplaySlice()}\\n${this.plottedFileName ?? ''}`;\n  }\n\n  /** Each class's volume over the whole stack, in px² × slices (see RegionStore.classVolumes). */\n  async getClassVolumes(classes: readonly string[]): Promise<Record<string, number>> {\n    return Object.fromEntries(await this.regionStore.classVolumes(classes));\n  }\n\n  getRegionSourceClassCounts(stack?: boolean): Promise<Record<string, number>> {\n    return this.regionStore.getRegionSourceClassCounts(stack);\n  }\n  getHiddenClasses$(): Observable<ReadonlySet<string>> {\n    return this.regionStore.getHiddenClasses$();\n  }\n  setClassesHidden(classes: readonly string[], hidden: boolean): void {\n    this.regionStore.setClassesHidden(classes, hidden);\n    // A surface is its class's (its group key is the class name).\n    this.napari.setRegionHidden([...this.regionStore.getHiddenClasses()]);\n    this.sections.schedule();\n  }\n  async selectRegionClasses(classes: readonly string[], additive?: boolean): Promise<void> {\n    await this.regionStore.selectClasses(classes, additive);\n  }\n  getGeoJsonStringWithSource(regions: Region[], slice?: number): Promise<string> {\n    return this.regionStore.getGeoJsonWithSource(regions, slice);\n  }\n\n  // ── Per-slice z-stack regions (jit-ui#93), from the shared RegionStore. ──\n  enterStackMode(\n    slices: Map<number, Region[]>,\n    initialZ?: number,\n    saveLayout?: 'combined' | 'per-slice-file',\n  ): void {\n    this.regionStore.enterStackMode(slices, initialZ, saveLayout);\n  }\n  exitStackMode(): void {\n    this.regionStore.exitStackMode();\n  }\n  isStackMode(): boolean {\n    return this.regionStore.isStackMode();\n  }\n  /** The slice the regions are shown for (recorded outside stack mode too). */\n  getDisplaySlice(): number {\n    return this.regionStore.getDisplaySlice();\n  }\n  getStackSaveLayout(): 'combined' | 'per-slice-file' {\n    return this.regionStore.getStackSaveLayout();\n  }\n  setDisplaySlice(z: number): void {\n    this.regionStore.setDisplaySlice(z);\n  }\n  getSliceRegions(): Region[] {\n    return this.regionStore.getSliceRegions();\n  }\n  getStackSaveSlices(): Map<number, Region[]> {\n    return this.regionStore.getStackSaveSlices();\n  }\n  /** All slices' ANNOTATION regions for a z-stack save (jit-ui#93), each tagged\n   *  with its zero-based Region.z; profile lines excluded. Flat annotation set\n   *  outside stack mode. */\n  getSliceAnnotationRegions(): Region[] {\n    return this.regionStore.getSliceRegions().filter((r) => !isProfileRegion(r));\n  }\n  /** Per-slice annotation regions to write on a folder-stack save (jit-ui#93):\n   *  slice index → that slice's annotation regions (profile lines excluded),\n   *  including now-empty slices that were loaded non-empty (so they overwrite). */\n  getStackSaveAnnotationSlices(): Map<number, Region[]> {\n    const out = new Map<number, Region[]>();\n    for (const [z, regs] of this.regionStore.getStackSaveSlices()) {\n      out.set(\n        z,\n        regs.filter((r) => !isProfileRegion(r)),\n      );\n    }\n    return out;\n  }\n\n  /** Authoritative full-resolution image size for mask export. Prefers the\n   *  active renderer's reported size, falling back to the image metadata (x/y\n   *  are the full-res pixel dimensions used across the app). Rejects non-finite\n   *  or non-positive sizes — the Plotly bounds can yield NaN before a plot is\n   *  fully laid out, which would otherwise crash mask creation. */\n  getMaskImageSize(): { width: number; height: number } | null {\n    const valid = (s: { width: number; height: number } | null | undefined) =>\n      s && Number.isFinite(s.width) && Number.isFinite(s.height) && s.width >= 1 && s.height >= 1\n        ? { width: Math.round(s.width), height: Math.round(s.height) }\n        : null;\n\n    const fromRenderer = valid(this.getTrueImageSize());\n    if (fromRenderer) return fromRenderer;\n\n    let meta: IImageMetadata[] = [];\n    this.getImageMeta()\n      .subscribe((m) => (meta = m))\n      .unsubscribe();\n    const m0 = meta?.[0];\n    return m0 ? valid({ width: m0.x, height: m0.y }) : null;\n  }\n\n  // ── IRegionEditorApi: annotation-only surface for the Region Editor ───\n  // Intensity-profile lines (kind='profile') belong to the intensity tool, not\n  // the editor. These methods give external consumers an annotation-only view\n  // and guarantee profile lines are preserved. The writes land in the store like\n  // any other, and every backend redraws from its events.\n\n  getAnnotationRegions(): Region[] {\n    return this.regionStore.getRegions().filter((r) => !isProfileRegion(r));\n  }\n  setAnnotationRegions(\n    regions: Region[],\n    showRegionLabel?: boolean,\n    isRegionSaveOn?: boolean,\n    fillColor?: string,\n  ): void {\n    // Re-append the store's profile lines so an editor save/delete can't drop them.\n    const profiles = this.regionStore.getRegions().filter((r) => isProfileRegion(r));\n    const annotations = (regions || []).filter((r) => !isProfileRegion(r));\n    this.setRegions([...annotations, ...profiles], showRegionLabel, isRegionSaveOn, fillColor, false);\n  }\n  getSelectedRegions$(): Observable<Region[]> {\n    // Map the internal index-based selection to the selected annotation regions.\n    return this.getSelectedShapeIndices$().pipe(\n      map((idxs) => {\n        const regs = this.regionStore.getRegions();\n        return idxs.map((i) => regs[i]).filter((r): r is Region => !!r && !isProfileRegion(r));\n      }),\n    );\n  }\n  setSelectedRegions(regions: Region[]): void {\n    const regs = this.regionStore.getRegions();\n    const indices = (regions || []).map((r) => regs.findIndex((x) => x.id === r.id)).filter((i) => i >= 0);\n    this.setSelectedShapeIndices(indices);\n  }\n\n  // ── tools → active renderer (run on either backend) ─────────────────\n  // The wand, vertex eraser and zoom-to-box are implemented on both backends\n  // via ICoordinateTransform (+ a viewport pixel readback for the wand), so they\n  // follow the active renderer — the slice pane's while the volume view is split.\n  setActiveTool(id: string | null, options?: CanvasToolOptions): void {\n    this.regionBackend().setActiveTool(id, options);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setWandMode(active: boolean, options?: IWandOptions): void {\n    this.regionBackend().setWandMode(active, options);\n  }\n  setWandOptions(options: IWandOptions): void {\n    this.regionBackend().setWandOptions(options);\n  }\n  clearActiveWandRegion(): void {\n    this.regionBackend().clearActiveWandRegion();\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setBrushMode(active: boolean, options?: IBrushOptions): void {\n    this.regionBackend().setBrushMode(active, options);\n  }\n  setBrushOptions(options: IBrushOptions): void {\n    this.regionBackend().setBrushOptions(options);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setVertexEraserMode(active: boolean): void {\n    this.regionBackend().setVertexEraserMode(active);\n  }\n  setVertexEraserRadius(radius: number): void {\n    this.regionBackend().setVertexEraserRadius(radius);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setZoomToBoxMode(active: boolean): void {\n    this.regionBackend().setZoomToBoxMode(active);\n  }\n  segmentRectangles(): Promise<number> {\n    return this.regionBackend().segmentRectangles();\n  }\n  segmentRectanglesCellpose(): Promise<number> {\n    return this.regionBackend().segmentRectanglesCellpose();\n  }\n  setSamModel(id: string): void {\n    this.regionBackend().setSamModel(id);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setSamPointMode(active: boolean): void {\n    this.regionBackend().setSamPointMode(active);\n  }\n  commitSamPoints(): void {\n    this.regionBackend().commitSamPoints();\n  }\n  clearSamPoints(): void {\n    this.regionBackend().clearSamPoints();\n  }\n\n  // ── display options ──────────────────────────────────────────────────\n  // State lives in the shared VisualizerStore — reads go straight to it.\n  // The two SETTERS still route through Plotly because its implementations\n  // carry render glue beyond the store write (a live Plotly.restyle of\n  // colorscale/reversescale on the mounted heatmap); OSD recolors via its own\n  // store subscription either way.\n  getColormap(): Observable<ColormapNode | null> {\n    return this.store.getColormap();\n  }\n  setColormap(colormap: ColormapNode): void {\n    this.plotly.setColormap(colormap);\n  }\n  getColormapOptions(): ColormapNode[] {\n    return this.store.getColormapOptions();\n  }\n  getReverseScale(): Observable<boolean> {\n    return this.store.getReverseScale();\n  }\n  setReverseScale(reverse: boolean): void {\n    this.plotly.setReverseScale(reverse);\n  }\n  setImageMeta(imageMeta: IImageMetadata[], imageKey?: string): void {\n    this.store.setImageMeta(imageMeta, imageKey);\n  }\n  getImageMeta(): Observable<IImageMetadata[]> {\n    return this.store.getImageMeta();\n  }\n\n  // ── IChannelHistogramApi: Channels & Histogram pane surface ───────────\n  // Channel/grayscale/invert state lives in the shared VisualizerStore; both\n  // backends subscribe and recolor live, so setters just write the store. The\n  // histogram comes from whichever backend is on screen (its native pixels).\n  getHistogram(channelIndex: number, bins: number): IHistogram | null {\n    return this.renderer().getHistogram(channelIndex, bins);\n  }\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    return this.renderer().getHistogram$(channelIndex, bins);\n  }\n  /** Export the underlying data (16-bit multi-band TIFF) via the active backend. */\n  exportData(): void {\n    this.renderer().exportData();\n  }\n  getChannels$(): Observable<IChannelState[]> {\n    return this.store.getChannelStates();\n  }\n  setSelectedChannel(index: number): void {\n    this.store.setSelectedChannel(index);\n  }\n  setChannelState(index: number, partial: Partial<IChannelState>): void {\n    this.store.setChannelState(index, partial);\n  }\n  resetContrast(indices: number[]): void {\n    // Full reset: window (0..255), gamma (1) AND the channel's default tint.\n    for (const i of indices) this.store.resetChannelState(i);\n  }\n  /** Auto-window each channel by saturating `saturation` (0..1) of pixels at each\n   *  end of its histogram (skipping outlier first/last bins). */\n  autoContrast(indices: number[], saturation: number): void {\n    for (const i of indices) {\n      const h = this.renderer().getHistogram(i, 256);\n      if (!h) continue;\n      const [min, max] = autoWindowFromHistogram(h, saturation, [0, 255]);\n      if (max > min) this.store.setChannelState(i, { min, max });\n    }\n  }\n  getGrayscale$(): Observable<boolean> {\n    return this.store.getGrayscale();\n  }\n  setGrayscale(on: boolean): void {\n    this.store.setGrayscale(on);\n  }\n  getInvert$(): Observable<boolean> {\n    return this.store.getInvert();\n  }\n  setInvert(on: boolean): void {\n    this.store.setInvert(on);\n  }\n\n  /**\n   * The active backend's region overlay (the slice pane's while the volume view is split). Falls\n   * back to Plotly's when the active backend\n   * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a\n   * usable overlay.\n   */\n  getRegionOverlay(): IRegionOverlay {\n    const r = this.regionBackend();\n    if (r === this.osd) {\n      return this.osd.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    if (r === this.napari) {\n      return this.napari.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    return this.plotly.getRegionOverlay();\n  }\n\n  /** Isosurface controls of the backend on screen, when it renders isosurfaces. */\n  getIsosurfaceControls(): IIsosurfaceControls | null {\n    return this.renderer().getIsosurfaceControls();\n  }\n\n  /** 3D scene controls of the backend on screen (Plotly or napari-js), or null on a\n   *  2D-only one. */\n  getSurface3dControls(): ISurface3dControls | null {\n    return this.renderer().getSurface3dControls();\n  }\n\n  /** Intensity (line-ROI) controls, whichever backend draws the image: the\n   *  IntensityProfileService adds the line to the store, and every backend\n   *  (Plotly included) draws it from the store's update event. */\n  getIntensityControls(): IIntensityControls | null {\n    return this.intensity;\n  }\n\n  /**\n   * Spatial-omics controls, or null when no `SPATIAL_DATA_PORT` is bound. Served by a\n   * backend-neutral {@link SpatialControlsFacade} (state in the shared stores), so the\n   * controls work across a plot-type switch and before any backend has mounted.\n   */\n  getSpatialControls(): ISpatialControls | null {\n    if (!this.spatialData) return null;\n    this.spatialFacade ??= new SpatialControlsFacade(this.spatialData, {\n      store: this.store,\n      regionStore: this.regionStore,\n      selectionStore: this.selectionStore,\n      napari: this.napari,\n      plotType: () => this.currentPlotType,\n      zIndex: () => this.currentZIndex,\n    });\n    return this.spatialFacade.controls;\n  }\n\n  /** Created on first use; owns the dataset subscription. */\n  private spatialFacade: SpatialControlsFacade | null = null;\n  /** Displayed slice. Only a volume-backed spatial dataset reads it, to keep a\n   *  region drawn over one section from selecting the whole depth behind it. */\n  private currentZIndex = 0;\n\n  /** Angular calls this when the injector providing the router is destroyed — the host\n   *  component for a `provideVisualization()` chain. The dataset subscription would\n   *  otherwise keep the whole isolated chain reachable from the root data port. */\n  ngOnDestroy(): void {\n    this.importTicket = { id: this.importTicket.id + 1, image: undefined }; // a late import changes nothing\n    this.spatialFacade?.dispose();\n    this.spatialFacade = null;\n    this.regionUpdates.unsubscribe();\n    this.sectionSubs.unsubscribe();\n    this.sections.stop();\n    if (this.rebuildTimer) clearTimeout(this.rebuildTimer);\n  }\n\n  /**\n   * Intensity-profile sampling, whichever backend is on screen: the sampling is the\n   * backend-neutral IntensityProfileService's; the viewport changes come from every\n   * backend that reports them (OpenSeadragon, napari-js), merged into one stable\n   * stream the inset subscribes to once.\n   */\n  getIntensitySampling(): IIntensitySampling {\n    return this.intensitySampling;\n  }\n  private readonly intensitySampling: IIntensitySampling = {\n    // Load the displayed slice's pixels for a backend that has no frames of its own\n    // (OpenSeadragon, napari-js; Plotly feeds its frames to the service when it plots).\n    ensureIntensitySampling: (imageInfo, zIndex) => {\n      this.pointSamplingAtPlot();\n      return this.intensity.ensureIntensitySampling(imageInfo, zIndex);\n    },\n    // Re-sample from a fresh crop of the image-pixel ROI at display resolution.\n    refreshIntensitySamplingForRoi: (x, y, width, height, zIndex) => {\n      this.pointSamplingAtPlot();\n      this.intensity.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);\n    },\n    getViewportChange$: () =>\n      merge(...this.backends().map((b) => b.getIntensitySampling()?.getViewportChange$() ?? EMPTY)),\n  };\n  /** @deprecated Use `getIntensitySampling().ensureIntensitySampling()`. */\n  ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void> {\n    return this.intensitySampling.ensureIntensitySampling(imageInfo, zIndex);\n  }\n\n  /** Crops for sampling are sized from the plot div (whichever backend renders into it). */\n  private pointSamplingAtPlot(): void {\n    if (this.plotDiv) this.intensity.setSamplingElement(this.plotDiv);\n  }\n\n  /** @deprecated Use `getIntensitySampling().getViewportChange$()`. */\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return this.intensitySampling.getViewportChange$();\n  }\n\n  /** @deprecated Use `getIntensitySampling().refreshIntensitySamplingForRoi()`. */\n  refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number, zIndex: number): void {\n    this.intensitySampling.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);\n  }\n\n  /** The visualizer view is going away: detach every backend — dropping their view-bound\n   *  subscriptions and disposing the napari-js viewer, whose canvas, render loop and GPU\n   *  buffers would otherwise outlive the view (for a component-scoped chain, forever).\n   *  Nothing is on screen afterwards, so the next plot starts from the default backend. */\n  detach(): void {\n    this.sliceRequest++;\n    this.sections.stop();\n    this.sliceMounted = false;\n    this.sliceDiv = null;\n    this.plotly.detach();\n    this.osd.detach();\n    this.napari.detach();\n    this.lastRendered = null;\n  }\n\n  /** @deprecated Use {@link detach}. */\n  unsubscribe(): void {\n    this.detach();\n  }\n}\n"]}