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

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

@@ -1,20 +1,18 @@
 import { Inject, Injectable, Optional } from '@angular/core';
-import { combineLatest, firstValueFrom } from 'rxjs';
+import { EMPTY, combineLatest, merge } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { PlotlyService } from './implementations/plotly/plotly.service';
 import { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';
-import { PlotType, isNapari3d, isNapariScatter, isSpatialOmics, isSpatialOmics3d } from './contracts/plot-type';
+import { PlotType, isNapari3d, isNapariScatter, isSpatialOmics, isSpatialOmics3d, } from './contracts/plot-type';
 import { SPATIAL_DATA_PORT } from './contracts/ports/spatial-data.port';
-import { isCategoricalColumn } from './contracts/spatial-dataset.contract';
-import { resolveCategoryColors } from './spatial/spatial-encoding';
-import { sectionsOf } from './spatial/spatial-sections';
-import { observationsInSlice, volumeImageRef, } from './spatial/spatial-volume-image';
-import { emptySelection, selectByCategory, selectByIndices, selectInRegions, selectInRegionsProjected, } from './spatial/spatial-selection';
+import { SpatialControlsFacade } from './spatial/spatial-controls.facade';
 import { RegionStore } from './store/region-store.service';
 import { SpatialSelectionStore } from './store/spatial-selection.service';
+import { autoWindowFromHistogram } from './contracts/intensity';
 import { VisualizerStore } from './store/visualizer-store.service';
 import { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';
 import { VIZ_CONFIG } from './contracts/viz-config';
+import { IntensityProfileService } from './intensity/intensity-profile.service';
 import * as i0 from "@angular/core";
 import * as i1 from "./implementations/plotly/plotly.service";
 import * as i2 from "./implementations/osd/openseadragon-visualizer.service";
@@ -22,72 +20,39 @@ import * as i3 from "./implementations/napari-js/napari-visualizer.service";
 import * as i4 from "./store/visualizer-store.service";
 import * as i5 from "./store/region-store.service";
 import * as i6 from "./store/spatial-selection.service";
-/**
- * Backend selector. Routes per plot type:
- *  - the **Image** plot type renders through OpenSeadragon — a natively-tiled,
- *    zoomable raster backed by the jit-service tile endpoints. It's the default
- *    view and supports the region overlay/tools and (for grayscale) the
- *    colormap, applied client-side via the tile pixel pipeline.
- *  - every other plot type (heatmap, surface, contour, scatter, line,
- *    scatter3d, isosurface) renders through Plotly.
- *
- * Only the **render + viewport** path is routed. Region state, display options
- * (colormap/LUT), and the long-lived observables always live in Plotly (the
- * shared store) so both backends stay in sync; OSD reads them to drive its own
- * overlay and tile recoloring.
- *
- * The Image type renders through OpenSeadragon; a failed OSD load falls back to
- * Plotly for that image only (see `osdFellBack`) so it still renders.
- */
+import * as i7 from "./intensity/intensity-profile.service";
 /** Intensity-profile line ROIs are owned by the intensity tool, not the editor.
  *  Package-internal predicate (property-based so it also matches plain objects
  *  after a drag round-trip). */
 function isProfileRegion(r) {
     return r?.kind === 'profile';
 }
-/** Saturation-based auto-window: pick [min,max] so ~`saturation` of pixels clip
- *  at each end of the histogram. A dominant first/last bin (unscanned padding /
- *  clipped background) is dropped so it doesn't skew the range. */
-function autoWindowFromHistogram(h, saturation) {
-    const counts = h.counts.slice();
-    const n = counts.length;
-    if (n === 0)
-        return [0, 255];
-    if (n > 2 && counts[0] > counts[1])
-        counts[0] = 0;
-    if (n > 2 && counts[n - 1] > counts[n - 2])
-        counts[n - 1] = 0;
-    let total = 0;
-    for (const c of counts)
-        total += c;
-    if (total <= 0)
-        return [0, 255];
-    const target = total * Math.max(0, Math.min(0.5, saturation));
-    let acc = 0;
-    let min = h.bins[0];
-    for (let i = 0; i < n; i++) {
-        acc += counts[i];
-        if (acc > target) {
-            min = h.bins[i];
-            break;
-        }
-    }
-    acc = 0;
-    let max = h.bins[n - 1];
-    for (let i = n - 1; i >= 0; i--) {
-        acc += counts[i];
-        if (acc > target) {
-            max = h.bins[i];
-            break;
-        }
-    }
-    return [min, max];
-}
+/**
+ * The visualizer chain's front door: implements `IVisualizer`, `IRegionEditorApi`
+ * and `IChannelHistogramApi` (bound to the `VISUALIZER` / `REGION_EDITOR_API` /
+ * `CHANNEL_HISTOGRAM_API` tokens) over three rendering backends, chosen per plot type:
+ *  - **Image** renders through OpenSeadragon (natively tiled, region tools,
+ *    client-side colormap), or through napari-js when `VizConfig.useNapariRenderer`
+ *    opts in; the napari image types and the 2D spatial-omics mode render through
+ *    napari-js. A failed load falls back napari-js → OSD → Plotly for that image only
+ *    (see `napariFellBack` / `osdFellBack`, cleared by `reset()`).
+ *  - the napari 3D types (volume, isosurface, surface, 3D scatter, the 3D spatial
+ *    cloud) render through napari-js, falling back to Plotly.
+ *  - every other plot type (heatmap, contour, surface, scatter, line, …) renders
+ *    through Plotly.
+ *
+ * Only rendering and the viewport are routed to the backend on screen. Region state
+ * lives in the shared `RegionStore` and display state (colormap, channels, presets,
+ * spatial view) in the shared `VisualizerStore`, so every backend sees the same
+ * values; the backends subscribe to them to redraw.
+ *
+ * Package-internal: hosts depend on the tokens, not on this class.
+ */
 export class RoutingVisualizerService {
     constructor(plotly, osd, napari, store, config, 
     // Optional: a host that serves no spatial-omics data binds nothing,
     // and `getSpatialControls()` then returns null.
-    regionStore, selectionStore, spatialData = null) {
+    regionStore, selectionStore, intensity, spatialData = null) {
         this.plotly = plotly;
         this.osd = osd;
         this.napari = napari;
@@ -95,6 +60,7 @@ export class RoutingVisualizerService {
         this.config = config;
         this.regionStore = regionStore;
         this.selectionStore = selectionStore;
+        this.intensity = intensity;
         this.spatialData = spatialData;
         this.currentPlotType = PlotType.IMAGE;
         this.lastRendered = null;
@@ -107,15 +73,37 @@ export class RoutingVisualizerService {
         /** napari-js failed for the current render cycle → fall back to OSD (then Plotly).
          *  Reset by reset() at the start of every cycle, like {@link osdFellBack}. */
         this.napariFellBack = false;
-        /** Memoised so consumers can hold the object across calls. */
-        this.spatialControls = null;
-        /** Latest dataset, mirrored so `selectFromRegions()` can answer synchronously
-         *  — it runs from a button click and must not await a round-trip. */
-        this.currentSpatialDataset = null;
+        /** The div the backends render into (every backend shares it); '' before the first plot. */
+        this.plotDiv = '';
+        this.viewOptions = {
+            setNavigatorVisible: (visible) => {
+                for (const b of this.backends())
+                    b.getOsdViewOptions()?.setNavigatorVisible(visible);
+            },
+            setImageSmoothingEnabled: (enabled) => {
+                for (const b of this.backends())
+                    b.getOsdViewOptions()?.setImageSmoothingEnabled(enabled);
+            },
+        };
+        /** Created on first use; owns the dataset subscription. */
+        this.spatialFacade = null;
         /** 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;
-        this.spatialDatasetSub = null;
+        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).
+            ensureIntensitySampling: (imageInfo, zIndex) => {
+                this.pointSamplingAtPlot();
+                return this.intensity.ensureIntensitySampling(imageInfo, zIndex);
+            },
+            // Re-sample from a fresh crop of the image-pixel ROI at display resolution.
+            refreshIntensitySamplingForRoi: (x, y, width, height, zIndex) => {
+                this.pointSamplingAtPlot();
+                this.intensity.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);
+            },
+            getViewportChange$: () => merge(...this.backends().map((b) => b.getIntensitySampling()?.getViewportChange$() ?? EMPTY)),
+        };
     }
     isImageType(t) {
         return t === PlotType.IMAGE;
@@ -169,48 +157,57 @@ export class RoutingVisualizerService {
     }
     // System capabilities are Plotly's (the full-featured backend) so the UI
     // keeps offering every plot type regardless of which one is on screen.
-    get capabilities() { return this.plotly.capabilities; }
+    get capabilities() {
+        return this.plotly.capabilities;
+    }
     // ── render / viewport → active renderer ──────────────────────────────
-    async load(imageInfo, zIndex) {
+    async load(imageInfo, zIndex, signal) {
         // 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;
         const backend = this.imageBackend();
         if (backend === this.napari) {
             try {
-                return await this.napari.load(imageInfo, zIndex);
+                return await this.napari.load(imageInfo, zIndex, signal);
             }
             catch (err) {
+                // Aborted: nobody wants this image any more, so don't go on to load it elsewhere.
+                if (signal?.aborted)
+                    throw err;
                 this.napariFellBack = true;
                 // Mirror imageBackend()'s fallback so load + plot pick the same backend:
                 //  - 3D napari types have no 2D fallback → straight to Plotly.
                 //  - 2D image → OSD, then Plotly.
                 if (this.isNapari3dType(this.currentPlotType)) {
                     console.warn('[visualizer] napari-js load failed — falling back to Plotly.', err);
-                    return this.plotly.load(imageInfo, zIndex);
+                    return this.plotly.load(imageInfo, zIndex, signal);
                 }
                 console.warn('[visualizer] napari-js load failed — falling back to OpenSeadragon.', err);
-                return this.loadViaOsdThenPlotly(imageInfo, zIndex);
+                return this.loadViaOsdThenPlotly(imageInfo, zIndex, signal);
             }
         }
         if (backend === this.osd) {
-            return this.loadViaOsdThenPlotly(imageInfo, zIndex);
+            return this.loadViaOsdThenPlotly(imageInfo, zIndex, signal);
         }
-        return this.plotly.load(imageInfo, zIndex);
+        return this.plotly.load(imageInfo, zIndex, signal);
     }
     /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */
-    async loadViaOsdThenPlotly(imageInfo, zIndex) {
+    async loadViaOsdThenPlotly(imageInfo, zIndex, signal) {
         try {
-            return await this.osd.load(imageInfo, zIndex);
+            return await this.osd.load(imageInfo, zIndex, signal);
         }
         catch (err) {
+            if (signal?.aborted)
+                throw err;
             console.warn('[visualizer] OpenSeadragon load failed — falling back to Plotly for this image.', err);
             this.osdFellBack = true;
-            return this.plotly.load(imageInfo, zIndex);
+            return this.plotly.load(imageInfo, zIndex, signal);
         }
     }
     plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace) {
         this.currentPlotType = plotType;
+        this.plottedFileName = imageInfo?.fileName;
+        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
         // this inside its own plot(), but OSD doesn't, so drive it here. Idempotent
@@ -229,7 +226,9 @@ export class RoutingVisualizerService {
         this.lastRendered = next;
         return next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);
     }
-    reloadAndPlot() { this.plotly.reloadAndPlot(); }
+    reloadAndPlot() {
+        this.plotly.reloadAndPlot();
+    }
     reset() {
         // Start of a render cycle: re-enable napari-js/OSD attempts (clear any prior
         // per-image fallback) and tear down whatever's on screen.
@@ -237,47 +236,98 @@ export class RoutingVisualizerService {
         this.napariFellBack = false;
         this.renderer().reset();
     }
-    relayout(trueImageSize) { this.renderer().relayout(trueImageSize); }
-    resetAxes() { this.renderer().resetAxes(); }
-    autoscale() { this.renderer().autoscale(); }
-    zoomIn() { this.renderer().zoomIn(); }
-    zoomOut() { this.renderer().zoomOut(); }
-    setDragMode(mode) { this.renderer().setDragMode(mode); }
-    // Set on both backends (not just the active renderer): consumers call this
-    // before the first render, when `renderer()` is still the Plotly default, so
-    // OSD must receive the flag to honour it at viewer creation.
+    relayout(trueImageSize) {
+        this.renderer().relayout(trueImageSize);
+    }
+    resetAxes() {
+        this.renderer().resetAxes();
+    }
+    fitToView() {
+        this.renderer().fitToView();
+    }
+    /** @deprecated Use {@link fitToView}. */
+    autoscale() {
+        this.fitToView();
+    }
+    zoomIn() {
+        this.renderer().zoomIn();
+    }
+    zoomOut() {
+        this.renderer().zoomOut();
+    }
+    setDragMode(mode) {
+        this.renderer().setDragMode(mode);
+    }
+    /** Every backend, on screen or not. */
+    backends() {
+        return [this.plotly, this.osd, this.napari];
+    }
+    /**
+     * The navigator / smoothing options, applied to EVERY backend that has them (not
+     * just the active renderer): consumers set them before the first render, when
+     * `renderer()` is still the Plotly default, and OSD/napari-js must receive them
+     * to honour them at viewer creation.
+     */
+    getOsdViewOptions() {
+        return this.viewOptions;
+    }
+    /** @deprecated Use `getOsdViewOptions().setNavigatorVisible()`. */
     setNavigatorVisible(visible) {
-        this.osd.setNavigatorVisible(visible);
-        this.plotly.setNavigatorVisible(visible);
-        this.napari.setNavigatorVisible(visible);
+        this.viewOptions.setNavigatorVisible(visible);
     }
-    // Set on both backends (see setNavigatorVisible): consumers may set it before
-    // the first render, when the active renderer is still Plotly.
+    /** @deprecated Use `getOsdViewOptions().setImageSmoothingEnabled()`. */
     setImageSmoothingEnabled(enabled) {
-        this.osd.setImageSmoothingEnabled(enabled);
-        this.plotly.setImageSmoothingEnabled(enabled);
+        this.viewOptions.setImageSmoothingEnabled(enabled);
+    }
+    setShowStack(showstack) {
+        this.renderer().setShowStack(showstack);
     }
-    setShowStack(showstack) { this.renderer().setShowStack(showstack); }
     setZIndex(zIndex) {
         this.currentZIndex = zIndex;
         this.renderer().setZIndex(zIndex);
     }
-    getTrueImageSize() { return this.renderer().getTrueImageSize(); }
-    getCurrentImage() { return this.renderer().getCurrentImage(); }
-    getDisplayedPixelData() { return this.renderer().getDisplayedPixelData(); }
+    getTrueImageSize() {
+        return this.renderer().getTrueImageSize();
+    }
+    getCurrentImage() {
+        return this.renderer().getCurrentImage();
+    }
+    getDisplayedPixelData() {
+        return this.renderer().getDisplayedPixelData();
+    }
     getDisplayedSourceRect() {
         return this.renderer().getDisplayedSourceRect();
     }
-    downloadImage() { this.renderer().downloadImage(); }
-    exportComposite() { this.renderer().exportComposite(); }
+    downloadImage() {
+        this.renderer().downloadImage();
+    }
+    exportComposite() {
+        this.renderer().exportComposite();
+    }
     setPlotType(plotType) {
         this.currentPlotType = plotType;
         this.plotly.setPlotType(plotType);
     }
-    setSurfaceDragMode(mode) { this.renderer().setSurfaceDragMode(mode); }
-    resetSurfaceCamera() { this.renderer().resetSurfaceCamera(); }
-    setResolutionScale(scale) { this.renderer().setResolutionScale?.(scale); }
-    getResolutionScale() { return this.renderer().getResolutionScale?.() ?? 1; }
+    /** @deprecated Use `getSurface3dControls()`. */
+    setSurfaceDragMode(mode) {
+        this.getSurface3dControls()?.setSurfaceDragMode(mode);
+    }
+    /** @deprecated Use `getSurface3dControls()`. */
+    resetSurfaceCamera() {
+        this.getSurface3dControls()?.resetSurfaceCamera();
+    }
+    /** The 3D decimate factor of the backend on screen (napari-js), else null. */
+    getVolumeResolution() {
+        return this.renderer().getVolumeResolution();
+    }
+    /** @deprecated Use `getVolumeResolution()?.set()`. */
+    setResolutionScale(scale) {
+        this.getVolumeResolution()?.set(scale);
+    }
+    /** @deprecated Use `getVolumeResolution()?.get()`. */
+    getResolutionScale() {
+        return this.getVolumeResolution()?.get() ?? 1;
+    }
     /** The viewport of the backend on screen, for a contributed plot mode. Null
      *  when that backend cannot provide one (e.g. OSD fell back to Plotly). */
     getPlotModeViewport() {
@@ -289,10 +339,12 @@ export class RoutingVisualizerService {
         return this.plotly.getPlotTypeDescriptors();
     }
     // ── long-lived observables + stack flags ──────────────────────────────────
-    setStackLoading(b) { this.plotly.setStackLoading(b); }
+    setStackLoading(b) {
+        this.plotly.setStackLoading(b);
+    }
     // Cancel in-flight loading on every backend — the user's Cancel shouldn't depend on which one is
     // active. Only backends that stream frames (napari-js) do real work; the rest no-op. The concrete
-    // backend classes don't all declare the optional contract method, so call it via IVisualizer.
+    // backend classes don't all declare the optional contract method, so call it via IViewerBackend.
     cancelLoading() {
         for (const backend of [this.plotly, this.osd, this.napari]) {
             backend.cancelLoading?.();
@@ -319,82 +371,151 @@ export class RoutingVisualizerService {
             return active.length ? Math.max(...active) : 0;
         }));
     }
-    getAutoscaleEvent() { return this.plotly.getAutoscaleEvent(); }
-    getIntensityProfile$() { return this.plotly.getIntensityProfile$(); }
-    // The intensity inset is a Plotly LINE chart — render it through Plotly, which
-    // owns the profile stream regardless of which backend draws the main image.
+    // Every backend fits to view on its own (Plotly's autoscale, OSD's goHome, napari's camera
+    // fit) and each emits from its own subject, so merge all three: listening to Plotly alone
+    // missed the context-menu Autoscale on the Image and napari views.
+    getAutoscaleEvent() {
+        return merge(this.plotly.getAutoscaleEvent(), this.osd.getAutoscaleEvent(), this.napari.getAutoscaleEvent()).pipe(map(() => undefined));
+    }
+    /** The line-ROI profiles: sampled by the backend-neutral IntensityProfileService. */
+    getIntensityProfile$() {
+        return this.intensity.getIntensityProfile$();
+    }
+    // The intensity inset is a Plotly LINE chart — render it through Plotly whichever
+    // backend draws the main image.
     renderIntensityInset(divId, profiles) {
         this.plotly.renderIntensityInset(divId, profiles);
     }
-    // ── regions → active renderer ────────────────────────────────────────
-    // Region *state* lives in the shared RegionStore; both backends implement
-    // IRegionStore by delegating to it. We route through the active renderer
-    // (not hardcoded Plotly) so the backend on screen also *renders* the change:
-    // Plotly relayouts its shapes, OpenSeadragon's overlay redraws from the store
-    // update event. Either way the same store is the single source of truth.
+    // ── regions ──────────────────────────────────────────────────────────
+    // Region state lives in the shared RegionStore, so every read and write goes
+    // straight to it. Every backend draws from the store's events: the OSD and
+    // napari-js overlays and Plotly's shape projection redraw on its region-update
+    // and selection streams, and the canvas tools reset on getRegionSetReplaced$
+    // (undo, redo, a slice switch).
     setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append) {
-        this.renderer().setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);
-    }
-    getRegions() { return this.renderer().getRegions(); }
-    getRegionPolygons() { return this.renderer().getRegionPolygons(); }
-    getRegionUpdateEvent() { return this.renderer().getRegionUpdateEvent(); }
-    setSelectedShapeIndices(indices) { this.renderer().setSelectedShapeIndices(indices); }
-    selectRegion(region) { this.renderer().selectRegion(region); }
-    getSelectedShapeIndices$() { return this.renderer().getSelectedShapeIndices$(); }
-    deleteActiveShape() { this.renderer().deleteActiveShape(); }
-    getShowShapeLabel() { return this.renderer().getShowShapeLabel(); }
-    getShapeColor() { return this.renderer().getShapeColor(); }
-    getFillColor() { return this.renderer().getFillColor(); }
-    getClassificationColors() { return this.renderer().getClassificationColors(); }
+        this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);
+    }
+    getRegions() {
+        return this.regionStore.getRegions();
+    }
+    getRegionPolygons() {
+        return this.regionStore.getRegionPolygons();
+    }
+    getRegionUpdateEvent() {
+        return this.regionStore.getRegionUpdateEvent();
+    }
+    setSelectedShapeIndices(indices) {
+        this.regionStore.setSelectedShapeIndices(indices);
+    }
+    selectRegion(region) {
+        this.regionStore.selectRegion(region);
+    }
+    getSelectedShapeIndices$() {
+        return this.regionStore.getSelectedShapeIndices$();
+    }
+    deleteActiveShape() {
+        this.regionStore.deleteActiveShape();
+    }
+    getShowShapeLabel() {
+        return this.regionStore.getShowShapeLabel();
+    }
+    getShapeColor() {
+        return this.regionStore.getShapeColor();
+    }
+    getFillColor() {
+        return this.regionStore.getFillColor();
+    }
+    getClassificationColors() {
+        return this.store.getClassificationColors();
+    }
     setClassificationColor(label, color) {
-        this.renderer().setClassificationColor(label, color);
+        this.store.setClassificationColor(label, color);
     }
     // Annotation-class presets live in the shared VisualizerStore (backend-neutral
     // session state), so route straight to it rather than through renderer(). (jit-ui#70)
-    getPresetSet() { return this.store.getPresetSet(); }
-    getPresetSet$() { return this.store.getPresetSet$(); }
-    setPresetSet(set) { this.store.setPresetSet(set); }
-    upsertClass(preset) { this.store.upsertClass(preset); }
-    removeClass(name) { this.store.removeClass(name); }
-    resetPresets() { this.store.resetPresets(); }
-    plotPreviousShapes() { this.renderer().plotPreviousShapes(); }
-    setPreviousShapes(shapes) { this.renderer().setPreviousShapes(shapes); }
-    getPreviousShapes() { return this.renderer().getPreviousShapes(); }
-    // Undo state is owned by the shared RegionStore (same instance for both
-    // backends), so routing through the active renderer is safe and stable.
-    undo() { this.renderer().undo(); }
-    redo() { this.renderer().redo(); }
-    canUndo() { return this.renderer().canUndo(); }
-    canRedo() { return this.renderer().canRedo(); }
-    getCanUndo$() { return this.renderer().getCanUndo$(); }
-    getCanRedo$() { return this.renderer().getCanRedo$(); }
-    resetUndoHistory() { this.renderer().resetUndoHistory(); }
-    importRegions(geoJsonStr) { return this.renderer().importRegions(geoJsonStr); }
-    exportRegions(regions) { this.renderer().exportRegions(regions); }
-    getGeoJsonString(regions) { return this.renderer().getGeoJsonString(regions); }
-    // ── Per-slice z-stack regions (jit-ui#93) — the RegionStore is shared across
-    //    backends, so routing to the active renderer hits the same store. ──────
+    getPresetSet() {
+        return this.store.getPresetSet();
+    }
+    getPresetSet$() {
+        return this.store.getPresetSet$();
+    }
+    setPresetSet(set) {
+        this.store.setPresetSet(set);
+    }
+    upsertClass(preset) {
+        this.store.upsertClass(preset);
+    }
+    removeClass(name) {
+        this.store.removeClass(name);
+    }
+    resetPresets() {
+        this.store.resetPresets();
+    }
+    undo() {
+        this.regionStore.undo();
+    }
+    redo() {
+        this.regionStore.redo();
+    }
+    canUndo() {
+        return this.regionStore.canUndo();
+    }
+    canRedo() {
+        return this.regionStore.canRedo();
+    }
+    getCanUndo$() {
+        return this.regionStore.getCanUndo$();
+    }
+    getCanRedo$() {
+        return this.regionStore.getCanRedo$();
+    }
+    resetUndoHistory() {
+        this.regionStore.resetUndoHistory();
+    }
+    importRegions(geoJsonStr) {
+        return this.regionStore.importRegions(geoJsonStr);
+    }
+    /** Download `regions` as GeoJSON, named after the image last plotted. */
+    exportRegions(regions) {
+        this.regionStore.exportRegions(regions, this.plottedFileName);
+    }
+    getGeoJsonString(regions) {
+        return this.regionStore.getGeoJsonString(regions);
+    }
+    // ── Per-slice z-stack regions (jit-ui#93), from the shared RegionStore. ──
     enterStackMode(slices, initialZ, saveLayout) {
-        this.renderer().enterStackMode(slices, initialZ, saveLayout);
-    }
-    exitStackMode() { this.renderer().exitStackMode(); }
-    isStackMode() { return this.renderer().isStackMode(); }
-    getStackSaveLayout() { return this.renderer().getStackSaveLayout(); }
-    setDisplaySlice(z) { this.renderer().setDisplaySlice(z); }
-    getSliceRegions() { return this.renderer().getSliceRegions(); }
-    getStackSaveSlices() { return this.renderer().getStackSaveSlices(); }
+        this.regionStore.enterStackMode(slices, initialZ, saveLayout);
+    }
+    exitStackMode() {
+        this.regionStore.exitStackMode();
+    }
+    isStackMode() {
+        return this.regionStore.isStackMode();
+    }
+    getStackSaveLayout() {
+        return this.regionStore.getStackSaveLayout();
+    }
+    setDisplaySlice(z) {
+        this.regionStore.setDisplaySlice(z);
+    }
+    getSliceRegions() {
+        return this.regionStore.getSliceRegions();
+    }
+    getStackSaveSlices() {
+        return this.regionStore.getStackSaveSlices();
+    }
     /** All slices' ANNOTATION regions for a z-stack save (jit-ui#93), each tagged
      *  with its zero-based Region.z; profile lines excluded. Flat annotation set
      *  outside stack mode. */
     getSliceAnnotationRegions() {
-        return this.renderer().getSliceRegions().filter((r) => !isProfileRegion(r));
+        return this.regionStore.getSliceRegions().filter((r) => !isProfileRegion(r));
     }
     /** Per-slice annotation regions to write on a folder-stack save (jit-ui#93):
      *  slice index → that slice's annotation regions (profile lines excluded),
      *  including now-empty slices that were loaded non-empty (so they overwrite). */
     getStackSaveAnnotationSlices() {
         const out = new Map();
-        for (const [z, regs] of this.renderer().getStackSaveSlices()) {
+        for (const [z, regs] of this.regionStore.getStackSaveSlices()) {
             out.set(z, regs.filter((r) => !isProfileRegion(r)));
         }
         return out;
@@ -405,81 +526,126 @@ export class RoutingVisualizerService {
      *  or non-positive sizes — the Plotly bounds can yield NaN before a plot is
      *  fully laid out, which would otherwise crash mask creation. */
     getMaskImageSize() {
-        const valid = (s) => s && Number.isFinite(s.width) && Number.isFinite(s.height) &&
-            s.width >= 1 && s.height >= 1
+        const valid = (s) => s && Number.isFinite(s.width) && Number.isFinite(s.height) && s.width >= 1 && s.height >= 1
             ? { width: Math.round(s.width), height: Math.round(s.height) }
             : null;
         const fromRenderer = valid(this.getTrueImageSize());
         if (fromRenderer)
             return fromRenderer;
         let meta = [];
-        this.getImageMeta().subscribe((m) => (meta = m)).unsubscribe();
+        this.getImageMeta()
+            .subscribe((m) => (meta = m))
+            .unsubscribe();
         const m0 = meta?.[0];
         return m0 ? valid({ width: m0.x, height: m0.y }) : null;
     }
     // ── IRegionEditorApi: annotation-only surface for the Region Editor ───
     // Intensity-profile lines (kind='profile') belong to the intensity tool, not
     // the editor. These methods give external consumers an annotation-only view
-    // and guarantee profile lines are preserved. Routing (not the store) owns this
-    // so writes/selection go through renderer() and the active backend re-renders
-    // (Plotly relayouts its shapes in setRegions; it doesn't on regionUpdate$).
+    // and guarantee profile lines are preserved. The writes land in the store like
+    // any other, and every backend redraws from its events.
     getAnnotationRegions() {
-        return this.renderer().getRegions().filter((r) => !isProfileRegion(r));
+        return this.regionStore.getRegions().filter((r) => !isProfileRegion(r));
     }
     setAnnotationRegions(regions, showRegionLabel, isRegionSaveOn, fillColor) {
-        // Re-append the store's profile lines so an editor save/delete can't drop
-        // them, then route through setRegions so the active backend re-renders.
-        const profiles = this.renderer().getRegions().filter((r) => isProfileRegion(r));
+        // Re-append the store's profile lines so an editor save/delete can't drop them.
+        const profiles = this.regionStore.getRegions().filter((r) => isProfileRegion(r));
         const annotations = (regions || []).filter((r) => !isProfileRegion(r));
         this.setRegions([...annotations, ...profiles], showRegionLabel, isRegionSaveOn, fillColor, false);
     }
     getSelectedRegions$() {
         // Map the internal index-based selection to the selected annotation regions.
         return this.getSelectedShapeIndices$().pipe(map((idxs) => {
-            const regs = this.renderer().getRegions();
-            return idxs
-                .map((i) => regs[i])
-                .filter((r) => !!r && !isProfileRegion(r));
+            const regs = this.regionStore.getRegions();
+            return idxs.map((i) => regs[i]).filter((r) => !!r && !isProfileRegion(r));
         }));
     }
     setSelectedRegions(regions) {
-        const regs = this.renderer().getRegions();
-        const indices = (regions || [])
-            .map((r) => regs.findIndex((x) => x.id === r.id))
-            .filter((i) => i >= 0);
+        const regs = this.regionStore.getRegions();
+        const indices = (regions || []).map((r) => regs.findIndex((x) => x.id === r.id)).filter((i) => i >= 0);
         this.setSelectedShapeIndices(indices);
     }
     // ── tools → active renderer (run on either backend) ─────────────────
     // The wand, vertex eraser and zoom-to-box are implemented on both backends
     // via ICoordinateTransform (+ a viewport pixel readback for the wand), so they
     // follow the active renderer.
-    setWandMode(active, options) { this.renderer().setWandMode(active, options); }
-    setWandOptions(options) { this.renderer().setWandOptions(options); }
-    clearActiveWandRegion() { this.renderer().clearActiveWandRegion(); }
-    setBrushMode(active, options) { this.renderer().setBrushMode(active, options); }
-    setBrushOptions(options) { this.renderer().setBrushOptions(options); }
-    setVertexEraserMode(active) { this.renderer().setVertexEraserMode(active); }
-    setVertexEraserRadius(radius) { this.renderer().setVertexEraserRadius(radius); }
-    setZoomToBoxMode(active) { this.renderer().setZoomToBoxMode(active); }
-    segmentRectangles() { return this.renderer().segmentRectangles(); }
-    segmentRectanglesCellpose() { return this.renderer().segmentRectanglesCellpose(); }
-    setSamModel(id) { this.renderer().setSamModel(id); }
-    setSamPointMode(active) { this.renderer().setSamPointMode(active); }
-    commitSamPoints() { this.renderer().commitSamPoints(); }
-    clearSamPoints() { this.renderer().clearSamPoints(); }
+    setActiveTool(id, options) {
+        this.renderer().setActiveTool(id, options);
+    }
+    /** @deprecated Use {@link setActiveTool}. */
+    setWandMode(active, options) {
+        this.renderer().setWandMode(active, options);
+    }
+    setWandOptions(options) {
+        this.renderer().setWandOptions(options);
+    }
+    clearActiveWandRegion() {
+        this.renderer().clearActiveWandRegion();
+    }
+    /** @deprecated Use {@link setActiveTool}. */
+    setBrushMode(active, options) {
+        this.renderer().setBrushMode(active, options);
+    }
+    setBrushOptions(options) {
+        this.renderer().setBrushOptions(options);
+    }
+    /** @deprecated Use {@link setActiveTool}. */
+    setVertexEraserMode(active) {
+        this.renderer().setVertexEraserMode(active);
+    }
+    setVertexEraserRadius(radius) {
+        this.renderer().setVertexEraserRadius(radius);
+    }
+    /** @deprecated Use {@link setActiveTool}. */
+    setZoomToBoxMode(active) {
+        this.renderer().setZoomToBoxMode(active);
+    }
+    segmentRectangles() {
+        return this.renderer().segmentRectangles();
+    }
+    segmentRectanglesCellpose() {
+        return this.renderer().segmentRectanglesCellpose();
+    }
+    setSamModel(id) {
+        this.renderer().setSamModel(id);
+    }
+    /** @deprecated Use {@link setActiveTool}. */
+    setSamPointMode(active) {
+        this.renderer().setSamPointMode(active);
+    }
+    commitSamPoints() {
+        this.renderer().commitSamPoints();
+    }
+    clearSamPoints() {
+        this.renderer().clearSamPoints();
+    }
     // ── display options ──────────────────────────────────────────────────
     // State lives in the shared VisualizerStore — reads go straight to it.
     // The two SETTERS still route through Plotly because its implementations
     // carry render glue beyond the store write (a live Plotly.restyle of
     // colorscale/reversescale on the mounted heatmap); OSD recolors via its own
     // store subscription either way.
-    getColormap() { return this.store.getColormap(); }
-    setColormap(colormap) { this.plotly.setColormap(colormap); }
-    getColormapOptions() { return this.store.getColormapOptions(); }
-    getReverseScale() { return this.store.getReverseScale(); }
-    setReverseScale(reverscale) { this.plotly.setReverseScale(reverscale); }
-    setImageMeta(imageMeta) { this.store.setImageMeta(imageMeta); }
-    getImageMeta() { return this.store.getImageMeta(); }
+    getColormap() {
+        return this.store.getColormap();
+    }
+    setColormap(colormap) {
+        this.plotly.setColormap(colormap);
+    }
+    getColormapOptions() {
+        return this.store.getColormapOptions();
+    }
+    getReverseScale() {
+        return this.store.getReverseScale();
+    }
+    setReverseScale(reverse) {
+        this.plotly.setReverseScale(reverse);
+    }
+    setImageMeta(imageMeta, imageKey) {
+        this.store.setImageMeta(imageMeta, imageKey);
+    }
+    getImageMeta() {
+        return this.store.getImageMeta();
+    }
     // ── IChannelHistogramApi: Channels & Histogram pane surface ───────────
     // Channel/grayscale/invert state lives in the shared VisualizerStore; both
     // backends subscribe and recolor live, so setters just write the store. The
@@ -491,9 +657,15 @@ export class RoutingVisualizerService {
         return this.renderer().getHistogram$(channelIndex, bins);
     }
     /** Export the underlying data (16-bit multi-band TIFF) via the active backend. */
-    exportData() { this.renderer().exportData(); }
-    getChannels$() { return this.store.getChannelStates(); }
-    setSelectedChannel(index) { this.store.setSelectedChannel(index); }
+    exportData() {
+        this.renderer().exportData();
+    }
+    getChannels$() {
+        return this.store.getChannelStates();
+    }
+    setSelectedChannel(index) {
+        this.store.setSelectedChannel(index);
+    }
     setChannelState(index, partial) {
         this.store.setChannelState(index, partial);
     }
@@ -509,15 +681,23 @@ export class RoutingVisualizerService {
             const h = this.renderer().getHistogram(i, 256);
             if (!h)
                 continue;
-            const [min, max] = autoWindowFromHistogram(h, saturation);
+            const [min, max] = autoWindowFromHistogram(h, saturation, [0, 255]);
             if (max > min)
                 this.store.setChannelState(i, { min, max });
         }
     }
-    getGrayscale$() { return this.store.getGrayscale(); }
-    setGrayscale(on) { this.store.setGrayscale(on); }
-    getInvert$() { return this.store.getInvert(); }
-    setInvert(on) { this.store.setInvert(on); }
+    getGrayscale$() {
+        return this.store.getGrayscale();
+    }
+    setGrayscale(on) {
+        this.store.setGrayscale(on);
+    }
+    getInvert$() {
+        return this.store.getInvert();
+    }
+    setInvert(on) {
+        this.store.setInvert(on);
+    }
     /**
      * The active backend's region overlay. Falls back to Plotly's when the active backend
      * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a
@@ -533,219 +713,87 @@ export class RoutingVisualizerService {
         }
         return this.plotly.getRegionOverlay();
     }
+    /** Isosurface controls of the backend on screen, when it renders isosurfaces. */
+    getIsosurfaceControls() {
+        return this.renderer().getIsosurfaceControls();
+    }
+    /** 3D scene controls of the backend on screen (Plotly or napari-js), or null on a
+     *  2D-only one. */
+    getSurface3dControls() {
+        return this.renderer().getSurface3dControls();
+    }
+    /** Intensity (line-ROI) controls, whichever backend draws the image: the
+     *  IntensityProfileService adds the line to the store, and every backend
+     *  (Plotly included) draws it from the store's update event. */
+    getIntensityControls() {
+        return this.intensity;
+    }
     /**
-     * Isosurface controls when available — always Plotly's, since the isosurface
-     * plot type renders on Plotly (OSD only handles the image type).
-     */
-    getIsosurfaceControls() { return this.renderer().getIsosurfaceControls(); }
-    /** 3D scene controls — always Plotly's, since the 3D plot types render on
-     *  Plotly (OSD only handles the image type). */
-    getSurface3dControls() { return this.renderer().getSurface3dControls(); }
-    /** Intensity (line-ROI) controls — always Plotly's, since the line profiles
-     *  render their inset on Plotly regardless of which backend draws the image. */
-    getIntensityControls() { return this.plotly.getIntensityControls(); }
-    /**
-     * Spatial-omics controls, or null when no `SPATIAL_DATA_PORT` is bound.
-     *
-     * Implemented HERE rather than on a backend because the state is
-     * backend-neutral: the view state lives in the shared `VisualizerStore` (like
-     * the colormap), so the controls keep working across a plot-type switch and a
-     * host can drive them before any backend has mounted.
+     * Spatial-omics controls, or null when no `SPATIAL_DATA_PORT` is bound. Served by a
+     * backend-neutral {@link SpatialControlsFacade} (state in the shared stores), so the
+     * controls work across a plot-type switch and before any backend has mounted.
      */
     getSpatialControls() {
-        const port = this.spatialData;
-        if (!port)
+        if (!this.spatialData)
             return null;
-        // Mirror the dataset (and drop a stale selection when it changes — the masks
-        // are index-based, so they are meaningless against different observations).
-        this.spatialDatasetSub ??= port.getDataset$().subscribe((dataset) => {
-            const changed = dataset?.id !== this.currentSpatialDataset?.id;
-            this.currentSpatialDataset = dataset;
-            if (!changed)
-                return;
-            this.selectionStore.set(emptySelection(dataset?.observations.count ?? 0));
-            // A colour source the new dataset cannot satisfy would leave the map flat
-            // while the panel and the charts kept naming the old column — so drop it,
-            // and only it: point size, opacity and the rest are the user's preferences,
-            // not the previous dataset's state.
-            const by = this.store.currentSpatialView().colorBy;
-            if (by && !this.canColorBy(dataset, by))
-                this.store.setSpatialView({ colorBy: null });
+        this.spatialFacade ??= new SpatialControlsFacade(this.spatialData, {
+            store: this.store,
+            regionStore: this.regionStore,
+            selectionStore: this.selectionStore,
+            napari: this.napari,
+            plotType: () => this.currentPlotType,
+            zIndex: () => this.currentZIndex,
         });
-        this.spatialControls ??= {
-            getDataset$: () => port.getDataset$(),
-            getViewState$: () => this.store.getSpatialView$(),
-            viewState: () => this.store.currentSpatialView(),
-            setViewState: (partial) => this.store.setSpatialView(partial),
-            // The hint SEEDS the toggle when the source changes, and nothing consults it
-            // afterwards. It used to be ORed in at render time, which meant an unchecked
-            // box could not turn log scaling off for a hinted column — and the linked
-            // chart, which reads `logScale` alone, disagreed with the map about what it
-            // was showing. One authority, set once per source.
-            colorByColumn: (name) => {
-                const meta = this.currentSpatialDataset?.columns.find((c) => c.name === name);
-                const hint = meta?.kind === 'continuous' ? !!meta.logScaleHint : false;
-                this.store.setSpatialView({ colorBy: { kind: 'column', name }, logScale: hint });
-            },
-            colorByFeature: (name) => this.store.setSpatialView({
-                colorBy: { kind: 'feature', name },
-                logScale: !!this.currentSpatialDataset?.features?.logScaleHint,
-            }),
-            clearColorBy: () => this.store.setSpatialView({ colorBy: null }),
-            searchFeatures: async (query, limit = 50) => {
-                // Prefer the port's search (a 31k-gene dataset does not ship its names);
-                // otherwise filter whatever the manifest inlined.
-                if (port.searchFeatures)
-                    return port.searchFeatures(query, limit);
-                const dataset = await firstValueFrom(port.getDataset$());
-                const names = dataset?.features?.names ?? [];
-                const q = query.toLowerCase();
-                return names.filter((n) => n.toLowerCase().includes(q)).slice(0, limit);
-            },
-            ...(port.importGroups ? {
-                importGroups: (label, table) => port.importGroups(label, table),
-            } : {}),
-            ...(port.getTranscriptCounts ? {
-                transcriptCounts: (genes) => port.getTranscriptCounts(genes),
-            } : {}),
-            ...(port.getMarkerGenes ? {
-                markerGenes: (column, perGroup) => port.getMarkerGenes(column, perGroup),
-            } : {}),
-            getTranscriptEstimate$: () => this.napari.transcriptEstimate$.asObservable(),
-            getGeneCountsInView$: () => this.napari.geneCountsInView$.asObservable(),
-            getDensityStats$: () => this.napari.densityStats$.asObservable(),
-            categoryColors: async (name) => {
-                const column = await port.getColumn(name);
-                if (!isCategoricalColumn(column)) {
-                    throw new Error(`[spatial] column "${name}" is continuous — it has no categories`);
-                }
-                // Resolved by the SAME function the renderer uses, so a legend swatch
-                // can never disagree with the colour on screen.
-                return resolveCategoryColors(column.meta);
-            },
-            continuousValues: async (source) => {
-                if (source.kind === 'feature')
-                    return port.getFeatureVector(source.name);
-                const column = await port.getColumn(source.name);
-                if (isCategoricalColumn(column)) {
-                    throw new Error(`[spatial] column "${source.name}" is categorical — it has no values to chart`);
-                }
-                return column.values;
-            },
-            categoricalView: async (name) => {
-                const column = await port.getColumn(name);
-                if (!isCategoricalColumn(column)) {
-                    throw new Error(`[spatial] column "${name}" is continuous — it has no categories`);
-                }
-                return {
-                    name,
-                    categories: column.meta.categories,
-                    colors: resolveCategoryColors(column.meta),
-                    codes: column.codes,
-                };
-            },
-            // Spread rather than always defined: `getEmbedding` is optional on both the port
-            // and this facade, and a panel checks for its presence to decide whether the view
-            // is offered at all. Defining it as a function that rejects would make an
-            // embedding-less source look like a broken one.
-            ...(port.getEmbedding
-                ? { getEmbedding: (name) => port.getEmbedding(name) }
-                : {}),
-            categoricalColumns: () => (this.currentSpatialDataset?.columns ?? [])
-                .filter((c) => c.kind === 'categorical')
-                .map((c) => c.name),
-            // Memoized on the observations object, so the renderer's own lookup and
-            // this one are the same single scan of up to 3.7M z values.
-            sampledSections: () => {
-                const obs = this.currentSpatialDataset?.observations;
-                return obs ? sectionsOf(obs) : null;
-            },
-            getSelection$: () => this.selectionStore.getSelection$(),
-            selectFromRegions: () => {
-                const dataset = this.currentSpatialDataset;
-                if (!dataset)
-                    return 0;
-                const regions = this.regionStore.getRegions();
-                // The union of every drawn region — so every ROI tool the library
-                // already has doubles as a spatial selection tool.
-                //
-                // In the 3D cloud there is no data-space affine to push a drawn shape
-                // through, so the observations are projected to canvas pixels by the
-                // renderer (which owns the camera) and tested in screen space instead.
-                // Falls back to the 2D path whenever the cloud is not mounted.
-                const projected = isSpatialOmics3d(this.currentPlotType)
-                    ? this.napari.getSpatialScreenProjection(dataset.observations)
-                    : null;
-                // In the 2D view of a volume-backed dataset the shape was drawn over ONE
-                // section, in the volume's pixel grid: it selects the cells of that
-                // section, not the whole depth of brain standing behind them.
-                const volume = !dataset.imageRef ? dataset.volume : undefined;
-                const selection = projected
-                    ? selectInRegionsProjected(projected, dataset.observations.count, regions)
-                    : selectInRegions(dataset.observations, volume ? volumeImageRef(volume, dataset.micronsPerUnit) : dataset.imageRef, regions, volume
-                        ? observationsInSlice(dataset.observations, volume, this.currentZIndex)
-                        : undefined);
-                this.selectionStore.set(selection);
-                return selection.count;
-            },
-            selectCategory: async (column, categoryIndex) => {
-                const loaded = await port.getColumn(column);
-                if (!isCategoricalColumn(loaded)) {
-                    throw new Error(`[spatial] column "${column}" is continuous — it has no categories`);
-                }
-                const selection = selectByCategory(loaded.codes, categoryIndex);
-                this.selectionStore.set(selection);
-                return selection.count;
-            },
-            selectIndices: (indices) => {
-                const count = this.currentSpatialDataset?.observations.count ?? 0;
-                if (count === 0)
-                    return 0;
-                const selection = selectByIndices(indices, count);
-                this.selectionStore.set(selection);
-                return selection.count;
-            },
-            clearSelection: () => this.selectionStore.clear(),
-        };
-        return this.spatialControls;
+        return this.spatialFacade.controls;
+    }
+    /** Angular calls this when the injector providing the router is destroyed — the host
+     *  component for a `provideVisualization()` chain. The dataset subscription would
+     *  otherwise keep the whole isolated chain reachable from the root data port. */
+    ngOnDestroy() {
+        this.spatialFacade?.dispose();
+        this.spatialFacade = null;
     }
     /**
-     * Whether `dataset` can answer this colour source.
-     *
-     * A column is checkable against the declared list. A gene is checkable only when
-     * the dataset inlines its feature names — a dataset too wide to inline them
-     * (typeahead-only) keeps the source, and a name that turns out not to exist
-     * surfaces as the chart's "could not be charted" rather than as a silent reset.
+     * Intensity-profile sampling, whichever backend is on screen: the sampling is the
+     * backend-neutral IntensityProfileService's; the viewport changes come from every
+     * backend that reports them (OpenSeadragon, napari-js), merged into one stable
+     * stream the inset subscribes to once.
      */
-    canColorBy(dataset, by) {
-        if (!dataset)
-            return false;
-        if (by.kind === 'column')
-            return dataset.columns.some((c) => c.name === by.name);
-        const names = dataset.features?.names;
-        return !!dataset.features && (!names || names.includes(by.name));
-    }
-    /** Load pixel frames for intensity sampling when OpenSeadragon owns the image
-     *  (it doesn't feed Plotly's frame cache). No-op needed when Plotly renders. */
+    getIntensitySampling() {
+        return this.intensitySampling;
+    }
+    /** @deprecated Use `getIntensitySampling().ensureIntensitySampling()`. */
     ensureIntensitySampling(imageInfo, zIndex) {
-        return this.plotly.ensureIntensitySampling(imageInfo, zIndex);
+        return this.intensitySampling.ensureIntensitySampling(imageInfo, zIndex);
     }
-    /** Visible-region changes from the OpenSeadragon viewer (image-pixel coords),
-     *  so the intensity inset can re-sample at the current zoom level. Plotly's own
-     *  high-def zoom updates the sampling cache inline, so only OSD feeds this. */
+    /** Crops for sampling are sized from the plot div (whichever backend renders into it). */
+    pointSamplingAtPlot() {
+        if (this.plotDiv)
+            this.intensity.setSamplingElement(this.plotDiv);
+    }
+    /** @deprecated Use `getIntensitySampling().getViewportChange$()`. */
     getViewportChange$() {
-        return this.osd.getViewportChange$();
+        return this.intensitySampling.getViewportChange$();
     }
-    /** Re-sample the intensity profiles from a fresh crop of the given image-pixel
-     *  ROI at display resolution (sampling always lives in Plotly). */
+    /** @deprecated Use `getIntensitySampling().refreshIntensitySamplingForRoi()`. */
     refreshIntensitySamplingForRoi(x, y, width, height, zIndex) {
-        this.plotly.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);
+        this.intensitySampling.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);
+    }
+    /** The visualizer view is going away: detach every backend — dropping their view-bound
+     *  subscriptions and disposing the napari-js viewer, whose canvas, render loop and GPU
+     *  buffers would otherwise outlive the view (for a component-scoped chain, forever).
+     *  Nothing is on screen afterwards, so the next plot starts from the default backend. */
+    detach() {
+        this.plotly.detach();
+        this.osd.detach();
+        this.napari.detach();
+        this.lastRendered = null;
     }
+    /** @deprecated Use {@link detach}. */
     unsubscribe() {
-        this.plotly.unsubscribe();
-        this.osd.unsubscribe();
+        this.detach();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RoutingVisualizerService, deps: [{ token: i1.PlotlyService }, { token: i2.OpenSeadragonVisualizerService }, { token: i3.NapariVisualizerService }, { token: i4.VisualizerStore }, { token: VIZ_CONFIG }, { token: i5.RegionStore }, { token: i6.SpatialSelectionStore }, { token: SPATIAL_DATA_PORT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RoutingVisualizerService, deps: [{ token: i1.PlotlyService }, { token: i2.OpenSeadragonVisualizerService }, { token: i3.NapariVisualizerService }, { token: i4.VisualizerStore }, { token: VIZ_CONFIG }, { token: i5.RegionStore }, { token: i6.SpatialSelectionStore }, { token: i7.IntensityProfileService }, { token: SPATIAL_DATA_PORT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RoutingVisualizerService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RoutingVisualizerService, decorators: [{
@@ -754,10 +802,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
         }], ctorParameters: () => [{ type: i1.PlotlyService }, { type: i2.OpenSeadragonVisualizerService }, { type: i3.NapariVisualizerService }, { type: i4.VisualizerStore }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [VIZ_CONFIG]
-                }] }, { type: i5.RegionStore }, { type: i6.SpatialSelectionStore }, { type: undefined, decorators: [{
+                }] }, { type: i5.RegionStore }, { type: i6.SpatialSelectionStore }, { type: i7.IntensityProfileService }, { type: undefined, decorators: [{
                     type: Optional
                 }, {
                     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, Optional } from '@angular/core';\nimport { Observable, Subscription, combineLatest, firstValueFrom } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { Image } from 'image-js';\n\nimport { IImageInfo, IImageMetadata } from './contracts/image.contract';\nimport { 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 { PlotType, PlotTypeDescriptor, isNapari3d, isNapariScatter, isSpatialOmics, isSpatialOmics3d } from './contracts/plot-type';\nimport { IVisualizer, PixelData, IntensityProfile, IIsosurfaceControls, IIntensityControls, ISurface3dControls, ISpatialControls } from './contracts/visualizer.contract';\nimport { SPATIAL_DATA_PORT, SpatialDataPort } from './contracts/ports/spatial-data.port';\nimport { SpatialColorBy } from './contracts/display-types';\nimport { SpatialDataset, isCategoricalColumn } from './contracts/spatial-dataset.contract';\nimport { resolveCategoryColors } from './spatial/spatial-encoding';\nimport { sectionsOf } from './spatial/spatial-sections';\nimport {\n  observationsInSlice, volumeImageRef,\n} from './spatial/spatial-volume-image';\nimport {\n  emptySelection,\n  selectByCategory,\n  selectByIndices,\n  selectInRegions,\n  selectInRegionsProjected,\n} from './spatial/spatial-selection';\nimport { RegionStore } from './store/region-store.service';\nimport { SpatialSelectionStore } from './store/spatial-selection.service';\nimport { ViewerCapabilities } from './contracts/capabilities.contract';\nimport { IRegionOverlay } from './contracts/region-overlay.contract';\nimport { IRegionEditorApi } from './contracts/region-editor-api.contract';\nimport { IChannelHistogramApi, IChannelState, IHistogram } from './contracts/channel-histogram-api.contract';\nimport { VisualizerStore } from './store/visualizer-store.service';\nimport { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';\nimport { VIZ_CONFIG, VizConfig } from './contracts/viz-config';\nimport { PlotModeViewport } from './contracts/plot-type-contribution.contract';\n\n/**\n * Backend selector. Routes per plot type:\n *  - the **Image** plot type renders through OpenSeadragon — a natively-tiled,\n *    zoomable raster backed by the jit-service tile endpoints. It's the default\n *    view and supports the region overlay/tools and (for grayscale) the\n *    colormap, applied client-side via the tile pixel pipeline.\n *  - every other plot type (heatmap, surface, contour, scatter, line,\n *    scatter3d, isosurface) renders through Plotly.\n *\n * Only the **render + viewport** path is routed. Region state, display options\n * (colormap/LUT), and the long-lived observables always live in Plotly (the\n * shared store) so both backends stay in sync; OSD reads them to drive its own\n * overlay and tile recoloring.\n *\n * The Image type renders through OpenSeadragon; a failed OSD load falls back to\n * Plotly for that image only (see `osdFellBack`) so it still renders.\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: any): boolean {\n  return r?.kind === 'profile';\n}\n\n/** Saturation-based auto-window: pick [min,max] so ~`saturation` of pixels clip\n *  at each end of the histogram. A dominant first/last bin (unscanned padding /\n *  clipped background) is dropped so it doesn't skew the range. */\nfunction autoWindowFromHistogram(h: IHistogram, saturation: number): [number, number] {\n  const counts = h.counts.slice();\n  const n = counts.length;\n  if (n === 0) return [0, 255];\n  if (n > 2 && counts[0] > counts[1]) counts[0] = 0;\n  if (n > 2 && counts[n - 1] > counts[n - 2]) counts[n - 1] = 0;\n  let total = 0;\n  for (const c of counts) total += c;\n  if (total <= 0) return [0, 255];\n  const target = total * Math.max(0, Math.min(0.5, saturation));\n  let acc = 0;\n  let min = h.bins[0];\n  for (let i = 0; i < n; i++) {\n    acc += counts[i];\n    if (acc > target) { min = h.bins[i]; break; }\n  }\n  acc = 0;\n  let max = h.bins[n - 1];\n  for (let i = n - 1; i >= 0; i--) {\n    acc += counts[i];\n    if (acc > target) { max = h.bins[i]; break; }\n  }\n  return [min, max];\n}\n\n@Injectable({ providedIn: 'root' })\nexport class RoutingVisualizerService implements IVisualizer, IRegionEditorApi, IChannelHistogramApi {\n\n  private currentPlotType: PlotType = PlotType.IMAGE;\n  private lastRendered: IVisualizer | 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\n  constructor(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              @Optional() @Inject(SPATIAL_DATA_PORT)\n              private spatialData: SpatialDataPort | null = null) {}\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(): IVisualizer {\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(): IVisualizer {\n    return this.lastRendered ?? this.plotly;\n  }\n\n  // System capabilities are Plotly's (the full-featured backend) so the UI\n  // keeps offering every plot type regardless of which one is on screen.\n  get capabilities(): ViewerCapabilities { return this.plotly.capabilities; }\n\n  // ── render / viewport → active renderer ──────────────────────────────\n  async load(imageInfo: IImageInfo, zIndex: number): Promise<any> {\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);\n      } catch (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);\n        }\n        console.warn('[visualizer] napari-js load failed — falling back to OpenSeadragon.', err);\n        return this.loadViaOsdThenPlotly(imageInfo, zIndex);\n      }\n    }\n    if (backend === this.osd) {\n      return this.loadViaOsdThenPlotly(imageInfo, zIndex);\n    }\n    return this.plotly.load(imageInfo, zIndex);\n  }\n\n  /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */\n  private async loadViaOsdThenPlotly(imageInfo: IImageInfo, zIndex: number): Promise<any> {\n    try {\n      return await this.osd.load(imageInfo, zIndex);\n    } catch (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);\n    }\n  }\n  plot(plotDiv: string, imageLoaded: any, imageInfo: IImageInfo, screenHeight: number,\n       plotType: PlotType, inPlace?: boolean): Promise<boolean> {\n    this.currentPlotType = plotType;\n    // Apply the per-image region cache (snapshot old regions, restore the new\n    // image's, clear selection) for whichever backend renders — Plotly does\n    // this inside its own plot(), but OSD doesn't, so drive it here. Idempotent\n    // for the same image, so it's safe to call on every (re)plot.\n    this.plotly.setActiveImage(imageInfo);\n    const next = this.imageBackend();\n    // Both backends share the same div — tear down the outgoing one on switch.\n    // Plotly must be *purged* (not reset, which re-draws empty axes) before OSD\n    // takes the div.\n    if (this.lastRendered && this.lastRendered !== next) {\n      if (this.lastRendered === this.plotly) this.plotly.purgePlot();\n      else this.lastRendered.reset();\n    }\n    this.lastRendered = next;\n    return next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);\n  }\n  reloadAndPlot(): void { this.plotly.reloadAndPlot(); }\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 { this.renderer().relayout(trueImageSize); }\n  resetAxes(): void { this.renderer().resetAxes(); }\n  autoscale(): void { this.renderer().autoscale(); }\n  zoomIn(): void { this.renderer().zoomIn(); }\n  zoomOut(): void { this.renderer().zoomOut(); }\n  setDragMode(mode: string | false): void { this.renderer().setDragMode(mode); }\n  // Set on both backends (not just the active renderer): consumers call this\n  // before the first render, when `renderer()` is still the Plotly default, so\n  // OSD must receive the flag to honour it at viewer creation.\n  setNavigatorVisible(visible: boolean): void {\n    this.osd.setNavigatorVisible(visible);\n    this.plotly.setNavigatorVisible(visible);\n    this.napari.setNavigatorVisible(visible);\n  }\n  // Set on both backends (see setNavigatorVisible): consumers may set it before\n  // the first render, when the active renderer is still Plotly.\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.osd.setImageSmoothingEnabled(enabled);\n    this.plotly.setImageSmoothingEnabled(enabled);\n  }\n  setShowStack(showstack: boolean): void { this.renderer().setShowStack(showstack); }\n  setZIndex(zIndex: number): void {\n    this.currentZIndex = zIndex;\n    this.renderer().setZIndex(zIndex);\n  }\n  getTrueImageSize(): { width: number; height: number } | null { return this.renderer().getTrueImageSize(); }\n  getCurrentImage(): Promise<Image | null> { return this.renderer().getCurrentImage(); }\n  getDisplayedPixelData(): PixelData | null { return this.renderer().getDisplayedPixelData(); }\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    return this.renderer().getDisplayedSourceRect();\n  }\n  downloadImage(): void { this.renderer().downloadImage(); }\n  exportComposite(): void { this.renderer().exportComposite(); }\n\n  setPlotType(plotType: PlotType): void {\n    this.currentPlotType = plotType;\n    this.plotly.setPlotType(plotType);\n  }\n  setSurfaceDragMode(mode: string): void { this.renderer().setSurfaceDragMode(mode); }\n  resetSurfaceCamera(): void { this.renderer().resetSurfaceCamera(); }\n  setResolutionScale(scale: number): void { this.renderer().setResolutionScale?.(scale); }\n  getResolutionScale(): number { return this.renderer().getResolutionScale?.() ?? 1; }\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 { this.plotly.setStackLoading(b); }\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 IVisualizer.\n  cancelLoading(): void {\n    for (const backend of [this.plotly, this.osd, this.napari] as IVisualizer[]) {\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: IVisualizer): 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  getAutoscaleEvent(): Observable<any> { return this.plotly.getAutoscaleEvent(); }\n  getIntensityProfile$(): Observable<IntensityProfile[]> { return this.plotly.getIntensityProfile$(); }\n  // The intensity inset is a Plotly LINE chart — render it through Plotly, which\n  // owns the profile stream regardless of which backend draws the main image.\n  renderIntensityInset(divId: string, profiles: IntensityProfile[]): void {\n    this.plotly.renderIntensityInset(divId, profiles); }\n\n  // ── regions → active renderer ────────────────────────────────────────\n  // Region *state* lives in the shared RegionStore; both backends implement\n  // IRegionStore by delegating to it. We route through the active renderer\n  // (not hardcoded Plotly) so the backend on screen also *renders* the change:\n  // Plotly relayouts its shapes, OpenSeadragon's overlay redraws from the store\n  // update event. Either way the same store is the single source of truth.\n  setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean,\n             fillColor?: string, append?: boolean): void {\n    this.renderer().setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);\n  }\n  getRegions(): Region[] { return this.renderer().getRegions(); }\n  getRegionPolygons(): any[] { return this.renderer().getRegionPolygons(); }\n  getRegionUpdateEvent(): Observable<any[]> { return this.renderer().getRegionUpdateEvent(); }\n  setSelectedShapeIndices(indices: number[]): void { this.renderer().setSelectedShapeIndices(indices); }\n  selectRegion(region: Region): void { this.renderer().selectRegion(region); }\n  getSelectedShapeIndices$(): Observable<number[]> { return this.renderer().getSelectedShapeIndices$(); }\n  deleteActiveShape(): void { this.renderer().deleteActiveShape(); }\n  getShowShapeLabel(): boolean { return this.renderer().getShowShapeLabel(); }\n  getShapeColor(): string { return this.renderer().getShapeColor(); }\n  getFillColor(): string { return this.renderer().getFillColor(); }\n  getClassificationColors(): Map<string, string> { return this.renderer().getClassificationColors(); }\n  setClassificationColor(label: string, color: string): void {\n    this.renderer().setClassificationColor(label, color); }\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 { return this.store.getPresetSet(); }\n  getPresetSet$(): Observable<PresetSet> { return this.store.getPresetSet$(); }\n  setPresetSet(set: PresetSet): void { this.store.setPresetSet(set); }\n  upsertClass(preset: ClassPreset): void { this.store.upsertClass(preset); }\n  removeClass(name: string): void { this.store.removeClass(name); }\n  resetPresets(): void { this.store.resetPresets(); }\n  plotPreviousShapes(): void { this.renderer().plotPreviousShapes(); }\n  setPreviousShapes(shapes: any[]): void { this.renderer().setPreviousShapes(shapes); }\n  getPreviousShapes(): any[] { return this.renderer().getPreviousShapes(); }\n  // Undo state is owned by the shared RegionStore (same instance for both\n  // backends), so routing through the active renderer is safe and stable.\n  undo(): void { this.renderer().undo(); }\n  redo(): void { this.renderer().redo(); }\n  canUndo(): boolean { return this.renderer().canUndo(); }\n  canRedo(): boolean { return this.renderer().canRedo(); }\n  getCanUndo$(): Observable<boolean> { return this.renderer().getCanUndo$(); }\n  getCanRedo$(): Observable<boolean> { return this.renderer().getCanRedo$(); }\n  resetUndoHistory(): void { this.renderer().resetUndoHistory(); }\n  importRegions(geoJsonStr: string): Region[] { return this.renderer().importRegions(geoJsonStr); }\n  exportRegions(regions: Region[]): void { this.renderer().exportRegions(regions); }\n  getGeoJsonString(regions: Region[]): string { return this.renderer().getGeoJsonString(regions); }\n\n  // ── Per-slice z-stack regions (jit-ui#93) — the RegionStore is shared across\n  //    backends, so routing to the active renderer hits the same store. ──────\n  enterStackMode(slices: Map<number, Region[]>, initialZ?: number,\n                 saveLayout?: 'combined' | 'per-slice-file'): void {\n    this.renderer().enterStackMode(slices, initialZ, saveLayout);\n  }\n  exitStackMode(): void { this.renderer().exitStackMode(); }\n  isStackMode(): boolean { return this.renderer().isStackMode(); }\n  getStackSaveLayout(): 'combined' | 'per-slice-file' { return this.renderer().getStackSaveLayout(); }\n  setDisplaySlice(z: number): void { this.renderer().setDisplaySlice(z); }\n  getSliceRegions(): Region[] { return this.renderer().getSliceRegions(); }\n  getStackSaveSlices(): Map<number, Region[]> { return this.renderer().getStackSaveSlices(); }\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.renderer().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.renderer().getStackSaveSlices()) {\n      out.set(z, regs.filter((r) => !isProfileRegion(r)));\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) &&\n      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().subscribe((m) => (meta = m)).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. Routing (not the store) owns this\n  // so writes/selection go through renderer() and the active backend re-renders\n  // (Plotly relayouts its shapes in setRegions; it doesn't on regionUpdate$).\n\n  getAnnotationRegions(): Region[] {\n    return this.renderer().getRegions().filter((r) => !isProfileRegion(r));\n  }\n  setAnnotationRegions(regions: Region[], showRegionLabel?: boolean,\n                       isRegionSaveOn?: boolean, fillColor?: string): void {\n    // Re-append the store's profile lines so an editor save/delete can't drop\n    // them, then route through setRegions so the active backend re-renders.\n    const profiles = this.renderer().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.renderer().getRegions();\n        return idxs\n          .map((i) => regs[i])\n          .filter((r): r is Region => !!r && !isProfileRegion(r));\n      }),\n    );\n  }\n  setSelectedRegions(regions: Region[]): void {\n    const regs = this.renderer().getRegions();\n    const indices = (regions || [])\n      .map((r) => regs.findIndex((x) => x.id === r.id))\n      .filter((i) => i >= 0);\n    this.setSelectedShapeIndices(indices);\n  }\n\n  // ── tools → active renderer (run on either backend) ─────────────────\n  // The wand, vertex eraser and zoom-to-box are implemented on both backends\n  // via ICoordinateTransform (+ a viewport pixel readback for the wand), so they\n  // follow the active renderer.\n  setWandMode(active: boolean, options?: any): void { this.renderer().setWandMode(active, options); }\n  setWandOptions(options: any): void { this.renderer().setWandOptions(options); }\n  clearActiveWandRegion(): void { this.renderer().clearActiveWandRegion(); }\n  setBrushMode(active: boolean, options?: any): void { this.renderer().setBrushMode(active, options); }\n  setBrushOptions(options: any): void { this.renderer().setBrushOptions(options); }\n  setVertexEraserMode(active: boolean): void { this.renderer().setVertexEraserMode(active); }\n  setVertexEraserRadius(radius: number): void { this.renderer().setVertexEraserRadius(radius); }\n  setZoomToBoxMode(active: boolean): void { this.renderer().setZoomToBoxMode(active); }\n  segmentRectangles(): Promise<number> { return this.renderer().segmentRectangles(); }\n  segmentRectanglesCellpose(): Promise<number> { return this.renderer().segmentRectanglesCellpose(); }\n  setSamModel(id: string): void { this.renderer().setSamModel(id); }\n  setSamPointMode(active: boolean): void { this.renderer().setSamPointMode(active); }\n  commitSamPoints(): void { this.renderer().commitSamPoints(); }\n  clearSamPoints(): void { this.renderer().clearSamPoints(); }\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<any> { return this.store.getColormap(); }\n  setColormap(colormap: any): void { this.plotly.setColormap(colormap); }\n  getColormapOptions(): any { return this.store.getColormapOptions(); }\n  getReverseScale(): Observable<boolean> { return this.store.getReverseScale(); }\n  setReverseScale(reverscale: any): void { this.plotly.setReverseScale(reverscale); }\n  setImageMeta(imageMeta: IImageMetadata[]): void { this.store.setImageMeta(imageMeta); }\n  getImageMeta(): Observable<IImageMetadata[]> { return this.store.getImageMeta(); }\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 { this.renderer().exportData(); }\n  getChannels$(): Observable<IChannelState[]> { return this.store.getChannelStates(); }\n  setSelectedChannel(index: number): void { this.store.setSelectedChannel(index); }\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);\n      if (max > min) this.store.setChannelState(i, { min, max });\n    }\n  }\n  getGrayscale$(): Observable<boolean> { return this.store.getGrayscale(); }\n  setGrayscale(on: boolean): void { this.store.setGrayscale(on); }\n  getInvert$(): Observable<boolean> { return this.store.getInvert(); }\n  setInvert(on: boolean): void { this.store.setInvert(on); }\n\n  /**\n   * The active backend's region overlay. Falls back to Plotly's when the active backend\n   * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a\n   * usable overlay.\n   */\n  getRegionOverlay(): IRegionOverlay {\n    const r = this.renderer();\n    if (r === this.osd) {\n      return this.osd.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    if (r === this.napari) {\n      return this.napari.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    return this.plotly.getRegionOverlay();\n  }\n\n  /**\n   * Isosurface controls when available — always Plotly's, since the isosurface\n   * plot type renders on Plotly (OSD only handles the image type).\n   */\n  getIsosurfaceControls(): IIsosurfaceControls | null { return this.renderer().getIsosurfaceControls(); }\n\n  /** 3D scene controls — always Plotly's, since the 3D plot types render on\n   *  Plotly (OSD only handles the image type). */\n  getSurface3dControls(): ISurface3dControls | null { return this.renderer().getSurface3dControls(); }\n\n  /** Intensity (line-ROI) controls — always Plotly's, since the line profiles\n   *  render their inset on Plotly regardless of which backend draws the image. */\n  getIntensityControls(): IIntensityControls | null { return this.plotly.getIntensityControls(); }\n\n  /**\n   * Spatial-omics controls, or null when no `SPATIAL_DATA_PORT` is bound.\n   *\n   * Implemented HERE rather than on a backend because the state is\n   * backend-neutral: the view state lives in the shared `VisualizerStore` (like\n   * the colormap), so the controls keep working across a plot-type switch and a\n   * host can drive them before any backend has mounted.\n   */\n  getSpatialControls(): ISpatialControls | null {\n    const port = this.spatialData;\n    if (!port) return null;\n    // Mirror the dataset (and drop a stale selection when it changes — the masks\n    // are index-based, so they are meaningless against different observations).\n    this.spatialDatasetSub ??= port.getDataset$().subscribe((dataset) => {\n      const changed = dataset?.id !== this.currentSpatialDataset?.id;\n      this.currentSpatialDataset = dataset;\n      if (!changed) return;\n      this.selectionStore.set(emptySelection(dataset?.observations.count ?? 0));\n      // A colour source the new dataset cannot satisfy would leave the map flat\n      // while the panel and the charts kept naming the old column — so drop it,\n      // and only it: point size, opacity and the rest are the user's preferences,\n      // not the previous dataset's state.\n      const by = this.store.currentSpatialView().colorBy;\n      if (by && !this.canColorBy(dataset, by)) this.store.setSpatialView({ colorBy: null });\n    });\n    this.spatialControls ??= {\n      getDataset$: () => port.getDataset$(),\n      getViewState$: () => this.store.getSpatialView$(),\n      viewState: () => this.store.currentSpatialView(),\n      setViewState: (partial) => this.store.setSpatialView(partial),\n      // The hint SEEDS the toggle when the source changes, and nothing consults it\n      // afterwards. It used to be ORed in at render time, which meant an unchecked\n      // box could not turn log scaling off for a hinted column — and the linked\n      // chart, which reads `logScale` alone, disagreed with the map about what it\n      // was showing. One authority, set once per source.\n      colorByColumn: (name: string) => {\n        const meta = this.currentSpatialDataset?.columns.find((c) => c.name === name);\n        const hint = meta?.kind === 'continuous' ? !!meta.logScaleHint : false;\n        this.store.setSpatialView({ colorBy: { kind: 'column', name }, logScale: hint });\n      },\n      colorByFeature: (name: string) =>\n        this.store.setSpatialView({\n          colorBy: { kind: 'feature', name },\n          logScale: !!this.currentSpatialDataset?.features?.logScaleHint,\n        }),\n      clearColorBy: () => this.store.setSpatialView({ colorBy: null }),\n      searchFeatures: async (query: string, limit = 50) => {\n        // Prefer the port's search (a 31k-gene dataset does not ship its names);\n        // otherwise filter whatever the manifest inlined.\n        if (port.searchFeatures) return port.searchFeatures(query, limit);\n        const dataset = await firstValueFrom(port.getDataset$());\n        const names = dataset?.features?.names ?? [];\n        const q = query.toLowerCase();\n        return names.filter((n) => n.toLowerCase().includes(q)).slice(0, limit);\n      },\n      ...(port.importGroups ? {\n        importGroups: (label: string, table: string) => port.importGroups!(label, table),\n      } : {}),\n      ...(port.getTranscriptCounts ? {\n        transcriptCounts: (genes: string[]) => port.getTranscriptCounts!(genes),\n      } : {}),\n      ...(port.getMarkerGenes ? {\n        markerGenes: (column: string, perGroup?: number) => port.getMarkerGenes!(column, perGroup),\n      } : {}),\n      getTranscriptEstimate$: () => this.napari.transcriptEstimate$.asObservable(),\n      getGeneCountsInView$: () => this.napari.geneCountsInView$.asObservable(),\n      getDensityStats$: () => this.napari.densityStats$.asObservable(),\n      categoryColors: async (name: string) => {\n        const column = await port.getColumn(name);\n        if (!isCategoricalColumn(column)) {\n          throw new Error(`[spatial] column \"${name}\" is continuous — it has no categories`);\n        }\n        // Resolved by the SAME function the renderer uses, so a legend swatch\n        // can never disagree with the colour on screen.\n        return resolveCategoryColors(column.meta);\n      },\n\n      continuousValues: async (source) => {\n        if (source.kind === 'feature') return port.getFeatureVector(source.name);\n        const column = await port.getColumn(source.name);\n        if (isCategoricalColumn(column)) {\n          throw new Error(\n            `[spatial] column \"${source.name}\" is categorical — it has no values to chart`,\n          );\n        }\n        return column.values;\n      },\n\n      categoricalView: async (name: string) => {\n        const column = await port.getColumn(name);\n        if (!isCategoricalColumn(column)) {\n          throw new Error(`[spatial] column \"${name}\" is continuous — it has no categories`);\n        }\n        return {\n          name,\n          categories: column.meta.categories,\n          colors: resolveCategoryColors(column.meta),\n          codes: column.codes,\n        };\n      },\n\n      // Spread rather than always defined: `getEmbedding` is optional on both the port\n      // and this facade, and a panel checks for its presence to decide whether the view\n      // is offered at all. Defining it as a function that rejects would make an\n      // embedding-less source look like a broken one.\n      ...(port.getEmbedding\n        ? { getEmbedding: (name: string) => port.getEmbedding!(name) }\n        : {}),\n\n      categoricalColumns: () => (this.currentSpatialDataset?.columns ?? [])\n        .filter((c) => c.kind === 'categorical')\n        .map((c) => c.name),\n\n      // Memoized on the observations object, so the renderer's own lookup and\n      // this one are the same single scan of up to 3.7M z values.\n      sampledSections: () => {\n        const obs = this.currentSpatialDataset?.observations;\n        return obs ? sectionsOf(obs) : null;\n      },\n\n      getSelection$: () => this.selectionStore.getSelection$(),\n\n      selectFromRegions: () => {\n        const dataset = this.currentSpatialDataset;\n        if (!dataset) return 0;\n        const regions = this.regionStore.getRegions();\n        // The union of every drawn region — so every ROI tool the library\n        // already has doubles as a spatial selection tool.\n        //\n        // In the 3D cloud there is no data-space affine to push a drawn shape\n        // through, so the observations are projected to canvas pixels by the\n        // renderer (which owns the camera) and tested in screen space instead.\n        // Falls back to the 2D path whenever the cloud is not mounted.\n        const projected = isSpatialOmics3d(this.currentPlotType)\n          ? this.napari.getSpatialScreenProjection(dataset.observations)\n          : null;\n        // In the 2D view of a volume-backed dataset the shape was drawn over ONE\n        // section, in the volume's pixel grid: it selects the cells of that\n        // section, not the whole depth of brain standing behind them.\n        const volume = !dataset.imageRef ? dataset.volume : undefined;\n        const selection = projected\n          ? selectInRegionsProjected(projected, dataset.observations.count, regions)\n          : selectInRegions(\n              dataset.observations,\n              volume ? volumeImageRef(volume, dataset.micronsPerUnit) : dataset.imageRef,\n              regions,\n              volume\n                ? observationsInSlice(dataset.observations, volume, this.currentZIndex)\n                : undefined,\n            );\n        this.selectionStore.set(selection);\n        return selection.count;\n      },\n\n      selectCategory: async (column: string, categoryIndex: number) => {\n        const loaded = await port.getColumn(column);\n        if (!isCategoricalColumn(loaded)) {\n          throw new Error(`[spatial] column \"${column}\" is continuous — it has no categories`);\n        }\n        const selection = selectByCategory(loaded.codes, categoryIndex);\n        this.selectionStore.set(selection);\n        return selection.count;\n      },\n\n      selectIndices: (indices: Iterable<number>) => {\n        const count = this.currentSpatialDataset?.observations.count ?? 0;\n        if (count === 0) return 0;\n        const selection = selectByIndices(indices, count);\n        this.selectionStore.set(selection);\n        return selection.count;\n      },\n\n      clearSelection: () => this.selectionStore.clear(),\n    };\n    return this.spatialControls;\n  }\n\n  /**\n   * Whether `dataset` can answer this colour source.\n   *\n   * A column is checkable against the declared list. A gene is checkable only when\n   * the dataset inlines its feature names — a dataset too wide to inline them\n   * (typeahead-only) keeps the source, and a name that turns out not to exist\n   * surfaces as the chart's \"could not be charted\" rather than as a silent reset.\n   */\n  private canColorBy(dataset: SpatialDataset | null, by: SpatialColorBy): boolean {\n    if (!dataset) return false;\n    if (by.kind === 'column') return dataset.columns.some((c) => c.name === by.name);\n    const names = dataset.features?.names;\n    return !!dataset.features && (!names || names.includes(by.name));\n  }\n\n  /** Memoised so consumers can hold the object across calls. */\n  private spatialControls: ISpatialControls | null = null;\n  /** Latest dataset, mirrored so `selectFromRegions()` can answer synchronously\n   *  — it runs from a button click and must not await a round-trip. */\n  private currentSpatialDataset: SpatialDataset | 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  private spatialDatasetSub: Subscription | null = null;\n\n  /** Load pixel frames for intensity sampling when OpenSeadragon owns the image\n   *  (it doesn't feed Plotly's frame cache). No-op needed when Plotly renders. */\n  ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void> {\n    return this.plotly.ensureIntensitySampling(imageInfo, zIndex);\n  }\n\n  /** Visible-region changes from the OpenSeadragon viewer (image-pixel coords),\n   *  so the intensity inset can re-sample at the current zoom level. Plotly's own\n   *  high-def zoom updates the sampling cache inline, so only OSD feeds this. */\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return this.osd.getViewportChange$();\n  }\n\n  /** Re-sample the intensity profiles from a fresh crop of the given image-pixel\n   *  ROI at display resolution (sampling always lives in Plotly). */\n  refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number, zIndex: number): void {\n    this.plotly.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);\n  }\n\n  unsubscribe(): void {\n    this.plotly.unsubscribe();\n    this.osd.unsubscribe();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routing-visualizer.service.js","sourceRoot":"","sources":["../../../src/lib/routing-visualizer.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAa,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,KAAK,EAAc,aAAa,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAC/D,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAMrC,OAAO,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AACxE,OAAO,EAAE,8BAA8B,EAAE,MAAM,wDAAwD,CAAC;AACxG,OAAO,EACL,QAAQ,EAER,UAAU,EACV,eAAe,EACf,cAAc,EACd,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAe/B,OAAO,EAAE,iBAAiB,EAAmB,MAAM,qCAAqC,CAAC;AAEzF,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAK1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uDAAuD,CAAC;AAChG,OAAO,EAAE,UAAU,EAAa,MAAM,wBAAwB,CAAC;AAE/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;;;;;;;;;AAEhF;;gCAEgC;AAChC,SAAS,eAAe,CAAC,CAAuC;IAC9D,OAAO,CAAC,EAAE,IAAI,KAAK,SAAS,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,OAAO,wBAAwB;IAiBnC,YACU,MAAqB,EACrB,GAAmC,EACnC,MAA+B,EAC/B,KAAsB,EACF,MAAiB;IAC7C,oEAAoE;IACpE,gDAAgD;IACxC,WAAwB,EACxB,cAAqC,EACrC,SAAkC,EAGlC,cAAsC,IAAI;QAZ1C,WAAM,GAAN,MAAM,CAAe;QACrB,QAAG,GAAH,GAAG,CAAgC;QACnC,WAAM,GAAN,MAAM,CAAyB;QAC/B,UAAK,GAAL,KAAK,CAAiB;QACF,WAAM,GAAN,MAAM,CAAW;QAGrC,gBAAW,GAAX,WAAW,CAAa;QACxB,mBAAc,GAAd,cAAc,CAAuB;QACrC,cAAS,GAAT,SAAS,CAAyB;QAGlC,gBAAW,GAAX,WAAW,CAA+B;QA7B5C,oBAAe,GAAa,QAAQ,CAAC,KAAK,CAAC;QAC3C,iBAAY,GAA0B,IAAI,CAAC;QACnD;;;;iFAIyE;QACjE,gBAAW,GAAG,KAAK,CAAC;QAC5B;sFAC8E;QACtE,mBAAc,GAAG,KAAK,CAAC;QAG/B,4FAA4F;QACpF,YAAO,GAAG,EAAE,CAAC;QAmMJ,gBAAW,GAAoB;YAC9C,mBAAmB,EAAE,CAAC,OAAO,EAAE,EAAE;gBAC/B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE;oBAAE,CAAC,CAAC,iBAAiB,EAAE,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;YACvF,CAAC;YACD,wBAAwB,EAAE,CAAC,OAAO,EAAE,EAAE;gBACpC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE;oBAAE,CAAC,CAAC,iBAAiB,EAAE,EAAE,wBAAwB,CAAC,OAAO,CAAC,CAAC;YAC5F,CAAC;SACF,CAAC;QAqgBF,2DAA2D;QACnD,kBAAa,GAAiC,IAAI,CAAC;QAC3D;sFAC8E;QACtE,kBAAa,GAAG,CAAC,CAAC;QAmBT,sBAAiB,GAAuB;YACvD,gFAAgF;YAChF,oFAAoF;YACpF,uBAAuB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE;gBAC7C,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC3B,OAAO,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YACnE,CAAC;YACD,4EAA4E;YAC5E,8BAA8B,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;gBAC9D,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC3B,IAAI,CAAC,SAAS,CAAC,8BAA8B,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;YAC7E,CAAC;YACD,kBAAkB,EAAE,GAAG,EAAE,CACvB,KAAK,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,oBAAoB,EAAE,EAAE,kBAAkB,EAAE,IAAI,KAAK,CAAC,CAAC;SAChG,CAAC;IApuBC,CAAC;IAEI,WAAW,CAAC,CAAW;QAC7B,OAAO,CAAC,KAAK,QAAQ,CAAC,KAAK,CAAC;IAC9B,CAAC;IAED;;;;;;gGAM4F;IACpF,iBAAiB,CAAC,CAAW;QACnC,OAAO,CAAC,KAAK,QAAQ,CAAC,YAAY,IAAI,eAAe,CAAC,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC;IAChF,CAAC;IAED;gFAC4E;IACpE,cAAc,CAAC,CAAW;QAChC,OAAO,UAAU,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;OAOG;IACK,YAAY;QAClB,MAAM,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC;QAC/B,0FAA0F;QAC1F,IAAI,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,EAAE,CAAC;YACxF,IAAI,CAAC,IAAI,CAAC,cAAc;gBAAE,OAAO,IAAI,CAAC,MAAM,CAAC;YAC7C,IAAI,CAAC,IAAI,CAAC,WAAW;gBAAE,OAAO,IAAI,CAAC,GAAG,CAAC;YACvC,OAAO,IAAI,CAAC,MAAM,CAAC;QACrB,CAAC;QACD,yDAAyD;QACzD,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;YACxB,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QACnD,CAAC;QACD,uEAAuE;QACvE,IAAI,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;QACzD,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,8EAA8E;IACtE,QAAQ;QACd,OAAO,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,MAAM,CAAC;IAC1C,CAAC;IAED,yEAAyE;IACzE,uEAAuE;IACvE,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC;IAClC,CAAC;IAED,wEAAwE;IACxE,KAAK,CAAC,IAAI,CAAC,SAAqB,EAAE,MAAc,EAAE,MAAoB;QACpE,uEAAuE;QACvE,sEAAsE;QACtE,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC;QAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACpC,IAAI,OAAO,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;YAC5B,IAAI,CAAC;gBACH,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;YAC3D,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,kFAAkF;gBAClF,IAAI,MAAM,EAAE,OAAO;oBAAE,MAAM,GAAG,CAAC;gBAC/B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;gBAC3B,yEAAyE;gBACzE,+DAA+D;gBAC/D,kCAAkC;gBAClC,IAAI,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC;oBAC9C,OAAO,CAAC,IAAI,CAAC,8DAA8D,EAAE,GAAG,CAAC,CAAC;oBAClF,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;gBACrD,CAAC;gBACD,OAAO,CAAC,IAAI,CAAC,qEAAqE,EAAE,GAAG,CAAC,CAAC;gBACzF,OAAO,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;YAC9D,CAAC;QACH,CAAC;QACD,IAAI,OAAO,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;YACzB,OAAO,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrD,CAAC;IAED,4FAA4F;IACpF,KAAK,CAAC,oBAAoB,CAChC,SAAqB,EACrB,MAAc,EACd,MAAoB;QAEpB,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QACxD,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,MAAM,EAAE,OAAO;gBAAE,MAAM,GAAG,CAAC;YAC/B,OAAO,CAAC,IAAI,CAAC,iFAAiF,EAAE,GAAG,CAAC,CAAC;YACrG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;YACxB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IACD,IAAI,CACF,OAAe,EACf,WAAoB,EACpB,SAAqB,EACrB,YAAoB,EACpB,QAAkB,EAClB,OAAiB;QAEjB,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;QAChC,IAAI,CAAC,eAAe,GAAG,SAAS,EAAE,QAAQ,CAAC;QAC3C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,0EAA0E;QAC1E,wEAAwE;QACxE,4EAA4E;QAC5E,8DAA8D;QAC9D,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QACtC,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACjC,2EAA2E;QAC3E,4EAA4E;QAC5E,iBAAiB;QACjB,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,EAAE,CAAC;YACpD,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,MAAM;gBAAE,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;;gBAC1D,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QACjC,CAAC;QACD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IACrF,CAAC;IACD,aAAa;QACX,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IACD,KAAK;QACH,6EAA6E;QAC7E,0DAA0D;QAC1D,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,IAAI,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC;IAC1B,CAAC;IACD,QAAQ,CAAC,aAAwB;QAC/B,IAAI,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;IAC1C,CAAC;IACD,SAAS;QACP,IAAI,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,CAAC;IAC9B,CAAC;IACD,SAAS;QACP,IAAI,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,CAAC;IAC9B,CAAC;IACD,yCAAyC;IACzC,SAAS;QACP,IAAI,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC;IACD,MAAM;QACJ,IAAI,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC;IAC3B,CAAC;IACD,OAAO;QACL,IAAI,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC;IAC5B,CAAC;IACD,WAAW,CAAC,IAAoB;QAC9B,IAAI,CAAC,QAAQ,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IACD,uCAAuC;IAC/B,QAAQ;QACd,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;OAKG;IACH,iBAAiB;QACf,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IASD,mEAAmE;IACnE,mBAAmB,CAAC,OAAgB;QAClC,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;IACD,wEAAwE;IACxE,wBAAwB,CAAC,OAAgB;QACvC,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC;IACrD,CAAC;IACD,YAAY,CAAC,SAAkB;QAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC1C,CAAC;IACD,SAAS,CAAC,MAAc;QACtB,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC;QAC5B,IAAI,CAAC,QAAQ,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IACD,gBAAgB;QACd,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,gBAAgB,EAAE,CAAC;IAC5C,CAAC;IACD,eAAe;QACb,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,eAAe,EAAE,CAAC;IAC3C,CAAC;IACD,qBAAqB;QACnB,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,qBAAqB,EAAE,CAAC;IACjD,CAAC;IACD,sBAAsB;QACpB,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,sBAAsB,EAAE,CAAC;IAClD,CAAC;IACD,aAAa;QACX,IAAI,CAAC,QAAQ,EAAE,CAAC,aAAa,EAAE,CAAC;IAClC,CAAC;IACD,eAAe;QACb,IAAI,CAAC,QAAQ,EAAE,CAAC,eAAe,EAAE,CAAC;IACpC,CAAC;IAED,WAAW,CAAC,QAAkB;QAC5B,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;QAChC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;IACpC,CAAC;IACD,gDAAgD;IAChD,kBAAkB,CAAC,IAAY;QAC7B,IAAI,CAAC,oBAAoB,EAAE,EAAE,kBAAkB,CAAC,IAAI,CAAC,CAAC;IACxD,CAAC;IACD,gDAAgD;IAChD,kBAAkB;QAChB,IAAI,CAAC,oBAAoB,EAAE,EAAE,kBAAkB,EAAE,CAAC;IACpD,CAAC;IACD,8EAA8E;IAC9E,mBAAmB;QACjB,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,mBAAmB,EAAE,CAAC;IAC/C,CAAC;IACD,sDAAsD;IACtD,kBAAkB,CAAC,KAAa;QAC9B,IAAI,CAAC,mBAAmB,EAAE,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IACD,sDAAsD;IACtD,kBAAkB;QAChB,OAAO,IAAI,CAAC,mBAAmB,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IAChD,CAAC;IACD;+EAC2E;IAC3E,mBAAmB;QACjB,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,mBAAmB,EAAE,EAAE,IAAI,IAAI,CAAC;IACzD,CAAC;IACD,sBAAsB;QACpB,mFAAmF;QACnF,2FAA2F;QAC3F,OAAO,IAAI,CAAC,MAAM,CAAC,sBAAsB,EAAE,CAAC;IAC9C,CAAC;IAED,6EAA6E;IAC7E,eAAe,CAAC,CAAU;QACxB,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IACjC,CAAC;IACD,iGAAiG;IACjG,kGAAkG;IAClG,iGAAiG;IACjG,aAAa;QACX,KAAK,MAAM,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAqB,EAAE,CAAC;YAC/E,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;QAC5B,CAAC;IACH,CAAC;IACD,gGAAgG;IAChG,yFAAyF;IACzF,6FAA6F;IAC7F,cAAc;QACZ,OAAO,aAAa,CAAC;YACnB,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE;YAC5B,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE;YACzB,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE;SAC7B,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC;IACD,uBAAuB;QACrB,iGAAiG;QACjG,kGAAkG;QAClG,kGAAkG;QAClG,oFAAoF;QACpF,MAAM,KAAK,GAAG,CAAC,CAAiB,EAAiC,EAAE,CACjE,aAAa,CAAC,CAAC,CAAC,CAAC,uBAAuB,EAAE,EAAE,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC;QACnE,OAAO,aAAa,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAClF,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACZ,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;YACtE,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjD,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IACD,2FAA2F;IAC3F,0FAA0F;IAC1F,mEAAmE;IACnE,iBAAiB;QACf,OAAO,KAAK,CACV,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,EAC/B,IAAI,CAAC,GAAG,CAAC,iBAAiB,EAAE,EAC5B,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAChC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;IAC/B,CAAC;IACD,qFAAqF;IACrF,oBAAoB;QAClB,OAAO,IAAI,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC;IAC/C,CAAC;IACD,kFAAkF;IAClF,gCAAgC;IAChC,oBAAoB,CAAC,KAAa,EAAE,QAA4B;QAC9D,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACpD,CAAC;IAED,wEAAwE;IACxE,6EAA6E;IAC7E,2EAA2E;IAC3E,+EAA+E;IAC/E,6EAA6E;IAC7E,gCAAgC;IAChC,UAAU,CACR,OAAiB,EACjB,eAAyB,EACzB,cAAwB,EACxB,SAAkB,EAClB,MAAgB;QAEhB,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IAC3F,CAAC;IACD,UAAU;QACR,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;IACvC,CAAC;IACD,iBAAiB;QACf,OAAO,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;IAC9C,CAAC;IACD,oBAAoB;QAClB,OAAO,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;IACjD,CAAC;IACD,uBAAuB,CAAC,OAAiB;QACvC,IAAI,CAAC,WAAW,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACpD,CAAC;IACD,YAAY,CAAC,MAAc;QACzB,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IACD,wBAAwB;QACtB,OAAO,IAAI,CAAC,WAAW,CAAC,wBAAwB,EAAE,CAAC;IACrD,CAAC;IACD,iBAAiB;QACf,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;IACvC,CAAC;IACD,iBAAiB;QACf,OAAO,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;IAC9C,CAAC;IACD,aAAa;QACX,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC;IAC1C,CAAC;IACD,YAAY;QACV,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IACD,uBAAuB;QACrB,OAAO,IAAI,CAAC,KAAK,CAAC,uBAAuB,EAAE,CAAC;IAC9C,CAAC;IACD,sBAAsB,CAAC,KAAa,EAAE,KAAa;QACjD,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;IACD,+EAA+E;IAC/E,sFAAsF;IACtF,YAAY;QACV,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;IACnC,CAAC;IACD,aAAa;QACX,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;IACpC,CAAC;IACD,YAAY,CAAC,GAAc;QACzB,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;IAC/B,CAAC;IACD,WAAW,CAAC,MAAmB;QAC7B,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IACD,WAAW,CAAC,IAAY;QACtB,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IACD,YAAY;QACV,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;IAC5B,CAAC;IACD,IAAI;QACF,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;IACD,IAAI;QACF,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;IACD,OAAO;QACL,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;IACpC,CAAC;IACD,OAAO;QACL,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;IACpC,CAAC;IACD,WAAW;QACT,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;IACxC,CAAC;IACD,WAAW;QACT,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;IACxC,CAAC;IACD,gBAAgB;QACd,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,CAAC;IACtC,CAAC;IACD,aAAa,CAAC,UAAkB;QAC9B,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACpD,CAAC;IACD,yEAAyE;IACzE,aAAa,CAAC,OAAiB;QAC7B,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IAChE,CAAC;IACD,gBAAgB,CAAC,OAAiB;QAChC,OAAO,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACpD,CAAC;IAED,4EAA4E;IAC5E,cAAc,CACZ,MAA6B,EAC7B,QAAiB,EACjB,UAA0C;QAE1C,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IAChE,CAAC;IACD,aAAa;QACX,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC;IACnC,CAAC;IACD,WAAW;QACT,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;IACxC,CAAC;IACD,kBAAkB;QAChB,OAAO,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC;IAC/C,CAAC;IACD,eAAe,CAAC,CAAS;QACvB,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IACtC,CAAC;IACD,eAAe;QACb,OAAO,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC;IAC5C,CAAC;IACD,kBAAkB;QAChB,OAAO,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC;IAC/C,CAAC;IACD;;8BAE0B;IAC1B,yBAAyB;QACvB,OAAO,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/E,CAAC;IACD;;qFAEiF;IACjF,4BAA4B;QAC1B,MAAM,GAAG,GAAG,IAAI,GAAG,EAAoB,CAAC;QACxC,KAAK,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,EAAE,CAAC;YAC9D,GAAG,CAAC,GAAG,CACL,CAAC,EACD,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CACxC,CAAC;QACJ,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;qEAIiE;IACjE,gBAAgB;QACd,MAAM,KAAK,GAAG,CAAC,CAAuD,EAAE,EAAE,CACxE,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC;YACzF,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE;YAC9D,CAAC,CAAC,IAAI,CAAC;QAEX,MAAM,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;QACpD,IAAI,YAAY;YAAE,OAAO,YAAY,CAAC;QAEtC,IAAI,IAAI,GAAqB,EAAE,CAAC;QAChC,IAAI,CAAC,YAAY,EAAE;aAChB,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;aAC5B,WAAW,EAAE,CAAC;QACjB,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QACrB,OAAO,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC1D,CAAC;IAED,yEAAyE;IACzE,6EAA6E;IAC7E,4EAA4E;IAC5E,+EAA+E;IAC/E,wDAAwD;IAExD,oBAAoB;QAClB,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1E,CAAC;IACD,oBAAoB,CAClB,OAAiB,EACjB,eAAyB,EACzB,cAAwB,EACxB,SAAkB;QAElB,gFAAgF;QAChF,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;QACjF,MAAM,WAAW,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;QACvE,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,WAAW,EAAE,GAAG,QAAQ,CAAC,EAAE,eAAe,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IACpG,CAAC;IACD,mBAAmB;QACjB,6EAA6E;QAC7E,OAAO,IAAI,CAAC,wBAAwB,EAAE,CAAC,IAAI,CACzC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YACX,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;YAC3C,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;QACzF,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IACD,kBAAkB,CAAC,OAAiB;QAClC,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;QAC3C,MAAM,OAAO,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACvG,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IAED,uEAAuE;IACvE,2EAA2E;IAC3E,+EAA+E;IAC/E,8BAA8B;IAC9B,aAAa,CAAC,EAAiB,EAAE,OAA2B;QAC1D,IAAI,CAAC,QAAQ,EAAE,CAAC,aAAa,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAC7C,CAAC;IACD,6CAA6C;IAC7C,WAAW,CAAC,MAAe,EAAE,OAAsB;QACjD,IAAI,CAAC,QAAQ,EAAE,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC;IACD,cAAc,CAAC,OAAqB;QAClC,IAAI,CAAC,QAAQ,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAC1C,CAAC;IACD,qBAAqB;QACnB,IAAI,CAAC,QAAQ,EAAE,CAAC,qBAAqB,EAAE,CAAC;IAC1C,CAAC;IACD,6CAA6C;IAC7C,YAAY,CAAC,MAAe,EAAE,OAAuB;QACnD,IAAI,CAAC,QAAQ,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IACD,eAAe,CAAC,OAAsB;QACpC,IAAI,CAAC,QAAQ,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC;IACD,6CAA6C;IAC7C,mBAAmB,CAAC,MAAe;QACjC,IAAI,CAAC,QAAQ,EAAE,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IACD,qBAAqB,CAAC,MAAc;QAClC,IAAI,CAAC,QAAQ,EAAE,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;IAChD,CAAC;IACD,6CAA6C;IAC7C,gBAAgB,CAAC,MAAe;QAC9B,IAAI,CAAC,QAAQ,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IACD,iBAAiB;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,iBAAiB,EAAE,CAAC;IAC7C,CAAC;IACD,yBAAyB;QACvB,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,yBAAyB,EAAE,CAAC;IACrD,CAAC;IACD,WAAW,CAAC,EAAU;QACpB,IAAI,CAAC,QAAQ,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IAClC,CAAC;IACD,6CAA6C;IAC7C,eAAe,CAAC,MAAe;QAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IAC1C,CAAC;IACD,eAAe;QACb,IAAI,CAAC,QAAQ,EAAE,CAAC,eAAe,EAAE,CAAC;IACpC,CAAC;IACD,cAAc;QACZ,IAAI,CAAC,QAAQ,EAAE,CAAC,cAAc,EAAE,CAAC;IACnC,CAAC;IAED,wEAAwE;IACxE,uEAAuE;IACvE,yEAAyE;IACzE,qEAAqE;IACrE,4EAA4E;IAC5E,iCAAiC;IACjC,WAAW;QACT,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;IAClC,CAAC;IACD,WAAW,CAAC,QAAsB;QAChC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;IACpC,CAAC;IACD,kBAAkB;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAC;IACzC,CAAC;IACD,eAAe;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC;IACtC,CAAC;IACD,eAAe,CAAC,OAAgB;QAC9B,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IACD,YAAY,CAAC,SAA2B,EAAE,QAAiB;QACzD,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC/C,CAAC;IACD,YAAY;QACV,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;IACnC,CAAC;IAED,yEAAyE;IACzE,2EAA2E;IAC3E,4EAA4E;IAC5E,2EAA2E;IAC3E,YAAY,CAAC,YAAoB,EAAE,IAAY;QAC7C,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;IAC1D,CAAC;IACD,aAAa,CAAC,YAAoB,EAAE,IAAY;QAC9C,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;IACD,kFAAkF;IAClF,UAAU;QACR,IAAI,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE,CAAC;IAC/B,CAAC;IACD,YAAY;QACV,OAAO,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC;IACvC,CAAC;IACD,kBAAkB,CAAC,KAAa;QAC9B,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IACD,eAAe,CAAC,KAAa,EAAE,OAA+B;QAC5D,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC7C,CAAC;IACD,aAAa,CAAC,OAAiB;QAC7B,yEAAyE;QACzE,KAAK,MAAM,CAAC,IAAI,OAAO;YAAE,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAC3D,CAAC;IACD;mEAC+D;IAC/D,YAAY,CAAC,OAAiB,EAAE,UAAkB;QAChD,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;YACxB,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;YAC/C,IAAI,CAAC,CAAC;gBAAE,SAAS;YACjB,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,uBAAuB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;YACpE,IAAI,GAAG,GAAG,GAAG;gBAAE,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;IACD,aAAa;QACX,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;IACnC,CAAC;IACD,YAAY,CAAC,EAAW;QACtB,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;IAC9B,CAAC;IACD,UAAU;QACR,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;IAChC,CAAC;IACD,SAAS,CAAC,EAAW;QACnB,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,gBAAgB;QACd,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC1B,IAAI,CAAC,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACvE,CAAC;QACD,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QAC1E,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;IACxC,CAAC;IAED,iFAAiF;IACjF,qBAAqB;QACnB,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,qBAAqB,EAAE,CAAC;IACjD,CAAC;IAED;uBACmB;IACnB,oBAAoB;QAClB,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,oBAAoB,EAAE,CAAC;IAChD,CAAC;IAED;;oEAEgE;IAChE,oBAAoB;QAClB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACH,kBAAkB;QAChB,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC;QACnC,IAAI,CAAC,aAAa,KAAK,IAAI,qBAAqB,CAAC,IAAI,CAAC,WAAW,EAAE;YACjE,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe;YACpC,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa;SACjC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC;IACrC,CAAC;IAQD;;qFAEiF;IACjF,WAAW;QACT,IAAI,CAAC,aAAa,EAAE,OAAO,EAAE,CAAC;QAC9B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACH,oBAAoB;QAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAgBD,0EAA0E;IAC1E,uBAAuB,CAAC,SAAqB,EAAE,MAAc;QAC3D,OAAO,IAAI,CAAC,iBAAiB,CAAC,uBAAuB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IAC3E,CAAC;IAED,0FAA0F;IAClF,mBAAmB;QACzB,IAAI,IAAI,CAAC,OAAO;YAAE,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACpE,CAAC;IAED,qEAAqE;IACrE,kBAAkB;QAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,CAAC;IACrD,CAAC;IAED,iFAAiF;IACjF,8BAA8B,CAAC,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,MAAc,EAAE,MAAc;QAChG,IAAI,CAAC,iBAAiB,CAAC,8BAA8B,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrF,CAAC;IAED;;;6FAGyF;IACzF,MAAM;QACJ,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACrB,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC;QAClB,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACrB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IAC3B,CAAC;IAED,sCAAsC;IACtC,WAAW;QACT,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;8GAtyBU,wBAAwB,mKAsBzB,UAAU,oHAOV,iBAAiB;kHA7BhB,wBAAwB,cADX,MAAM;;2FACnB,wBAAwB;kBADpC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;0BAuB7B,MAAM;2BAAC,UAAU;;0BAMjB,QAAQ;;0BACR,MAAM;2BAAC,iBAAiB","sourcesContent":["import { Inject, Injectable, OnDestroy, Optional } from '@angular/core';\nimport { EMPTY, Observable, combineLatest, merge } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { Image } from 'image-js';\n\nimport { IImageInfo, IImageMetadata } from './contracts/image.contract';\nimport { Polygon, Region } from './models/region';\nimport { ClassPreset, PresetSet } from './models/class-preset';\nimport { PlotlyService } from './implementations/plotly/plotly.service';\nimport { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';\nimport {\n  PlotType,\n  PlotTypeDescriptor,\n  isNapari3d,\n  isNapariScatter,\n  isSpatialOmics,\n  isSpatialOmics3d,\n} from './contracts/plot-type';\nimport {\n  IViewerBackend,\n  IVisualizer,\n  LoadedImage,\n  PixelData,\n  IntensityProfile,\n  IIsosurfaceControls,\n  IIntensityControls,\n  ISurface3dControls,\n  ISpatialControls,\n  IIntensitySampling,\n  IOsdViewOptions,\n  IVolumeResolution,\n} from './contracts/visualizer.contract';\nimport { SPATIAL_DATA_PORT, SpatialDataPort } from './contracts/ports/spatial-data.port';\nimport { CanvasToolOptions, ColormapNode, IBrushOptions, IWandOptions } from './contracts/display-types';\nimport { SpatialControlsFacade } from './spatial/spatial-controls.facade';\nimport { RegionStore } from './store/region-store.service';\nimport { SpatialSelectionStore } from './store/spatial-selection.service';\nimport { ViewerCapabilities } from './contracts/capabilities.contract';\nimport { IRegionOverlay } from './contracts/region-overlay.contract';\nimport { IRegionEditorApi } from './contracts/region-editor-api.contract';\nimport { IChannelHistogramApi, IChannelState, IHistogram } from './contracts/channel-histogram-api.contract';\nimport { autoWindowFromHistogram } from './contracts/intensity';\nimport { VisualizerStore } from './store/visualizer-store.service';\nimport { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';\nimport { VIZ_CONFIG, VizConfig } from './contracts/viz-config';\nimport { PlotModeViewport } from './contracts/plot-type-contribution.contract';\nimport { IntensityProfileService } from './intensity/intensity-profile.service';\n\n/** Intensity-profile line ROIs are owned by the intensity tool, not the editor.\n *  Package-internal predicate (property-based so it also matches plain objects\n *  after a drag round-trip). */\nfunction isProfileRegion(r: { kind?: string } | null | undefined): boolean {\n  return r?.kind === 'profile';\n}\n\n/**\n * The visualizer chain's front door: implements `IVisualizer`, `IRegionEditorApi`\n * and `IChannelHistogramApi` (bound to the `VISUALIZER` / `REGION_EDITOR_API` /\n * `CHANNEL_HISTOGRAM_API` tokens) over three rendering backends, chosen per plot type:\n *  - **Image** renders through OpenSeadragon (natively tiled, region tools,\n *    client-side colormap), or through napari-js when `VizConfig.useNapariRenderer`\n *    opts in; the napari image types and the 2D spatial-omics mode render through\n *    napari-js. A failed load falls back napari-js → OSD → Plotly for that image only\n *    (see `napariFellBack` / `osdFellBack`, cleared by `reset()`).\n *  - the napari 3D types (volume, isosurface, surface, 3D scatter, the 3D spatial\n *    cloud) render through napari-js, falling back to Plotly.\n *  - every other plot type (heatmap, contour, surface, scatter, line, …) renders\n *    through Plotly.\n *\n * Only rendering and the viewport are routed to the backend on screen. Region state\n * lives in the shared `RegionStore` and display state (colormap, channels, presets,\n * spatial view) in the shared `VisualizerStore`, so every backend sees the same\n * values; the backends subscribe to them to redraw.\n *\n * Package-internal: hosts depend on the tokens, not on this class.\n */\n@Injectable({ providedIn: 'root' })\nexport class RoutingVisualizerService implements IVisualizer, IRegionEditorApi, IChannelHistogramApi, OnDestroy {\n  private currentPlotType: PlotType = PlotType.IMAGE;\n  private lastRendered: IViewerBackend | null = null;\n  /** OSD failed for the *current* render cycle (e.g. a fresh file still caching\n   *  past the deadline) → fall back to Plotly for this image only. Reset by\n   *  reset() at the start of every render cycle, so the next file — or a\n   *  re-select once the file is cached — retries OSD. (Was a permanent flag,\n   *  which left the whole session stuck on Plotly after one slow load.) */\n  private osdFellBack = false;\n  /** napari-js failed for the current render cycle → fall back to OSD (then Plotly).\n   *  Reset by reset() at the start of every cycle, like {@link osdFellBack}. */\n  private napariFellBack = false;\n  /** The file name of the image last plotted (names a GeoJSON export). */\n  private plottedFileName: string | undefined;\n  /** The div the backends render into (every backend shares it); '' before the first plot. */\n  private plotDiv = '';\n\n  constructor(\n    private plotly: PlotlyService,\n    private osd: OpenSeadragonVisualizerService,\n    private napari: NapariVisualizerService,\n    private store: VisualizerStore,\n    @Inject(VIZ_CONFIG) private config: VizConfig,\n    // Optional: a host that serves no spatial-omics data binds nothing,\n    // and `getSpatialControls()` then returns null.\n    private regionStore: RegionStore,\n    private selectionStore: SpatialSelectionStore,\n    private intensity: IntensityProfileService,\n    @Optional()\n    @Inject(SPATIAL_DATA_PORT)\n    private spatialData: SpatialDataPort | null = null,\n  ) {}\n\n  private isImageType(t: PlotType): boolean {\n    return t === PlotType.IMAGE;\n  }\n\n  /** The 2D napari types (image, region-centroid scatter, spatial omics) — a 2D fallback chain\n   *  (OSD, then Plotly).\n   *\n   *  NOTE for SPATIAL_OMICS: only napari-js draws the observation markers. If it fails (no WebGPU,\n   *  device loss) the fallback renders the tissue image ALONE — the spatial layer is absent, not\n   *  degraded. That is deliberate for now: showing the slide beats showing nothing, and a Plotly\n   *  `scattergl` spatial mode is the planned real fallback (see the plot-mode design doc). */\n  private isNapariImageType(t: PlotType): boolean {\n    return t === PlotType.NAPARI_IMAGE || isNapariScatter(t) || isSpatialOmics(t);\n  }\n\n  /** The 3D napari types (volume/isosurface/surface/scatter, plus the 3D spatial cloud) — no 2D\n   *  fallback exists (OSD is image-only), so they fall straight to Plotly. */\n  private isNapari3dType(t: PlotType): boolean {\n    return isNapari3d(t) || isSpatialOmics3d(t);\n  }\n\n  /**\n   * Backend to attempt for the current plot type this render. The fallback chains below are\n   * mirrored exactly by {@link load} so the handle `plot()` receives always comes from the\n   * backend `plot()` selects (no load/plot backend mismatch):\n   *  - 2D image (explicit `NAPARI_IMAGE`, or `IMAGE` with the WebGPU opt-in): napari-js → OSD → Plotly.\n   *  - plain `IMAGE` (no opt-in): OSD → Plotly.\n   *  - 3D napari (`NAPARI_VOLUME`/`NAPARI_ISOSURFACE`): napari-js → Plotly (OSD can't render 3D).\n   */\n  private imageBackend(): IViewerBackend {\n    const t = this.currentPlotType;\n    // 2D image with a napari-js attempt (explicit napari image, or opt-in on the Image type).\n    if (this.isNapariImageType(t) || (this.isImageType(t) && this.config.useNapariRenderer)) {\n      if (!this.napariFellBack) return this.napari;\n      if (!this.osdFellBack) return this.osd;\n      return this.plotly;\n    }\n    // Plain Image type (no napari opt-in): OSD, then Plotly.\n    if (this.isImageType(t)) {\n      return this.osdFellBack ? this.plotly : this.osd;\n    }\n    // 3D napari types: napari-js, with Plotly as the only viable fallback.\n    if (this.isNapari3dType(t)) {\n      return this.napariFellBack ? this.plotly : this.napari;\n    }\n    return this.plotly;\n  }\n\n  /** Backend currently on screen — what ongoing zoom/tool/region ops act on. */\n  private renderer(): IViewerBackend {\n    return this.lastRendered ?? this.plotly;\n  }\n\n  // System capabilities are Plotly's (the full-featured backend) so the UI\n  // keeps offering every plot type regardless of which one is on screen.\n  get capabilities(): ViewerCapabilities {\n    return this.plotly.capabilities;\n  }\n\n  // ── render / viewport → active renderer ──────────────────────────────\n  async load(imageInfo: IImageInfo, zIndex: number, signal?: AbortSignal): Promise<LoadedImage> {\n    // A stack can open away from slice 0 (`initialZIndex` — a volume opens\n    // mid-specimen), and that arrives here rather than through setZIndex.\n    this.currentZIndex = zIndex;\n    const backend = this.imageBackend();\n    if (backend === this.napari) {\n      try {\n        return await this.napari.load(imageInfo, zIndex, signal);\n      } catch (err) {\n        // Aborted: nobody wants this image any more, so don't go on to load it elsewhere.\n        if (signal?.aborted) throw err;\n        this.napariFellBack = true;\n        // Mirror imageBackend()'s fallback so load + plot pick the same backend:\n        //  - 3D napari types have no 2D fallback → straight to Plotly.\n        //  - 2D image → OSD, then Plotly.\n        if (this.isNapari3dType(this.currentPlotType)) {\n          console.warn('[visualizer] napari-js load failed — falling back to Plotly.', err);\n          return this.plotly.load(imageInfo, zIndex, signal);\n        }\n        console.warn('[visualizer] napari-js load failed — falling back to OpenSeadragon.', err);\n        return this.loadViaOsdThenPlotly(imageInfo, zIndex, signal);\n      }\n    }\n    if (backend === this.osd) {\n      return this.loadViaOsdThenPlotly(imageInfo, zIndex, signal);\n    }\n    return this.plotly.load(imageInfo, zIndex, signal);\n  }\n\n  /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */\n  private async loadViaOsdThenPlotly(\n    imageInfo: IImageInfo,\n    zIndex: number,\n    signal?: AbortSignal,\n  ): Promise<LoadedImage> {\n    try {\n      return await this.osd.load(imageInfo, zIndex, signal);\n    } catch (err) {\n      if (signal?.aborted) throw err;\n      console.warn('[visualizer] OpenSeadragon load failed — falling back to Plotly for this image.', err);\n      this.osdFellBack = true;\n      return this.plotly.load(imageInfo, zIndex, signal);\n    }\n  }\n  plot(\n    plotDiv: string,\n    imageLoaded: unknown,\n    imageInfo: IImageInfo,\n    screenHeight: number,\n    plotType: PlotType,\n    inPlace?: boolean,\n  ): Promise<boolean> {\n    this.currentPlotType = plotType;\n    this.plottedFileName = imageInfo?.fileName;\n    this.plotDiv = plotDiv;\n    // Apply the per-image region cache (snapshot old regions, restore the new\n    // image's, clear selection) for whichever backend renders — Plotly does\n    // this inside its own plot(), but OSD doesn't, so drive it here. Idempotent\n    // for the same image, so it's safe to call on every (re)plot.\n    this.plotly.setActiveImage(imageInfo);\n    const next = this.imageBackend();\n    // Both backends share the same div — tear down the outgoing one on switch.\n    // Plotly must be *purged* (not reset, which re-draws empty axes) before OSD\n    // takes the div.\n    if (this.lastRendered && this.lastRendered !== next) {\n      if (this.lastRendered === this.plotly) this.plotly.purgePlot();\n      else this.lastRendered.reset();\n    }\n    this.lastRendered = next;\n    return next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);\n  }\n  reloadAndPlot(): void {\n    this.plotly.reloadAndPlot();\n  }\n  reset(): void {\n    // Start of a render cycle: re-enable napari-js/OSD attempts (clear any prior\n    // per-image fallback) and tear down whatever's on screen.\n    this.osdFellBack = false;\n    this.napariFellBack = false;\n    this.renderer().reset();\n  }\n  relayout(trueImageSize?: number[]): void {\n    this.renderer().relayout(trueImageSize);\n  }\n  resetAxes(): void {\n    this.renderer().resetAxes();\n  }\n  fitToView(): void {\n    this.renderer().fitToView();\n  }\n  /** @deprecated Use {@link fitToView}. */\n  autoscale(): void {\n    this.fitToView();\n  }\n  zoomIn(): void {\n    this.renderer().zoomIn();\n  }\n  zoomOut(): void {\n    this.renderer().zoomOut();\n  }\n  setDragMode(mode: string | false): void {\n    this.renderer().setDragMode(mode);\n  }\n  /** Every backend, on screen or not. */\n  private backends(): IViewerBackend[] {\n    return [this.plotly, this.osd, this.napari];\n  }\n\n  /**\n   * The navigator / smoothing options, applied to EVERY backend that has them (not\n   * just the active renderer): consumers set them before the first render, when\n   * `renderer()` is still the Plotly default, and OSD/napari-js must receive them\n   * to honour them at viewer creation.\n   */\n  getOsdViewOptions(): IOsdViewOptions {\n    return this.viewOptions;\n  }\n  private readonly viewOptions: IOsdViewOptions = {\n    setNavigatorVisible: (visible) => {\n      for (const b of this.backends()) b.getOsdViewOptions()?.setNavigatorVisible(visible);\n    },\n    setImageSmoothingEnabled: (enabled) => {\n      for (const b of this.backends()) b.getOsdViewOptions()?.setImageSmoothingEnabled(enabled);\n    },\n  };\n  /** @deprecated Use `getOsdViewOptions().setNavigatorVisible()`. */\n  setNavigatorVisible(visible: boolean): void {\n    this.viewOptions.setNavigatorVisible(visible);\n  }\n  /** @deprecated Use `getOsdViewOptions().setImageSmoothingEnabled()`. */\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.viewOptions.setImageSmoothingEnabled(enabled);\n  }\n  setShowStack(showstack: boolean): void {\n    this.renderer().setShowStack(showstack);\n  }\n  setZIndex(zIndex: number): void {\n    this.currentZIndex = zIndex;\n    this.renderer().setZIndex(zIndex);\n  }\n  getTrueImageSize(): { width: number; height: number } | null {\n    return this.renderer().getTrueImageSize();\n  }\n  getCurrentImage(): Promise<Image | null> {\n    return this.renderer().getCurrentImage();\n  }\n  getDisplayedPixelData(): PixelData | null {\n    return this.renderer().getDisplayedPixelData();\n  }\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    return this.renderer().getDisplayedSourceRect();\n  }\n  downloadImage(): void {\n    this.renderer().downloadImage();\n  }\n  exportComposite(): void {\n    this.renderer().exportComposite();\n  }\n\n  setPlotType(plotType: PlotType): void {\n    this.currentPlotType = plotType;\n    this.plotly.setPlotType(plotType);\n  }\n  /** @deprecated Use `getSurface3dControls()`. */\n  setSurfaceDragMode(mode: string): void {\n    this.getSurface3dControls()?.setSurfaceDragMode(mode);\n  }\n  /** @deprecated Use `getSurface3dControls()`. */\n  resetSurfaceCamera(): void {\n    this.getSurface3dControls()?.resetSurfaceCamera();\n  }\n  /** The 3D decimate factor of the backend on screen (napari-js), else null. */\n  getVolumeResolution(): IVolumeResolution | null {\n    return this.renderer().getVolumeResolution();\n  }\n  /** @deprecated Use `getVolumeResolution()?.set()`. */\n  setResolutionScale(scale: number): void {\n    this.getVolumeResolution()?.set(scale);\n  }\n  /** @deprecated Use `getVolumeResolution()?.get()`. */\n  getResolutionScale(): number {\n    return this.getVolumeResolution()?.get() ?? 1;\n  }\n  /** The viewport of the backend on screen, for a contributed plot mode. Null\n   *  when that backend cannot provide one (e.g. OSD fell back to Plotly). */\n  getPlotModeViewport(): PlotModeViewport | null {\n    return this.renderer().getPlotModeViewport?.() ?? null;\n  }\n  getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    // Plotly enumerates the full PLOT_TYPE_DESCRIPTORS map, which already includes the\n    // napari-js WebGPU types (jit-ui#102) — so this single source covers them (no duplicates).\n    return this.plotly.getPlotTypeDescriptors();\n  }\n\n  // ── long-lived observables + stack flags ──────────────────────────────────\n  setStackLoading(b: boolean): void {\n    this.plotly.setStackLoading(b);\n  }\n  // Cancel in-flight loading on every backend — the user's Cancel shouldn't depend on which one is\n  // active. Only backends that stream frames (napari-js) do real work; the rest no-op. The concrete\n  // backend classes don't all declare the optional contract method, so call it via IViewerBackend.\n  cancelLoading(): void {\n    for (const backend of [this.plotly, this.osd, this.napari] as IViewerBackend[]) {\n      backend.cancelLoading?.();\n    }\n  }\n  // Loading state is surfaced from whichever backend is doing the work: OSD and napari-js (volume\n  // assembly) drive their own subjects, so merge all three into one stable stream the host\n  // subscribes to once. (Previously hardcoded to Plotly, so napari/OSD progress never showed.)\n  isStackLoading(): Observable<boolean> {\n    return combineLatest([\n      this.plotly.isStackLoading(),\n      this.osd.isStackLoading(),\n      this.napari.isStackLoading(),\n    ]).pipe(map((flags) => flags.some(Boolean)));\n  }\n  getStackLoadingProgress(): Observable<number> {\n    // Report the progress of whichever backend is ACTIVELY loading (max across active ones). A plain\n    // merge let an idle backend's stale value win the stream on a re-load — leaving the bar below the\n    // active backend's real progress (e.g. stuck ~⅓ while the % read 100). Gating by the loading flag\n    // ignores idle backends, so the bar tracks the one doing the work and reaches 100%.\n    const track = (v: IViewerBackend): Observable<[number, boolean]> =>\n      combineLatest([v.getStackLoadingProgress(), v.isStackLoading()]);\n    return combineLatest([track(this.plotly), track(this.osd), track(this.napari)]).pipe(\n      map((pairs) => {\n        const active = pairs.filter(([, loading]) => loading).map(([p]) => p);\n        return active.length ? Math.max(...active) : 0;\n      }),\n    );\n  }\n  // Every backend fits to view on its own (Plotly's autoscale, OSD's goHome, napari's camera\n  // fit) and each emits from its own subject, so merge all three: listening to Plotly alone\n  // missed the context-menu Autoscale on the Image and napari views.\n  getAutoscaleEvent(): Observable<void> {\n    return merge(\n      this.plotly.getAutoscaleEvent(),\n      this.osd.getAutoscaleEvent(),\n      this.napari.getAutoscaleEvent(),\n    ).pipe(map(() => undefined));\n  }\n  /** The line-ROI profiles: sampled by the backend-neutral IntensityProfileService. */\n  getIntensityProfile$(): Observable<IntensityProfile[]> {\n    return this.intensity.getIntensityProfile$();\n  }\n  // The intensity inset is a Plotly LINE chart — render it through Plotly whichever\n  // backend draws the main image.\n  renderIntensityInset(divId: string, profiles: IntensityProfile[]): void {\n    this.plotly.renderIntensityInset(divId, profiles);\n  }\n\n  // ── regions ──────────────────────────────────────────────────────────\n  // Region state lives in the shared RegionStore, so every read and write goes\n  // straight to it. Every backend draws from the store's events: the OSD and\n  // napari-js overlays and Plotly's shape projection redraw on its region-update\n  // and selection streams, and the canvas tools reset on getRegionSetReplaced$\n  // (undo, redo, a slice switch).\n  setRegions(\n    regions: Region[],\n    showRegionLabel?: boolean,\n    isRegionSaveOn?: boolean,\n    fillColor?: string,\n    append?: boolean,\n  ): void {\n    this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);\n  }\n  getRegions(): Region[] {\n    return this.regionStore.getRegions();\n  }\n  getRegionPolygons(): Polygon[] {\n    return this.regionStore.getRegionPolygons();\n  }\n  getRegionUpdateEvent(): Observable<Region[]> {\n    return this.regionStore.getRegionUpdateEvent();\n  }\n  setSelectedShapeIndices(indices: number[]): void {\n    this.regionStore.setSelectedShapeIndices(indices);\n  }\n  selectRegion(region: Region): void {\n    this.regionStore.selectRegion(region);\n  }\n  getSelectedShapeIndices$(): Observable<number[]> {\n    return this.regionStore.getSelectedShapeIndices$();\n  }\n  deleteActiveShape(): void {\n    this.regionStore.deleteActiveShape();\n  }\n  getShowShapeLabel(): boolean {\n    return this.regionStore.getShowShapeLabel();\n  }\n  getShapeColor(): string {\n    return this.regionStore.getShapeColor();\n  }\n  getFillColor(): string {\n    return this.regionStore.getFillColor();\n  }\n  getClassificationColors(): Map<string, string> {\n    return this.store.getClassificationColors();\n  }\n  setClassificationColor(label: string, color: string): void {\n    this.store.setClassificationColor(label, color);\n  }\n  // Annotation-class presets live in the shared VisualizerStore (backend-neutral\n  // session state), so route straight to it rather than through renderer(). (jit-ui#70)\n  getPresetSet(): PresetSet {\n    return this.store.getPresetSet();\n  }\n  getPresetSet$(): Observable<PresetSet> {\n    return this.store.getPresetSet$();\n  }\n  setPresetSet(set: PresetSet): void {\n    this.store.setPresetSet(set);\n  }\n  upsertClass(preset: ClassPreset): void {\n    this.store.upsertClass(preset);\n  }\n  removeClass(name: string): void {\n    this.store.removeClass(name);\n  }\n  resetPresets(): void {\n    this.store.resetPresets();\n  }\n  undo(): void {\n    this.regionStore.undo();\n  }\n  redo(): void {\n    this.regionStore.redo();\n  }\n  canUndo(): boolean {\n    return this.regionStore.canUndo();\n  }\n  canRedo(): boolean {\n    return this.regionStore.canRedo();\n  }\n  getCanUndo$(): Observable<boolean> {\n    return this.regionStore.getCanUndo$();\n  }\n  getCanRedo$(): Observable<boolean> {\n    return this.regionStore.getCanRedo$();\n  }\n  resetUndoHistory(): void {\n    this.regionStore.resetUndoHistory();\n  }\n  importRegions(geoJsonStr: string): Region[] {\n    return this.regionStore.importRegions(geoJsonStr);\n  }\n  /** Download `regions` as GeoJSON, named after the image last plotted. */\n  exportRegions(regions: Region[]): void {\n    this.regionStore.exportRegions(regions, this.plottedFileName);\n  }\n  getGeoJsonString(regions: Region[]): string {\n    return this.regionStore.getGeoJsonString(regions);\n  }\n\n  // ── Per-slice z-stack regions (jit-ui#93), from the shared RegionStore. ──\n  enterStackMode(\n    slices: Map<number, Region[]>,\n    initialZ?: number,\n    saveLayout?: 'combined' | 'per-slice-file',\n  ): void {\n    this.regionStore.enterStackMode(slices, initialZ, saveLayout);\n  }\n  exitStackMode(): void {\n    this.regionStore.exitStackMode();\n  }\n  isStackMode(): boolean {\n    return this.regionStore.isStackMode();\n  }\n  getStackSaveLayout(): 'combined' | 'per-slice-file' {\n    return this.regionStore.getStackSaveLayout();\n  }\n  setDisplaySlice(z: number): void {\n    this.regionStore.setDisplaySlice(z);\n  }\n  getSliceRegions(): Region[] {\n    return this.regionStore.getSliceRegions();\n  }\n  getStackSaveSlices(): Map<number, Region[]> {\n    return this.regionStore.getStackSaveSlices();\n  }\n  /** All slices' ANNOTATION regions for a z-stack save (jit-ui#93), each tagged\n   *  with its zero-based Region.z; profile lines excluded. Flat annotation set\n   *  outside stack mode. */\n  getSliceAnnotationRegions(): Region[] {\n    return this.regionStore.getSliceRegions().filter((r) => !isProfileRegion(r));\n  }\n  /** Per-slice annotation regions to write on a folder-stack save (jit-ui#93):\n   *  slice index → that slice's annotation regions (profile lines excluded),\n   *  including now-empty slices that were loaded non-empty (so they overwrite). */\n  getStackSaveAnnotationSlices(): Map<number, Region[]> {\n    const out = new Map<number, Region[]>();\n    for (const [z, regs] of this.regionStore.getStackSaveSlices()) {\n      out.set(\n        z,\n        regs.filter((r) => !isProfileRegion(r)),\n      );\n    }\n    return out;\n  }\n\n  /** Authoritative full-resolution image size for mask export. Prefers the\n   *  active renderer's reported size, falling back to the image metadata (x/y\n   *  are the full-res pixel dimensions used across the app). Rejects non-finite\n   *  or non-positive sizes — the Plotly bounds can yield NaN before a plot is\n   *  fully laid out, which would otherwise crash mask creation. */\n  getMaskImageSize(): { width: number; height: number } | null {\n    const valid = (s: { width: number; height: number } | null | undefined) =>\n      s && Number.isFinite(s.width) && Number.isFinite(s.height) && s.width >= 1 && s.height >= 1\n        ? { width: Math.round(s.width), height: Math.round(s.height) }\n        : null;\n\n    const fromRenderer = valid(this.getTrueImageSize());\n    if (fromRenderer) return fromRenderer;\n\n    let meta: IImageMetadata[] = [];\n    this.getImageMeta()\n      .subscribe((m) => (meta = m))\n      .unsubscribe();\n    const m0 = meta?.[0];\n    return m0 ? valid({ width: m0.x, height: m0.y }) : null;\n  }\n\n  // ── IRegionEditorApi: annotation-only surface for the Region Editor ───\n  // Intensity-profile lines (kind='profile') belong to the intensity tool, not\n  // the editor. These methods give external consumers an annotation-only view\n  // and guarantee profile lines are preserved. The writes land in the store like\n  // any other, and every backend redraws from its events.\n\n  getAnnotationRegions(): Region[] {\n    return this.regionStore.getRegions().filter((r) => !isProfileRegion(r));\n  }\n  setAnnotationRegions(\n    regions: Region[],\n    showRegionLabel?: boolean,\n    isRegionSaveOn?: boolean,\n    fillColor?: string,\n  ): void {\n    // Re-append the store's profile lines so an editor save/delete can't drop them.\n    const profiles = this.regionStore.getRegions().filter((r) => isProfileRegion(r));\n    const annotations = (regions || []).filter((r) => !isProfileRegion(r));\n    this.setRegions([...annotations, ...profiles], showRegionLabel, isRegionSaveOn, fillColor, false);\n  }\n  getSelectedRegions$(): Observable<Region[]> {\n    // Map the internal index-based selection to the selected annotation regions.\n    return this.getSelectedShapeIndices$().pipe(\n      map((idxs) => {\n        const regs = this.regionStore.getRegions();\n        return idxs.map((i) => regs[i]).filter((r): r is Region => !!r && !isProfileRegion(r));\n      }),\n    );\n  }\n  setSelectedRegions(regions: Region[]): void {\n    const regs = this.regionStore.getRegions();\n    const indices = (regions || []).map((r) => regs.findIndex((x) => x.id === r.id)).filter((i) => i >= 0);\n    this.setSelectedShapeIndices(indices);\n  }\n\n  // ── tools → active renderer (run on either backend) ─────────────────\n  // The wand, vertex eraser and zoom-to-box are implemented on both backends\n  // via ICoordinateTransform (+ a viewport pixel readback for the wand), so they\n  // follow the active renderer.\n  setActiveTool(id: string | null, options?: CanvasToolOptions): void {\n    this.renderer().setActiveTool(id, options);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setWandMode(active: boolean, options?: IWandOptions): void {\n    this.renderer().setWandMode(active, options);\n  }\n  setWandOptions(options: IWandOptions): void {\n    this.renderer().setWandOptions(options);\n  }\n  clearActiveWandRegion(): void {\n    this.renderer().clearActiveWandRegion();\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setBrushMode(active: boolean, options?: IBrushOptions): void {\n    this.renderer().setBrushMode(active, options);\n  }\n  setBrushOptions(options: IBrushOptions): void {\n    this.renderer().setBrushOptions(options);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setVertexEraserMode(active: boolean): void {\n    this.renderer().setVertexEraserMode(active);\n  }\n  setVertexEraserRadius(radius: number): void {\n    this.renderer().setVertexEraserRadius(radius);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setZoomToBoxMode(active: boolean): void {\n    this.renderer().setZoomToBoxMode(active);\n  }\n  segmentRectangles(): Promise<number> {\n    return this.renderer().segmentRectangles();\n  }\n  segmentRectanglesCellpose(): Promise<number> {\n    return this.renderer().segmentRectanglesCellpose();\n  }\n  setSamModel(id: string): void {\n    this.renderer().setSamModel(id);\n  }\n  /** @deprecated Use {@link setActiveTool}. */\n  setSamPointMode(active: boolean): void {\n    this.renderer().setSamPointMode(active);\n  }\n  commitSamPoints(): void {\n    this.renderer().commitSamPoints();\n  }\n  clearSamPoints(): void {\n    this.renderer().clearSamPoints();\n  }\n\n  // ── display options ──────────────────────────────────────────────────\n  // State lives in the shared VisualizerStore — reads go straight to it.\n  // The two SETTERS still route through Plotly because its implementations\n  // carry render glue beyond the store write (a live Plotly.restyle of\n  // colorscale/reversescale on the mounted heatmap); OSD recolors via its own\n  // store subscription either way.\n  getColormap(): Observable<ColormapNode | null> {\n    return this.store.getColormap();\n  }\n  setColormap(colormap: ColormapNode): void {\n    this.plotly.setColormap(colormap);\n  }\n  getColormapOptions(): ColormapNode[] {\n    return this.store.getColormapOptions();\n  }\n  getReverseScale(): Observable<boolean> {\n    return this.store.getReverseScale();\n  }\n  setReverseScale(reverse: boolean): void {\n    this.plotly.setReverseScale(reverse);\n  }\n  setImageMeta(imageMeta: IImageMetadata[], imageKey?: string): void {\n    this.store.setImageMeta(imageMeta, imageKey);\n  }\n  getImageMeta(): Observable<IImageMetadata[]> {\n    return this.store.getImageMeta();\n  }\n\n  // ── IChannelHistogramApi: Channels & Histogram pane surface ───────────\n  // Channel/grayscale/invert state lives in the shared VisualizerStore; both\n  // backends subscribe and recolor live, so setters just write the store. The\n  // histogram comes from whichever backend is on screen (its native pixels).\n  getHistogram(channelIndex: number, bins: number): IHistogram | null {\n    return this.renderer().getHistogram(channelIndex, bins);\n  }\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    return this.renderer().getHistogram$(channelIndex, bins);\n  }\n  /** Export the underlying data (16-bit multi-band TIFF) via the active backend. */\n  exportData(): void {\n    this.renderer().exportData();\n  }\n  getChannels$(): Observable<IChannelState[]> {\n    return this.store.getChannelStates();\n  }\n  setSelectedChannel(index: number): void {\n    this.store.setSelectedChannel(index);\n  }\n  setChannelState(index: number, partial: Partial<IChannelState>): void {\n    this.store.setChannelState(index, partial);\n  }\n  resetContrast(indices: number[]): void {\n    // Full reset: window (0..255), gamma (1) AND the channel's default tint.\n    for (const i of indices) this.store.resetChannelState(i);\n  }\n  /** Auto-window each channel by saturating `saturation` (0..1) of pixels at each\n   *  end of its histogram (skipping outlier first/last bins). */\n  autoContrast(indices: number[], saturation: number): void {\n    for (const i of indices) {\n      const h = this.renderer().getHistogram(i, 256);\n      if (!h) continue;\n      const [min, max] = autoWindowFromHistogram(h, saturation, [0, 255]);\n      if (max > min) this.store.setChannelState(i, { min, max });\n    }\n  }\n  getGrayscale$(): Observable<boolean> {\n    return this.store.getGrayscale();\n  }\n  setGrayscale(on: boolean): void {\n    this.store.setGrayscale(on);\n  }\n  getInvert$(): Observable<boolean> {\n    return this.store.getInvert();\n  }\n  setInvert(on: boolean): void {\n    this.store.setInvert(on);\n  }\n\n  /**\n   * The active backend's region overlay. Falls back to Plotly's when the active backend\n   * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a\n   * usable overlay.\n   */\n  getRegionOverlay(): IRegionOverlay {\n    const r = this.renderer();\n    if (r === this.osd) {\n      return this.osd.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    if (r === this.napari) {\n      return this.napari.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    return this.plotly.getRegionOverlay();\n  }\n\n  /** Isosurface controls of the backend on screen, when it renders isosurfaces. */\n  getIsosurfaceControls(): IIsosurfaceControls | null {\n    return this.renderer().getIsosurfaceControls();\n  }\n\n  /** 3D scene controls of the backend on screen (Plotly or napari-js), or null on a\n   *  2D-only one. */\n  getSurface3dControls(): ISurface3dControls | null {\n    return this.renderer().getSurface3dControls();\n  }\n\n  /** Intensity (line-ROI) controls, whichever backend draws the image: the\n   *  IntensityProfileService adds the line to the store, and every backend\n   *  (Plotly included) draws it from the store's update event. */\n  getIntensityControls(): IIntensityControls | null {\n    return this.intensity;\n  }\n\n  /**\n   * Spatial-omics controls, or null when no `SPATIAL_DATA_PORT` is bound. Served by a\n   * backend-neutral {@link SpatialControlsFacade} (state in the shared stores), so the\n   * controls work across a plot-type switch and before any backend has mounted.\n   */\n  getSpatialControls(): ISpatialControls | null {\n    if (!this.spatialData) return null;\n    this.spatialFacade ??= new SpatialControlsFacade(this.spatialData, {\n      store: this.store,\n      regionStore: this.regionStore,\n      selectionStore: this.selectionStore,\n      napari: this.napari,\n      plotType: () => this.currentPlotType,\n      zIndex: () => this.currentZIndex,\n    });\n    return this.spatialFacade.controls;\n  }\n\n  /** Created on first use; owns the dataset subscription. */\n  private spatialFacade: SpatialControlsFacade | null = null;\n  /** Displayed slice. Only a volume-backed spatial dataset reads it, to keep a\n   *  region drawn over one section from selecting the whole depth behind it. */\n  private currentZIndex = 0;\n\n  /** Angular calls this when the injector providing the router is destroyed — the host\n   *  component for a `provideVisualization()` chain. The dataset subscription would\n   *  otherwise keep the whole isolated chain reachable from the root data port. */\n  ngOnDestroy(): void {\n    this.spatialFacade?.dispose();\n    this.spatialFacade = null;\n  }\n\n  /**\n   * Intensity-profile sampling, whichever backend is on screen: the sampling is the\n   * backend-neutral IntensityProfileService's; the viewport changes come from every\n   * backend that reports them (OpenSeadragon, napari-js), merged into one stable\n   * stream the inset subscribes to once.\n   */\n  getIntensitySampling(): IIntensitySampling {\n    return this.intensitySampling;\n  }\n  private readonly intensitySampling: IIntensitySampling = {\n    // Load the displayed slice's pixels for a backend that has no frames of its own\n    // (OpenSeadragon, napari-js; Plotly feeds its frames to the service when it plots).\n    ensureIntensitySampling: (imageInfo, zIndex) => {\n      this.pointSamplingAtPlot();\n      return this.intensity.ensureIntensitySampling(imageInfo, zIndex);\n    },\n    // Re-sample from a fresh crop of the image-pixel ROI at display resolution.\n    refreshIntensitySamplingForRoi: (x, y, width, height, zIndex) => {\n      this.pointSamplingAtPlot();\n      this.intensity.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);\n    },\n    getViewportChange$: () =>\n      merge(...this.backends().map((b) => b.getIntensitySampling()?.getViewportChange$() ?? EMPTY)),\n  };\n  /** @deprecated Use `getIntensitySampling().ensureIntensitySampling()`. */\n  ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void> {\n    return this.intensitySampling.ensureIntensitySampling(imageInfo, zIndex);\n  }\n\n  /** Crops for sampling are sized from the plot div (whichever backend renders into it). */\n  private pointSamplingAtPlot(): void {\n    if (this.plotDiv) this.intensity.setSamplingElement(this.plotDiv);\n  }\n\n  /** @deprecated Use `getIntensitySampling().getViewportChange$()`. */\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return this.intensitySampling.getViewportChange$();\n  }\n\n  /** @deprecated Use `getIntensitySampling().refreshIntensitySamplingForRoi()`. */\n  refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number, zIndex: number): void {\n    this.intensitySampling.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);\n  }\n\n  /** The visualizer view is going away: detach every backend — dropping their view-bound\n   *  subscriptions and disposing the napari-js viewer, whose canvas, render loop and GPU\n   *  buffers would otherwise outlive the view (for a component-scoped chain, forever).\n   *  Nothing is on screen afterwards, so the next plot starts from the default backend. */\n  detach(): void {\n    this.plotly.detach();\n    this.osd.detach();\n    this.napari.detach();\n    this.lastRendered = null;\n  }\n\n  /** @deprecated Use {@link detach}. */\n  unsubscribe(): void {\n    this.detach();\n  }\n}\n"]}