@jax-data-science/sci-image-visualizer 0.17.0 → 0.18.1

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

@@ -6,6 +6,7 @@ import { PlotlyService } from './implementations/plotly/plotly.service';
 import { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';
 import { PlotType, isNapari3d, isNapariScatter, isSpatialOmics, isSpatialOmics3d, isNapariIsosurface, isNapariVolume, } from './contracts/plot-type';
 import { SPATIAL_DATA_PORT } from './contracts/ports/spatial-data.port';
+import { drawnCellSets } from './spatial/lod';
 import { SpatialControlsFacade } from './spatial/spatial-controls.facade';
 import { RegionStore } from './store/region-store.service';
 import { RegionScopeCache } from './store/region-scope-cache';
@@ -102,6 +103,36 @@ export class RoutingVisualizerService {
         this.meshRequest = 0;
         /** The class groups shown in 3D, and the image they belong to. */
         this.classes3d$ = new BehaviorSubject([]);
+        /**
+         * The spatial dataset's region set attached to its image (see attachDatasetRegionSet): the image
+         * (its region scope key), the set's key, and where its slices are when it says (its `sliceZ`),
+         * which places its surfaces in spatial 3D on an image of one plane. `shown3d` once its classes
+         * were shown in 3D by themselves, which happens once per image.
+         */
+        this.datasetRegionSet = null;
+        /**
+         * Each image's attached region set, kept across image switches: coming back to the image finds
+         * its source still in the store (with what was taken from it, or deleted) and restores the set
+         * rather than attaching it again, which would start the source afresh.
+         */
+        this.attachedRegionSets = new Map();
+        /** The spatial dataset on offer (the port's), for the boundary set its region set is. */
+        this.spatialDataset = null;
+        /**
+         * Whether the Annotations switch last hid every class in a spatial view (see syncAnnotations), so
+         * a change of it, not every view emission, hides or shows them.
+         */
+        this.annotationsHidden = false;
+        /** The 3D view's global cells switch as last applied (see updateCells3d). */
+        this.cells3dMode = 'types';
+        /** Classes set the other way than the global switch in the Region Editor. */
+        this.cells3dOverrides = new Map();
+        /** The classes drawn as individual cells in spatial 3D, as last applied. */
+        this.individual3d$ = new BehaviorSubject(new Set());
+        /** The classes that can be drawn as individual cells now (see getCellableClasses3d$). */
+        this.cellable3d$ = new BehaviorSubject(new Set());
+        /** The dataset region set's planes while they slice the plotted image (see getDatasetPlanes$). */
+        this.datasetPlanes$ = new BehaviorSubject(null);
         /** The groups last asked for in 3D, with their colours: what an edit's rebuild shows again. */
         this.shown3d = [];
         /**
@@ -142,6 +173,8 @@ export class RoutingVisualizerService {
         /** Displayed slice. Only a volume-backed spatial dataset reads it, to keep a
          *  region drawn over one section from selecting the whole depth behind it. */
         this.currentZIndex = 0;
+        /** The slice shown, the plot type or the dataset's planes changed (the spatial controls recount). */
+        this.spatialViewChanged$ = new Subject();
         this.intensitySampling = {
             // Load the displayed slice's pixels for a backend that has no frames of its own
             // (OpenSeadragon, napari-js; Plotly feeds its frames to the service when it plots).
@@ -157,6 +190,14 @@ export class RoutingVisualizerService {
             getViewportChange$: () => merge(...this.backends().map((b) => b.getIntensitySampling()?.getViewportChange$() ?? EMPTY)),
         };
         this.regionUpdates = this.regionStore.getRegionUpdateEvent().subscribe(() => this.onRegionsChanged());
+        this.planeCellsSub = this.spatialData
+            ? combineLatest([this.spatialData.getDataset$(), this.store.getSpatialView$()]).subscribe(([dataset]) => {
+                this.spatialDataset = dataset ?? null;
+                this.updatePlaneCells();
+                this.syncAnnotations();
+                this.updateCells3d();
+            })
+            : null;
         this.sections = new VolumeSections({
             volume: () => this.napari.volumeVoxels(),
             image: () => this.plottedFileName,
@@ -276,6 +317,8 @@ export class RoutingVisualizerService {
         // A stack can open away from slice 0 (`initialZIndex` — a volume opens
         // mid-specimen), and that arrives here rather than through setZIndex.
         this.currentZIndex = zIndex;
+        this.spatialViewChanged$.next();
+        zIndex = this.imageSlice(zIndex, imageInfo);
         const backend = this.imageBackend();
         if (backend === this.napari) {
             try {
@@ -317,6 +360,7 @@ export class RoutingVisualizerService {
     }
     plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace) {
         this.currentPlotType = plotType;
+        this.spatialViewChanged$.next();
         this.plottedFileName = imageInfo?.fileName;
         this.plottedInfo = imageInfo ?? null;
         this.plottedHeight = screenHeight;
@@ -328,6 +372,19 @@ export class RoutingVisualizerService {
         // 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();
+        // So does a dataset's region set: where its planes are is no other image's. Its attachment is
+        // kept (attachedRegionSets), to be restored when its image is back.
+        if (this.datasetRegionSet && this.datasetRegionSet.image !== this.importImageKey()) {
+            this.datasetRegionSet = null;
+            this.napari.setRegionPlanes(null);
+            this.datasetPlanes$.next(null);
+            this.spatialViewChanged$.next();
+            this.updateVolumeView(plotType);
+            this.updateCells3d();
+        }
+        this.updatePlaneCells();
+        this.syncAnnotations();
+        this.updateCells3d();
         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
@@ -345,7 +402,15 @@ export class RoutingVisualizerService {
                 this.lastRendered.reset();
         }
         this.lastRendered = next;
-        const plotted = next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);
+        const drawn = next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);
+        // A dataset's region set is shown in 3D once the cloud's scene is up: its voxel step is the scene's.
+        const plotted = this.datasetRegionSet?.planes
+            ? drawn.then((ok) => {
+                if (ok)
+                    this.showDatasetRegionSet3d();
+                return ok;
+            })
+            : drawn;
         if (!this.sliceDiv || !this.imageVolumeView)
             return plotted;
         // The split volume view: the slice pane follows the image (a new one, or its sharper pass).
@@ -474,12 +539,32 @@ export class RoutingVisualizerService {
     }
     setZIndex(zIndex) {
         this.currentZIndex = zIndex;
-        this.renderer().setZIndex(zIndex);
+        this.spatialViewChanged$.next();
+        const slice = this.imageSlice(zIndex);
+        this.renderer().setZIndex(slice);
+        if (this.datasetRegionSet?.planes)
+            this.napari.setRegionPlane(zIndex);
         if (this.sliceMounted) {
-            this.osd.setZIndex(zIndex);
+            this.osd.setZIndex(slice);
             this.sections.schedule();
         }
     }
+    /**
+     * The image's own slice for slider position `z`: 0 while the dataset region set's planes slice an
+     * image of one plane (the slider then picks the plane, see getDatasetPlanes$), else `z`.
+     */
+    imageSlice(z, info = this.plottedInfo) {
+        return this.datasetRegionSet?.planes && !info?.isStack ? 0 : z;
+    }
+    /**
+     * The planes of the spatial dataset's region set (its `sliceZ`, in observation units) while they
+     * slice the plotted image, an image of one plane; null otherwise. The host's slice slider then
+     * runs over them: each position shows that plane's regions and, in the 2D spatial view, the
+     * observations and transcripts nearest it, over the same image.
+     */
+    getDatasetPlanes$() {
+        return this.datasetPlanes$.asObservable();
+    }
     getTrueImageSize() {
         return this.renderer().getTrueImageSize();
     }
@@ -500,7 +585,11 @@ export class RoutingVisualizerService {
     }
     setPlotType(plotType) {
         this.currentPlotType = plotType;
+        this.spatialViewChanged$.next();
         this.updateVolumeView(plotType);
+        this.updatePlaneCells();
+        this.syncAnnotations();
+        this.updateCells3d();
         this.plotly.setPlotType(plotType);
     }
     /** @deprecated Use `getSurface3dControls()`. */
@@ -775,6 +864,278 @@ export class RoutingVisualizerService {
         this.regionStore.attachRegionSource(reuse, { slice: this.regionStore.getDisplaySlice() }, true);
         return true;
     }
+    /**
+     * Attach a spatial dataset's region set (a 3D segmentation's cells, outlined on every plane they
+     * span) to its image, the image plotted now, as the image's own regions are: over every slice
+     * from the set's planes (`'planes'`), not marked imported (it is the dataset's, nothing to save),
+     * leaving the image's drawn regions as they are. Once per image and set: called again (the
+     * dataset re-emitted, the image re-plotted) it changes nothing. Where the set's slices are (its
+     * `sliceZ`) places its surfaces among the observations in spatial 3D, where the region editor then
+     * offers its classes in 3D; there, every class is shown once by itself (see showDatasetRegionSet3d).
+     * Back on an image the set was attached to, with its source still the store's, it is restored as
+     * it was (what was taken from the source, or deleted, stays so), not attached again.
+     * Resolves false, changing nothing (the source disposed), when another image was plotted or
+     * another set attached while it opened, it could not be opened, or the image has region sources
+     * of its own (which it would replace, see keepsOwnSources).
+     */
+    async attachDatasetRegionSet(open, key) {
+        const image = this.importImageKey();
+        if (!image)
+            return false;
+        const current = this.datasetRegionSet;
+        if (current?.image === image && current.key === key) {
+            this.showDatasetRegionSet3d();
+            return true;
+        }
+        // Back on an image whose set is attached: its source is still the store's, with what was taken
+        // from it. Restored, not attached again.
+        const known = this.attachedRegionSets.get(image);
+        if (known?.key === key && known.opener && known.opener === this.regionStore.getPlanesSourceOpener()) {
+            this.useDatasetRegionSet(known);
+            return true;
+        }
+        if (this.keepsOwnSources(key))
+            return false;
+        // Claimed before the source opens: a second call meanwhile changes nothing.
+        const claim = { image, key, planes: null, groups: [], shown3d: false, opener: null };
+        this.datasetRegionSet = claim;
+        let first;
+        try {
+            first = await open();
+        }
+        catch (err) {
+            if (this.datasetRegionSet === claim)
+                this.datasetRegionSet = null;
+            console.warn("[visualizer] the dataset's region set could not be opened", err);
+            return false;
+        }
+        if (this.datasetRegionSet !== claim || this.importImageKey() !== image || this.keepsOwnSources(key)) {
+            if (this.datasetRegionSet === claim)
+                this.datasetRegionSet = null;
+            first.dispose();
+            return false;
+        }
+        const info = first.info;
+        const reuse = () => {
+            const source = first;
+            first = null;
+            return source ? Promise.resolve(source) : open();
+        };
+        const planes = info.sliceZ?.length && info.sliceZ.length === info.planes.length ? info.sliceZ : null;
+        // Sliced by its planes, the image's regions are held per plane (see useDatasetRegionSet): stack
+        // mode first, so the source is laid out on the plane shown.
+        if (planes && planes.length > 1 && !this.plottedInfo?.isStack && !this.regionStore.isStackMode()) {
+            const z = this.currentZIndex < planes.length ? this.currentZIndex : 0;
+            this.regionStore.enterStackMode(new Map([[z, this.regionStore.getRegions()]]), z, 'combined');
+        }
+        this.regionStore.attachRegionSource(reuse, 'planes');
+        const set = { ...claim, planes, groups: regionSetGroups(info), opener: reuse };
+        this.attachedRegionSets.set(image, set);
+        this.useDatasetRegionSet(set);
+        return true;
+    }
+    /**
+     * Whether the plotted image has region sources of its own (a served set, large saved ROIs, an
+     * annotation folder's slices), which attaching the dataset's set over every plane would replace,
+     * dropping them and what was taken from them: they are kept, and the set is not attached.
+     */
+    keepsOwnSources(key) {
+        if (!this.regionStore.hasAnyRegionSource())
+            return false;
+        console.warn(`[visualizer] the image has region sources of its own: the dataset's region set (${key}) is not attached over them`);
+        return true;
+    }
+    /**
+     * Make `set` the plotted image's region set: its planes slice the image (its regions per plane,
+     * as a stack's per slice: those drawn before go to the plane shown), place its surfaces in
+     * spatial 3D and drive the slider.
+     */
+    useDatasetRegionSet(set) {
+        this.datasetRegionSet = set;
+        const planes = set.planes;
+        const sliced = !!planes && planes.length > 1 && !this.plottedInfo?.isStack;
+        if (sliced && !this.regionStore.isStackMode()) {
+            const z = this.currentZIndex < planes.length ? this.currentZIndex : 0;
+            this.regionStore.enterStackMode(new Map([[z, this.regionStore.getRegions()]]), z, 'combined');
+        }
+        this.napari.setRegionPlanes(planes);
+        if (planes)
+            this.napari.setRegionPlane(this.currentZIndex);
+        this.datasetPlanes$.next(sliced ? planes : null);
+        this.spatialViewChanged$.next();
+        // Regions switched off in a spatial view before the set came: its classes are hidden as the
+        // rest are.
+        if (this.annotationsHidden &&
+            (isSpatialOmics(this.currentPlotType) || isSpatialOmics3d(this.currentPlotType))) {
+            this.setClassesHidden(set.groups.flatMap((g) => g.classes), true);
+        }
+        this.updateVolumeView(this.currentPlotType);
+        this.showDatasetRegionSet3d();
+        this.updatePlaneCells();
+        this.updateCells3d();
+    }
+    /**
+     * The dataset no longer names the attached set while its image is still plotted (see
+     * IVisualizer.releaseDatasetRegionSet): its planes, its surfaces and cells in 3D go, as on another
+     * image. Its attachment is kept (attachedRegionSets): the same set asked for again is restored.
+     */
+    releaseDatasetRegionSet(keep) {
+        const set = this.datasetRegionSet;
+        if (!set || set.key === keep)
+            return;
+        // One still opening (the claim) is dropped when it opens.
+        this.datasetRegionSet = null;
+        if (set.planes && this.classes3d$.value.length && this.classes3dImage === this.plottedFileName) {
+            this.clearRegionClasses3d();
+        }
+        this.napari.setRegionPlanes(null);
+        this.datasetPlanes$.next(null);
+        this.spatialViewChanged$.next();
+        this.updateVolumeView(this.currentPlotType);
+        this.updateCells3d();
+        this.updatePlaneCells();
+    }
+    /** The dataset region set's classes while in spatial 3D: those that can be drawn as cells. */
+    getCellableClasses3d$() {
+        return this.cellable3d$.asObservable();
+    }
+    /** The classes the spatial 3D view draws as individual cells (see updateCells3d). */
+    getIndividualClasses3d$() {
+        return this.individual3d$.asObservable();
+    }
+    /** Draw these classes as individual cells in spatial 3D, or merged again (the global switch aside). */
+    setClassesIndividual3d(classes, individual) {
+        const global = this.cells3dMode === 'cells';
+        for (const c of classes) {
+            if (individual === global)
+                this.cells3dOverrides.delete(c);
+            else
+                this.cells3dOverrides.set(c, individual);
+        }
+        this.updateCells3d(true);
+    }
+    /**
+     * Which of the dataset region set's classes the spatial 3D view draws as individual cells: every
+     * one with the panel's global switch on "cells", none on "types", each class the Region Editor
+     * set the other way excepted. Turning the global switch resets those. The individual classes'
+     * merged surfaces are left out (see showRegionClasses3d); their cells are drawn instead.
+     */
+    updateCells3d(force = false) {
+        const mode = this.store.currentSpatialView().cells3d ?? 'types';
+        if (mode !== this.cells3dMode) {
+            this.cells3dMode = mode;
+            this.cells3dOverrides.clear();
+            force = true;
+        }
+        const classes = new Set();
+        for (const g of this.datasetRegionSet?.planes ? this.datasetRegionSet.groups : []) {
+            for (const c of g.classes) {
+                if (this.cells3dOverrides.get(c) ?? mode === 'cells')
+                    classes.add(c);
+            }
+        }
+        const cellable = new Set(isSpatialOmics3d(this.currentPlotType) && this.datasetRegionSet?.planes
+            ? this.datasetRegionSet.groups.flatMap((g) => g.classes)
+            : []);
+        const had = this.cellable3d$.value;
+        if (had.size !== cellable.size || [...cellable].some((c) => !had.has(c)))
+            this.cellable3d$.next(cellable);
+        const before = this.individual3d$.value;
+        const same = before.size === classes.size && [...classes].every((c) => before.has(c));
+        if (same && !force)
+            return;
+        if (!same)
+            this.individual3d$.next(classes);
+        this.napari.setRegionCells(classes.size ? [...classes] : null);
+        // The merged surfaces follow: an individual class's leaves them, a merged one's comes back.
+        if (!same && this.shown3d.length && this.classes3dImage === this.plottedFileName) {
+            void this.showRegionClasses3d(this.shown3d);
+        }
+    }
+    /**
+     * In the spatial views (2D and 3D), the spatial panel's Regions switch (`showAnnotations`, off by
+     * default) is every class's in the Region Editor's list, as their eyes are: off, every class is
+     * hidden (the drawn regions' and the dataset region set's cell types alike: their regions in 2D,
+     * their surfaces in 3D, and the eyes show it); on again, every class is shown. Applied when the
+     * switch changes, or on entering a spatial view with it off (so by default), so a class hidden or
+     * shown by its own eye meanwhile stays as it was set.
+     */
+    syncAnnotations() {
+        if (!isSpatialOmics(this.currentPlotType) && !isSpatialOmics3d(this.currentPlotType))
+            return;
+        const hide = this.store.currentSpatialView().showAnnotations === false;
+        if (hide === this.annotationsHidden)
+            return;
+        this.annotationsHidden = hide;
+        const classes = this.knownClasses();
+        if (classes.length)
+            this.setClassesHidden(classes, hide);
+    }
+    /**
+     * Every class the Region Editor lists for the image: the dataset region set's, those shown in 3D,
+     * the drawn regions', and any hidden now.
+     */
+    knownClasses() {
+        const out = new Set(this.regionStore.getHiddenClasses());
+        for (const g of this.datasetRegionSet?.groups ?? [])
+            g.classes.forEach((c) => out.add(c));
+        for (const g of this.shown3d)
+            g.classes.forEach((c) => out.add(c));
+        for (const r of this.regionStore.getRegions())
+            if (r.label)
+                out.add(r.label);
+        return [...out];
+    }
+    /**
+     * The Cells panel's boundary set that is the dataset's region set (the one naming it as its
+     * `regionSource`), while its planes are shown on the plotted image with its source still the
+     * store's; null otherwise.
+     */
+    planeCellSet() {
+        const set = this.datasetRegionSet;
+        if (!set?.planes || !set.opener || set.opener !== this.regionStore.getPlanesSourceOpener())
+            return null;
+        return this.spatialDataset?.polygonTiles?.sets.find((s) => s.regionSource === set.key)?.name ?? null;
+    }
+    /**
+     * While the dataset region set's planes are shown, the Cells panel draws each plane's cells from
+     * it (its boundary set, see `CellLayers.setPlane`):
+     *  - that set is the panel's boundaries by default: a view that has not chosen a set (none yet, or
+     *    after a reset) is given it;
+     *  - in the 2D spatial view, while the panel draws them, the overlays do not draw the same
+     *    outlines a second time (`RegionStore.setRegionSourceDrawn`). They stay listed and editable
+     *    in the Region Editor, and are drawn by the overlays everywhere else.
+     */
+    updatePlaneCells() {
+        const name = this.planeCellSet();
+        const view = this.store.currentSpatialView();
+        if (name && view.cellSet == null) {
+            // Emits the view, which comes back here with the set chosen.
+            this.store.setSpatialView({ cellSet: name });
+            return;
+        }
+        const drawn = drawnCellSets(this.spatialDataset?.polygonTiles, view.cellSet);
+        const byCells = !!name &&
+            isSpatialOmics(this.currentPlotType) &&
+            (view.showCells ?? true) &&
+            drawn?.set === name &&
+            !drawn.nucleusSet;
+        this.regionStore.setRegionSourceDrawn(!byCells);
+    }
+    /**
+     * In spatial 3D, with the dataset's region set placed there: show each of its classes in 3D, in
+     * its colour, once per image, unless classes are shown already (the region editor's choice
+     * stands, and hiding them all stays hidden).
+     */
+    showDatasetRegionSet3d() {
+        const set = this.datasetRegionSet;
+        if (!set?.planes || set.shown3d || !set.groups.length)
+            return;
+        if (!isSpatialOmics3d(this.currentPlotType) || this.classes3d$.value.length)
+            return;
+        set.shown3d = true;
+        this.showRegionClasses3d(set.groups).catch((err) => console.warn('[visualizer] the cells could not be shown in 3D', err));
+    }
     /** Empty every slice of a stack (its regions and undo history) for regions imported over it. */
     enterImportedStack(info) {
         const layout = this.regionStore.isStackMode()
@@ -806,7 +1167,9 @@ export class RoutingVisualizerService {
     /** Recompute which 3D view is on screen for `plotType` (see {@link volumeView$}). */
     updateVolumeView(plotType) {
         this.imageVolumeView = isNapariVolume(plotType) || isNapariIsosurface(plotType);
-        const regions3d = this.imageVolumeView || (isSpatialOmics3d(plotType) && !!this.plottedInfo?.isStack);
+        // The spatial cloud places the surfaces of a stack's slices, or of a region set's planes.
+        const placed = !!this.plottedInfo?.isStack || !!this.datasetRegionSet?.planes;
+        const regions3d = this.imageVolumeView || (isSpatialOmics3d(plotType) && placed);
         // Every plot, as before: the Region Editor drops its per-class volumes on each (a new image).
         this.volumeView$.next(regions3d);
     }
@@ -870,7 +1233,10 @@ export class RoutingVisualizerService {
         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)));
+        // A group of classes drawn as individual cells has no merged surface (its cells are drawn).
+        const individual = this.individual3d$.value;
+        const merged = groups.filter((g) => !g.classes.length || !g.classes.every((c) => individual.has(c)));
+        const missing = merged.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(', ');
@@ -887,7 +1253,7 @@ export class RoutingVisualizerService {
         }
         if (request !== this.meshRequest)
             return;
-        this.napari.setRegionMeshes(groups.map((g) => {
+        this.napari.setRegionMeshes(merged.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);
@@ -1237,6 +1603,9 @@ export class RoutingVisualizerService {
             napari: this.napari,
             plotType: () => this.currentPlotType,
             zIndex: () => this.currentZIndex,
+            planes: () => (this.plottedInfo?.isStack ? null : (this.datasetRegionSet?.planes ?? null)),
+            slicePlanes: () => this.datasetRegionSet?.planes ?? null,
+            viewChanged$: this.spatialViewChanged$.asObservable(),
         });
         return this.spatialFacade.controls;
     }
@@ -1248,6 +1617,7 @@ export class RoutingVisualizerService {
         this.spatialFacade?.dispose();
         this.spatialFacade = null;
         this.regionUpdates.unsubscribe();
+        this.planeCellsSub?.unsubscribe();
         this.sectionSubs.unsubscribe();
         this.sections.stop();
         if (this.rebuildTimer)
@@ -1312,4 +1682,31 @@ 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, 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  /**\n   * Whether regions can be shown in 3D on screen: a napari volume (or isosurface) view, or the 3D\n   * spatial cloud over a stack image (its reference volume's, see showVolumeAsImage). Both draw the\n   * region reconstructions the same way (VolumeRegionMeshes), in the volume's box.\n   */\n  private readonly volumeView$ = new BehaviorSubject<boolean>(false);\n  /** Whether a napari volume (or isosurface) view is the current plot type: the slice pane's. */\n  private imageVolumeView = 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.plottedFileName = imageInfo?.fileName;\n    this.plottedInfo = imageInfo ?? null;\n    this.plottedHeight = screenHeight;\n    this.updateVolumeView(plotType);\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.imageVolumeView) 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.imageVolumeView) 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.imageVolumeView) 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.updateVolumeView(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  /** Recompute which 3D view is on screen for `plotType` (see {@link volumeView$}). */\n  private updateVolumeView(plotType: PlotType): void {\n    this.imageVolumeView = isNapariVolume(plotType) || isNapariIsosurface(plotType);\n    const regions3d = this.imageVolumeView || (isSpatialOmics3d(plotType) && !!this.plottedInfo?.isStack);\n    // Every plot, as before: the Region Editor drops its per-class volumes on each (a new image).\n    this.volumeView$.next(regions3d);\n  }\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  getPickedRegionClasses$(): Observable<readonly string[]> {\n    return this.regionStore.getPickedClasses$();\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"]}
+/**
+ * A region set's classes as 3D groups, as the region editor's class tree shows them: one per root of
+ * its hierarchy with every class under it (one per class of a flat one), in the hierarchy's order;
+ * without a hierarchy, one per class its features have. Each in the colour the set gives it (its
+ * hierarchy's, else its features').
+ */
+export function regionSetGroups(info) {
+    const colors = new Map(Object.entries(info.classColors ?? {}));
+    const nodes = [...(info.hierarchy ?? [])].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    if (!nodes.length) {
+        return [...colors.entries()].map(([name, color]) => ({ key: name, classes: [name], color }));
+    }
+    for (const n of nodes)
+        if (n.color)
+            colors.set(n.name, n.color);
+    const names = new Set(nodes.map((n) => n.name));
+    const children = new Map();
+    for (const n of nodes) {
+        if (!n.parent || !names.has(n.parent))
+            continue;
+        children.set(n.parent, [...(children.get(n.parent) ?? []), n.name]);
+    }
+    const subtree = (name) => [name, ...(children.get(name) ?? []).flatMap(subtree)];
+    return nodes
+        .filter((n) => !n.parent || !names.has(n.parent))
+        .map((n) => ({ key: n.name, classes: subtree(n.name), color: colors.get(n.name) ?? '#cccccc' }));
+}
+//# 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 type { SpatialDataset } from './contracts/spatial-dataset.contract';\nimport { drawnCellSets } from './spatial/lod';\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, RegionSourceInfo } 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  /**\n   * Whether regions can be shown in 3D on screen: a napari volume (or isosurface) view, or the 3D\n   * spatial cloud over a stack image (its reference volume's, see showVolumeAsImage). Both draw the\n   * region reconstructions the same way (VolumeRegionMeshes), in the volume's box.\n   */\n  private readonly volumeView$ = new BehaviorSubject<boolean>(false);\n  /** Whether a napari volume (or isosurface) view is the current plot type: the slice pane's. */\n  private imageVolumeView = 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  /**\n   * The spatial dataset's region set attached to its image (see attachDatasetRegionSet): the image\n   * (its region scope key), the set's key, and where its slices are when it says (its `sliceZ`),\n   * which places its surfaces in spatial 3D on an image of one plane. `shown3d` once its classes\n   * were shown in 3D by themselves, which happens once per image.\n   */\n  private datasetRegionSet: DatasetRegionSetState | null = null;\n  /**\n   * Each image's attached region set, kept across image switches: coming back to the image finds\n   * its source still in the store (with what was taken from it, or deleted) and restores the set\n   * rather than attaching it again, which would start the source afresh.\n   */\n  private readonly attachedRegionSets = new Map<string, DatasetRegionSetState>();\n  /** The spatial dataset on offer (the port's), for the boundary set its region set is. */\n  private spatialDataset: SpatialDataset | null = null;\n  /**\n   * Whether the Annotations switch last hid every class in a spatial view (see syncAnnotations), so\n   * a change of it, not every view emission, hides or shows them.\n   */\n  private annotationsHidden = false;\n  /** The 3D view's global cells switch as last applied (see updateCells3d). */\n  private cells3dMode: 'types' | 'cells' = 'types';\n  /** Classes set the other way than the global switch in the Region Editor. */\n  private readonly cells3dOverrides = new Map<string, boolean>();\n  /** The classes drawn as individual cells in spatial 3D, as last applied. */\n  private readonly individual3d$ = new BehaviorSubject<ReadonlySet<string>>(new Set());\n  /** The classes that can be drawn as individual cells now (see getCellableClasses3d$). */\n  private readonly cellable3d$ = new BehaviorSubject<ReadonlySet<string>>(new Set());\n  /** Follows the dataset and the spatial view for {@link updatePlaneCells}. */\n  private readonly planeCellsSub: Subscription | null;\n  /** The dataset region set's planes while they slice the plotted image (see getDatasetPlanes$). */\n  private readonly datasetPlanes$ = new BehaviorSubject<readonly number[] | null>(null);\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.planeCellsSub = this.spatialData\n      ? combineLatest([this.spatialData.getDataset$(), this.store.getSpatialView$()]).subscribe(([dataset]) => {\n          this.spatialDataset = dataset ?? null;\n          this.updatePlaneCells();\n          this.syncAnnotations();\n          this.updateCells3d();\n        })\n      : null;\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    this.spatialViewChanged$.next();\n    zIndex = this.imageSlice(zIndex, imageInfo);\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.spatialViewChanged$.next();\n    this.plottedFileName = imageInfo?.fileName;\n    this.plottedInfo = imageInfo ?? null;\n    this.plottedHeight = screenHeight;\n    this.updateVolumeView(plotType);\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.imageVolumeView) 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    // So does a dataset's region set: where its planes are is no other image's. Its attachment is\n    // kept (attachedRegionSets), to be restored when its image is back.\n    if (this.datasetRegionSet && this.datasetRegionSet.image !== this.importImageKey()) {\n      this.datasetRegionSet = null;\n      this.napari.setRegionPlanes(null);\n      this.datasetPlanes$.next(null);\n      this.spatialViewChanged$.next();\n      this.updateVolumeView(plotType);\n      this.updateCells3d();\n    }\n    this.updatePlaneCells();\n    this.syncAnnotations();\n    this.updateCells3d();\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 drawn = next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);\n    // A dataset's region set is shown in 3D once the cloud's scene is up: its voxel step is the scene's.\n    const plotted = this.datasetRegionSet?.planes\n      ? drawn.then((ok) => {\n          if (ok) this.showDatasetRegionSet3d();\n          return ok;\n        })\n      : drawn;\n    if (!this.sliceDiv || !this.imageVolumeView) 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.imageVolumeView) 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.spatialViewChanged$.next();\n    const slice = this.imageSlice(zIndex);\n    this.renderer().setZIndex(slice);\n    if (this.datasetRegionSet?.planes) this.napari.setRegionPlane(zIndex);\n    if (this.sliceMounted) {\n      this.osd.setZIndex(slice);\n      this.sections.schedule();\n    }\n  }\n\n  /**\n   * The image's own slice for slider position `z`: 0 while the dataset region set's planes slice an\n   * image of one plane (the slider then picks the plane, see getDatasetPlanes$), else `z`.\n   */\n  private imageSlice(z: number, info: IImageInfo | null | undefined = this.plottedInfo): number {\n    return this.datasetRegionSet?.planes && !info?.isStack ? 0 : z;\n  }\n\n  /**\n   * The planes of the spatial dataset's region set (its `sliceZ`, in observation units) while they\n   * slice the plotted image, an image of one plane; null otherwise. The host's slice slider then\n   * runs over them: each position shows that plane's regions and, in the 2D spatial view, the\n   * observations and transcripts nearest it, over the same image.\n   */\n  getDatasetPlanes$(): Observable<readonly number[] | null> {\n    return this.datasetPlanes$.asObservable();\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.spatialViewChanged$.next();\n    this.updateVolumeView(plotType);\n    this.updatePlaneCells();\n    this.syncAnnotations();\n    this.updateCells3d();\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  /**\n   * Attach a spatial dataset's region set (a 3D segmentation's cells, outlined on every plane they\n   * span) to its image, the image plotted now, as the image's own regions are: over every slice\n   * from the set's planes (`'planes'`), not marked imported (it is the dataset's, nothing to save),\n   * leaving the image's drawn regions as they are. Once per image and set: called again (the\n   * dataset re-emitted, the image re-plotted) it changes nothing. Where the set's slices are (its\n   * `sliceZ`) places its surfaces among the observations in spatial 3D, where the region editor then\n   * offers its classes in 3D; there, every class is shown once by itself (see showDatasetRegionSet3d).\n   * Back on an image the set was attached to, with its source still the store's, it is restored as\n   * it was (what was taken from the source, or deleted, stays so), not attached again.\n   * Resolves false, changing nothing (the source disposed), when another image was plotted or\n   * another set attached while it opened, it could not be opened, or the image has region sources\n   * of its own (which it would replace, see keepsOwnSources).\n   */\n  async attachDatasetRegionSet(open: RegionSourceOpener, key: string): Promise<boolean> {\n    const image = this.importImageKey();\n    if (!image) return false;\n    const current = this.datasetRegionSet;\n    if (current?.image === image && current.key === key) {\n      this.showDatasetRegionSet3d();\n      return true;\n    }\n    // Back on an image whose set is attached: its source is still the store's, with what was taken\n    // from it. Restored, not attached again.\n    const known = this.attachedRegionSets.get(image);\n    if (known?.key === key && known.opener && known.opener === this.regionStore.getPlanesSourceOpener()) {\n      this.useDatasetRegionSet(known);\n      return true;\n    }\n    if (this.keepsOwnSources(key)) return false;\n    // Claimed before the source opens: a second call meanwhile changes nothing.\n    const claim: DatasetRegionSetState = { image, key, planes: null, groups: [], shown3d: false, opener: null };\n    this.datasetRegionSet = claim;\n    let first: RegionSource | null;\n    try {\n      first = await open();\n    } catch (err) {\n      if (this.datasetRegionSet === claim) this.datasetRegionSet = null;\n      console.warn(\"[visualizer] the dataset's region set could not be opened\", err);\n      return false;\n    }\n    if (this.datasetRegionSet !== claim || this.importImageKey() !== image || this.keepsOwnSources(key)) {\n      if (this.datasetRegionSet === claim) this.datasetRegionSet = null;\n      first.dispose();\n      return false;\n    }\n    const info = first.info;\n    const reuse: RegionSourceOpener = () => {\n      const source = first;\n      first = null;\n      return source ? Promise.resolve(source) : open();\n    };\n    const planes = info.sliceZ?.length && info.sliceZ.length === info.planes.length ? info.sliceZ : null;\n    // Sliced by its planes, the image's regions are held per plane (see useDatasetRegionSet): stack\n    // mode first, so the source is laid out on the plane shown.\n    if (planes && planes.length > 1 && !this.plottedInfo?.isStack && !this.regionStore.isStackMode()) {\n      const z = this.currentZIndex < planes.length ? this.currentZIndex : 0;\n      this.regionStore.enterStackMode(new Map([[z, this.regionStore.getRegions()]]), z, 'combined');\n    }\n    this.regionStore.attachRegionSource(reuse, 'planes');\n    const set: DatasetRegionSetState = { ...claim, planes, groups: regionSetGroups(info), opener: reuse };\n    this.attachedRegionSets.set(image, set);\n    this.useDatasetRegionSet(set);\n    return true;\n  }\n\n  /**\n   * Whether the plotted image has region sources of its own (a served set, large saved ROIs, an\n   * annotation folder's slices), which attaching the dataset's set over every plane would replace,\n   * dropping them and what was taken from them: they are kept, and the set is not attached.\n   */\n  private keepsOwnSources(key: string): boolean {\n    if (!this.regionStore.hasAnyRegionSource()) return false;\n    console.warn(\n      `[visualizer] the image has region sources of its own: the dataset's region set (${key}) is not attached over them`,\n    );\n    return true;\n  }\n\n  /**\n   * Make `set` the plotted image's region set: its planes slice the image (its regions per plane,\n   * as a stack's per slice: those drawn before go to the plane shown), place its surfaces in\n   * spatial 3D and drive the slider.\n   */\n  private useDatasetRegionSet(set: DatasetRegionSetState): void {\n    this.datasetRegionSet = set;\n    const planes = set.planes;\n    const sliced = !!planes && planes.length > 1 && !this.plottedInfo?.isStack;\n    if (sliced && !this.regionStore.isStackMode()) {\n      const z = this.currentZIndex < planes.length ? this.currentZIndex : 0;\n      this.regionStore.enterStackMode(new Map([[z, this.regionStore.getRegions()]]), z, 'combined');\n    }\n    this.napari.setRegionPlanes(planes);\n    if (planes) this.napari.setRegionPlane(this.currentZIndex);\n    this.datasetPlanes$.next(sliced ? planes : null);\n    this.spatialViewChanged$.next();\n    // Regions switched off in a spatial view before the set came: its classes are hidden as the\n    // rest are.\n    if (\n      this.annotationsHidden &&\n      (isSpatialOmics(this.currentPlotType) || isSpatialOmics3d(this.currentPlotType))\n    ) {\n      this.setClassesHidden(\n        set.groups.flatMap((g) => g.classes),\n        true,\n      );\n    }\n    this.updateVolumeView(this.currentPlotType);\n    this.showDatasetRegionSet3d();\n    this.updatePlaneCells();\n    this.updateCells3d();\n  }\n\n  /**\n   * The dataset no longer names the attached set while its image is still plotted (see\n   * IVisualizer.releaseDatasetRegionSet): its planes, its surfaces and cells in 3D go, as on another\n   * image. Its attachment is kept (attachedRegionSets): the same set asked for again is restored.\n   */\n  releaseDatasetRegionSet(keep: string | null): void {\n    const set = this.datasetRegionSet;\n    if (!set || set.key === keep) return;\n    // One still opening (the claim) is dropped when it opens.\n    this.datasetRegionSet = null;\n    if (set.planes && this.classes3d$.value.length && this.classes3dImage === this.plottedFileName) {\n      this.clearRegionClasses3d();\n    }\n    this.napari.setRegionPlanes(null);\n    this.datasetPlanes$.next(null);\n    this.spatialViewChanged$.next();\n    this.updateVolumeView(this.currentPlotType);\n    this.updateCells3d();\n    this.updatePlaneCells();\n  }\n\n  /** The dataset region set's classes while in spatial 3D: those that can be drawn as cells. */\n  getCellableClasses3d$(): Observable<ReadonlySet<string>> {\n    return this.cellable3d$.asObservable();\n  }\n\n  /** The classes the spatial 3D view draws as individual cells (see updateCells3d). */\n  getIndividualClasses3d$(): Observable<ReadonlySet<string>> {\n    return this.individual3d$.asObservable();\n  }\n\n  /** Draw these classes as individual cells in spatial 3D, or merged again (the global switch aside). */\n  setClassesIndividual3d(classes: readonly string[], individual: boolean): void {\n    const global = this.cells3dMode === 'cells';\n    for (const c of classes) {\n      if (individual === global) this.cells3dOverrides.delete(c);\n      else this.cells3dOverrides.set(c, individual);\n    }\n    this.updateCells3d(true);\n  }\n\n  /**\n   * Which of the dataset region set's classes the spatial 3D view draws as individual cells: every\n   * one with the panel's global switch on \"cells\", none on \"types\", each class the Region Editor\n   * set the other way excepted. Turning the global switch resets those. The individual classes'\n   * merged surfaces are left out (see showRegionClasses3d); their cells are drawn instead.\n   */\n  private updateCells3d(force = false): void {\n    const mode = this.store.currentSpatialView().cells3d ?? 'types';\n    if (mode !== this.cells3dMode) {\n      this.cells3dMode = mode;\n      this.cells3dOverrides.clear();\n      force = true;\n    }\n    const classes = new Set<string>();\n    for (const g of this.datasetRegionSet?.planes ? this.datasetRegionSet.groups : []) {\n      for (const c of g.classes) {\n        if (this.cells3dOverrides.get(c) ?? mode === 'cells') classes.add(c);\n      }\n    }\n    const cellable = new Set<string>(\n      isSpatialOmics3d(this.currentPlotType) && this.datasetRegionSet?.planes\n        ? this.datasetRegionSet.groups.flatMap((g) => g.classes)\n        : [],\n    );\n    const had = this.cellable3d$.value;\n    if (had.size !== cellable.size || [...cellable].some((c) => !had.has(c))) this.cellable3d$.next(cellable);\n    const before = this.individual3d$.value;\n    const same = before.size === classes.size && [...classes].every((c) => before.has(c));\n    if (same && !force) return;\n    if (!same) this.individual3d$.next(classes);\n    this.napari.setRegionCells(classes.size ? [...classes] : null);\n    // The merged surfaces follow: an individual class's leaves them, a merged one's comes back.\n    if (!same && this.shown3d.length && this.classes3dImage === this.plottedFileName) {\n      void this.showRegionClasses3d(this.shown3d);\n    }\n  }\n\n  /**\n   * In the spatial views (2D and 3D), the spatial panel's Regions switch (`showAnnotations`, off by\n   * default) is every class's in the Region Editor's list, as their eyes are: off, every class is\n   * hidden (the drawn regions' and the dataset region set's cell types alike: their regions in 2D,\n   * their surfaces in 3D, and the eyes show it); on again, every class is shown. Applied when the\n   * switch changes, or on entering a spatial view with it off (so by default), so a class hidden or\n   * shown by its own eye meanwhile stays as it was set.\n   */\n  private syncAnnotations(): void {\n    if (!isSpatialOmics(this.currentPlotType) && !isSpatialOmics3d(this.currentPlotType)) return;\n    const hide = this.store.currentSpatialView().showAnnotations === false;\n    if (hide === this.annotationsHidden) return;\n    this.annotationsHidden = hide;\n    const classes = this.knownClasses();\n    if (classes.length) this.setClassesHidden(classes, hide);\n  }\n\n  /**\n   * Every class the Region Editor lists for the image: the dataset region set's, those shown in 3D,\n   * the drawn regions', and any hidden now.\n   */\n  private knownClasses(): string[] {\n    const out = new Set<string>(this.regionStore.getHiddenClasses());\n    for (const g of this.datasetRegionSet?.groups ?? []) g.classes.forEach((c) => out.add(c));\n    for (const g of this.shown3d) g.classes.forEach((c) => out.add(c));\n    for (const r of this.regionStore.getRegions()) if (r.label) out.add(r.label);\n    return [...out];\n  }\n\n  /**\n   * The Cells panel's boundary set that is the dataset's region set (the one naming it as its\n   * `regionSource`), while its planes are shown on the plotted image with its source still the\n   * store's; null otherwise.\n   */\n  private planeCellSet(): string | null {\n    const set = this.datasetRegionSet;\n    if (!set?.planes || !set.opener || set.opener !== this.regionStore.getPlanesSourceOpener()) return null;\n    return this.spatialDataset?.polygonTiles?.sets.find((s) => s.regionSource === set.key)?.name ?? null;\n  }\n\n  /**\n   * While the dataset region set's planes are shown, the Cells panel draws each plane's cells from\n   * it (its boundary set, see `CellLayers.setPlane`):\n   *  - that set is the panel's boundaries by default: a view that has not chosen a set (none yet, or\n   *    after a reset) is given it;\n   *  - in the 2D spatial view, while the panel draws them, the overlays do not draw the same\n   *    outlines a second time (`RegionStore.setRegionSourceDrawn`). They stay listed and editable\n   *    in the Region Editor, and are drawn by the overlays everywhere else.\n   */\n  private updatePlaneCells(): void {\n    const name = this.planeCellSet();\n    const view = this.store.currentSpatialView();\n    if (name && view.cellSet == null) {\n      // Emits the view, which comes back here with the set chosen.\n      this.store.setSpatialView({ cellSet: name });\n      return;\n    }\n    const drawn = drawnCellSets(this.spatialDataset?.polygonTiles, view.cellSet);\n    const byCells =\n      !!name &&\n      isSpatialOmics(this.currentPlotType) &&\n      (view.showCells ?? true) &&\n      drawn?.set === name &&\n      !drawn.nucleusSet;\n    this.regionStore.setRegionSourceDrawn(!byCells);\n  }\n\n  /**\n   * In spatial 3D, with the dataset's region set placed there: show each of its classes in 3D, in\n   * its colour, once per image, unless classes are shown already (the region editor's choice\n   * stands, and hiding them all stays hidden).\n   */\n  private showDatasetRegionSet3d(): void {\n    const set = this.datasetRegionSet;\n    if (!set?.planes || set.shown3d || !set.groups.length) return;\n    if (!isSpatialOmics3d(this.currentPlotType) || this.classes3d$.value.length) return;\n    set.shown3d = true;\n    this.showRegionClasses3d(set.groups).catch((err) =>\n      console.warn('[visualizer] the cells could not be shown in 3D', err),\n    );\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  /** Recompute which 3D view is on screen for `plotType` (see {@link volumeView$}). */\n  private updateVolumeView(plotType: PlotType): void {\n    this.imageVolumeView = isNapariVolume(plotType) || isNapariIsosurface(plotType);\n    // The spatial cloud places the surfaces of a stack's slices, or of a region set's planes.\n    const placed = !!this.plottedInfo?.isStack || !!this.datasetRegionSet?.planes;\n    const regions3d = this.imageVolumeView || (isSpatialOmics3d(plotType) && placed);\n    // Every plot, as before: the Region Editor drops its per-class volumes on each (a new image).\n    this.volumeView$.next(regions3d);\n  }\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    // A group of classes drawn as individual cells has no merged surface (its cells are drawn).\n    const individual = this.individual3d$.value;\n    const merged = groups.filter((g) => !g.classes.length || !g.classes.every((c) => individual.has(c)));\n    const missing = merged.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      merged.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  getPickedRegionClasses$(): Observable<readonly string[]> {\n    return this.regionStore.getPickedClasses$();\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      planes: () => (this.plottedInfo?.isStack ? null : (this.datasetRegionSet?.planes ?? null)),\n      slicePlanes: () => this.datasetRegionSet?.planes ?? null,\n      viewChanged$: this.spatialViewChanged$.asObservable(),\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  /** The slice shown, the plot type or the dataset's planes changed (the spatial controls recount). */\n  private readonly spatialViewChanged$ = new Subject<void>();\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.planeCellsSub?.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\n/**\n * A spatial dataset's region set on an image (see `attachDatasetRegionSet`): the image (its region\n * scope key), the set's key, its planes' z (its `sliceZ`, when it says), its class groups, whether\n * they were shown in 3D by themselves, and the opener it was attached to the store with (null while\n * it opens): while the store's source over every plane is that one, the set is still attached.\n */\ninterface DatasetRegionSetState {\n  image: string;\n  key: string;\n  planes: readonly number[] | null;\n  groups: ReadonlyArray<{ key: string; classes: readonly string[]; color: string }>;\n  shown3d: boolean;\n  opener: RegionSourceOpener | null;\n}\n\n/**\n * A region set's classes as 3D groups, as the region editor's class tree shows them: one per root of\n * its hierarchy with every class under it (one per class of a flat one), in the hierarchy's order;\n * without a hierarchy, one per class its features have. Each in the colour the set gives it (its\n * hierarchy's, else its features').\n */\nexport function regionSetGroups(info: RegionSourceInfo): Array<{ key: string; classes: string[]; color: string }> {\n  const colors = new Map(Object.entries(info.classColors ?? {}));\n  const nodes = [...(info.hierarchy ?? [])].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));\n  if (!nodes.length) {\n    return [...colors.entries()].map(([name, color]) => ({ key: name, classes: [name], color }));\n  }\n  for (const n of nodes) if (n.color) colors.set(n.name, n.color);\n  const names = new Set(nodes.map((n) => n.name));\n  const children = new Map<string, string[]>();\n  for (const n of nodes) {\n    if (!n.parent || !names.has(n.parent)) continue;\n    children.set(n.parent, [...(children.get(n.parent) ?? []), n.name]);\n  }\n  const subtree = (name: string): string[] => [name, ...(children.get(name) ?? []).flatMap(subtree)];\n  return nodes\n    .filter((n) => !n.parent || !names.has(n.parent))\n    .map((n) => ({ key: n.name, classes: subtree(n.name), color: colors.get(n.name) ?? '#cccccc' }));\n}\n"]}