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

package/lib/region-source/worker-region-source.d.ts

@@ -0,0 +1,65 @@
+/**
+ * A {@link RegionSource} over a GeoJSON string, parsed and tiled in the region-source Web Worker.
+ *
+ * One worker serves every open source. Where no worker can start (jsdom, SSR, a blocked worker
+ * URL) the same tables run on the main thread; if the worker dies, each source re-opens itself
+ * there from its text (which the host holds anyway: it handed it over) and carries on — whether
+ * it had a call in flight then or not (see {@link RegionSourceWorkerClient.generation}).
+ */
+import { RegionSource } from './region-source';
+import { RegionSourceRequest, RegionSourceResults } from './region-source-ops';
+import type { ReconstructOptions, SliceOutlines } from '../geometry/reconstruct';
+import type { Mesh } from 'napari-js/geometry';
+/** Makes the worker; may be async, as the default one is (it imports the factory on demand). */
+export type RegionSourceWorkerFactory = () => Worker | Promise<Worker>;
+/** Owns the region-source worker and the calls in flight on it. */
+export declare class RegionSourceWorkerClient {
+    private readonly factory?;
+    private worker;
+    private starting;
+    private unavailable;
+    private nextId;
+    private readonly pending;
+    /** The main-thread tables, once anything runs here. */
+    private local;
+    private tables;
+    /**
+     * `factory` is optional: without one the real worker module is imported on demand —
+     * dynamically, because it holds an `import.meta.url` that ts-jest's CommonJS compile
+     * rejects.
+     */
+    constructor(factory?: RegionSourceWorkerFactory | undefined);
+    /** Whether calls now run on the main thread. */
+    get inThread(): boolean;
+    /**
+     * Which table set calls run on: bumped when the worker is lost. A handle opened under another
+     * names a table that is gone (or, here, another source's), so its source must open again.
+     */
+    get generation(): number;
+    /** Run `request` in the worker, or here when there is none. */
+    call<R extends RegionSourceRequest>(request: R): Promise<RegionSourceResults[R['op']]>;
+    /** {@link call}, with the {@link generation} the request ran on. */
+    run<R extends RegionSourceRequest>(request: R): Promise<{
+        result: RegionSourceResults[R['op']];
+        generation: number;
+    }>;
+    /** Terminate the worker; calls in flight reject. */
+    dispose(): void;
+    private ensureWorker;
+    private startWorker;
+    private onReply;
+    /** Stop the worker for good: every later call runs here, every call in flight is lost. */
+    private lose;
+}
+/** The worker client every GeoJSON source shares. */
+export declare function sharedRegionSourceClient(): RegionSourceWorkerClient;
+/**
+ * Open a GeoJSON FeatureCollection string as a tiled region source. Rejects on invalid JSON or
+ * a collection without `features`.
+ */
+export declare function openGeoJsonRegionSource(text: string, client?: RegionSourceWorkerClient): Promise<RegionSource>;
+/**
+ * The 3D reconstruction of a region from its outlines on a stack (see `geometry/reconstruct`),
+ * meshed in the region-source worker (on the main thread where there is none).
+ */
+export declare function reconstructInWorker(slices: readonly SliceOutlines[], options?: ReconstructOptions, client?: RegionSourceWorkerClient): Promise<Mesh>;

package/lib/render-orchestrator.d.ts

@@ -16,7 +16,8 @@ import { IImageInfo } from './contracts/image.contract';
 export interface TwoPassRenderHost {
     /** Load + plot one phase (the component owns div/screen/plot-type/z and the
      *  newer-click filename guard). `inPlace` updates the existing render so the
-     *  canvas doesn't blank during the small→large swap. */
+     *  canvas doesn't blank during the small→large swap. Rejects when the phase
+     *  could not be drawn (including a backend's `plot()` resolving false). */
     renderPhase(info: IImageInfo, inPlace: boolean): Promise<unknown>;
     /** The small tier is on screen — drop the full loading overlay so the user
      *  sees the blurry preview, and show the sharpening spinner. */
@@ -26,10 +27,13 @@ export interface TwoPassRenderHost {
     /** Rendering finished. `viaSmall` = the overlay was already released by the
      *  small tier (so only release the running guard + apply the ROI); otherwise
      *  do the full finalize (overlay + running + ROI). */
-    finished(viaSmall: boolean, logTag: string): void;
+    finished(viaSmall: boolean): void;
     /** Both large-tier attempts failed; the small tier stays on screen as the
      *  fallback. Surface it to the user and release the running guard + ROI. */
     sharpenFailed(err: unknown): void;
+    /** Nothing could be drawn: the single pass failed, or both tiers did. Called
+     *  after {@link finished} (which releases the overlay), to tell the user. */
+    renderFailed(err: unknown): void;
 }
 export declare class RenderOrchestrator {
     private host;

package/lib/render-session.d.ts

@@ -0,0 +1,75 @@
+import { IImageInfo } from './contracts/image.contract';
+import { PlotType } from './contracts/plot-type';
+import { SpatialDataset } from './contracts/spatial-dataset.contract';
+import { IVisualizer } from './contracts/visualizer.contract';
+/** A user-facing message for a failure: an HttpErrorResponse's server message, an
+ *  Error's message, or the status text, else the value itself. */
+export declare function errorMessage(err: unknown): string;
+/** The viewer a render session draws into, and what it tells the viewer. */
+export interface RenderSessionHost {
+    readonly plotDivName: string;
+    readonly visualizer: IVisualizer;
+    /** The slice to load, read when each phase starts. */
+    zIndex(): number;
+    plotType(): PlotType;
+    /** A 2D view: only it renders the small tier first (the in-place sharpen pass does
+     *  not rebuild a 3D scene, so it blanked one). */
+    isHeatmap(): boolean;
+    /** A server-side cache fill is in progress (keeps the full overlay up). */
+    isCaching(): boolean;
+    /** The view is about to be torn down: end what was bound to it (contributed sessions). */
+    beforeReset(): void;
+    /** Lay the new image out (stack flag, slice bounds, initial slice) once the old view is gone. */
+    prepare(info: IImageInfo): void;
+    /** Drop the loading overlay the render owns (once per render). */
+    releaseOverlay(info: IImageInfo): void;
+    /** The render landed, sharp or as a fallback: apply ROIs, start sessions. */
+    landed(info: IImageInfo): void;
+    setImageLoading(loading: boolean): void;
+    alert(severity: 'warn' | 'error', summary: string, detail: string): void;
+    detectChanges(): void;
+}
+/**
+ * The viewer's render pipeline: one image (or image-less dataset) at a time, the newest
+ * always winning.
+ *
+ * Every render takes a task from a {@link Supersede}: a newer render, a Cancel or
+ * teardown makes the older one stale — its callbacks return early instead of painting,
+ * releasing the newer render's overlay or applying its ROIs — and aborts the signal its
+ * loads were given, so superseded network work stops at the source. Sequencing of the
+ * small→large tiers lives in {@link RenderOrchestrator}; this owns the UI flags it
+ * drives ({@link running}, {@link sharpening}).
+ */
+export declare class ImageRenderSession {
+    private readonly host;
+    /** A render is in flight. */
+    running: boolean;
+    /** The small tier is on screen and the large one is still loading. */
+    sharpening: boolean;
+    /** Set once the plot div exists; an image-less draw before then waits for it. */
+    private viewReady;
+    private pendingDraw;
+    private readonly supersede;
+    constructor(host: RenderSessionHost);
+    /**
+     * Render `info` (which has urls), preempting whatever is in flight. A newer image
+     * ALWAYS preempts: dropping it while the old one finished reported image B as loaded
+     * while image A stayed on screen, and a cold image held the slot for its whole
+     * server-side cache fill.
+     */
+    render(info: IImageInfo): void;
+    /**
+     * Draw a spatial mode with no image behind it: the observations alone, framed on their
+     * own extent. The image info is a placeholder naming the dataset, so regions drawn here
+     * are kept per dataset like any image's. Supersedes (and is superseded by) image renders.
+     */
+    plotWithoutImage(dataset: SpatialDataset): Promise<void>;
+    /**
+     * The plot div exists now: run an image-less draw that arrived before it did — only if
+     * its dataset is still the one on offer (by id: the port may re-emit the same dataset
+     * as a new object, and the current object is the one to draw) and no image has arrived.
+     */
+    viewIsReady(current: SpatialDataset | null, hasImage: boolean): void;
+    /** Cancel the render in flight: abort its loads and make its callbacks inert. */
+    cancel(): void;
+}

package/lib/routing-visualizer.service.d.ts

@@ -1,14 +1,20 @@
+import { OnDestroy } from '@angular/core';
 import { Observable } from 'rxjs';
 import { Image } from 'image-js';
 import { IImageInfo, IImageMetadata } from './contracts/image.contract';
-import { Region } from './models/region';
+import { Polygon, Region } from './models/region';
 import { ClassPreset, PresetSet } from './models/class-preset';
 import { PlotlyService } from './implementations/plotly/plotly.service';
 import { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';
 import { PlotType, PlotTypeDescriptor } from './contracts/plot-type';
-import { IVisualizer, PixelData, IntensityProfile, IIsosurfaceControls, IIntensityControls, ISurface3dControls, ISpatialControls } from './contracts/visualizer.contract';
+import { IVisualizer, LoadedImage, PixelData, IntensityProfile, IIsosurfaceControls, IIntensityControls, ISurface3dControls, ISpatialControls, IIntensitySampling, IOsdViewOptions, IVolumeResolution } from './contracts/visualizer.contract';
 import { SpatialDataPort } from './contracts/ports/spatial-data.port';
+import { CanvasToolOptions, ColormapNode, IBrushOptions, IWandOptions } from './contracts/display-types';
 import { RegionStore } from './store/region-store.service';
+import { RegionSource, RegionSourceView } from './region-source/region-source';
+import type { RegionIndexPage, RegionIndexQuery } from './region-source/region-tiles';
+import type { RegionStyle } from './region-overlay/region-style';
+import type { RegionSourceOpener, RegionSourceSlices } from './store/region-source-scope';
 import { SpatialSelectionStore } from './store/spatial-selection.service';
 import { ViewerCapabilities } from './contracts/capabilities.contract';
 import { IRegionOverlay } from './contracts/region-overlay.contract';
@@ -18,8 +24,33 @@ import { VisualizerStore } from './store/visualizer-store.service';
 import { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';
 import { VizConfig } from './contracts/viz-config';
 import { PlotModeViewport } from './contracts/plot-type-contribution.contract';
+import { IntensityProfileService } from './intensity/intensity-profile.service';
+import type { SectionAxis, SectionViews } from './contracts/section-view.contract';
 import * as i0 from "@angular/core";
-export declare class RoutingVisualizerService implements IVisualizer, IRegionEditorApi, IChannelHistogramApi {
+/** How long after the last edit the surfaces of the classes it touched are rebuilt (ms). */
+export declare const REGION_SURFACE_REBUILD_MS = 600;
+/**
+ * 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 declare class RoutingVisualizerService implements IVisualizer, IRegionEditorApi, IChannelHistogramApi, OnDestroy {
     private plotly;
     private osd;
     private napari;
@@ -27,6 +58,7 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     private config;
     private regionStore;
     private selectionStore;
+    private intensity;
     private spatialData;
     private currentPlotType;
     private lastRendered;
@@ -39,7 +71,59 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     /** 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}. */
     private napariFellBack;
-    constructor(plotly: PlotlyService, osd: OpenSeadragonVisualizerService, napari: NapariVisualizerService, store: VisualizerStore, config: VizConfig, regionStore: RegionStore, selectionStore: SpatialSelectionStore, spatialData?: SpatialDataPort | null);
+    /** The file name of the image last plotted (names a GeoJSON export). */
+    private plottedFileName;
+    /** The div the backends render into (every backend shares it); '' before the first plot. */
+    private plotDiv;
+    /** Whether a napari volume view is the current plot type. */
+    private readonly volumeView$;
+    /** Whether the volume view's slice pane is wanted (see {@link setSliceEditor}). */
+    private readonly sliceEditor$;
+    /** Whether the volume view draws the region reconstructions through the volume. */
+    private readonly regionsThroughVolume$;
+    /** Region reconstructions built so far, by image, resolution and classes (with those classes). */
+    private readonly meshCache;
+    /** Bumped per {@link showRegionClasses3d} (and per new image), so only the latest one shows. */
+    private meshRequest;
+    /** The class groups shown in 3D, and the image they belong to. */
+    private readonly classes3d$;
+    private classes3dImage;
+    /** The groups last asked for in 3D, with their colours: what an edit's rebuild shows again. */
+    private shown3d;
+    /**
+     * Each class's fingerprint on the live slice (see classSignatures), which image and slice, and
+     * what the region sources hold (see RegionStore.getSourceStateKey). Null while nothing follows
+     * the edits (no surface built, no sections).
+     */
+    private liveClasses;
+    /** The pending rebuild of the surfaces an edit touched. */
+    private rebuildTimer;
+    private readonly regionUpdates;
+    /** The div the slice pane renders into while it is wanted (null: no split). */
+    private sliceDiv;
+    /** Whether OSD is mounted in the slice pane: region, tool and overlay calls go to it. */
+    private sliceMounted;
+    /** The image the slice pane shows. */
+    private sliceFile;
+    /** Bumped per slice-pane mount or teardown, so only the latest one lands. */
+    private sliceRequest;
+    /** The sections beside the split volume view (the planes x and y through the stack). */
+    private readonly sections;
+    /** The z plane dragged in the volume: the slice to show (see {@link getSliceDrag$}). */
+    private readonly sliceDrag$;
+    private readonly sectionSubs;
+    /** The image info and screen height of the last plot (what the slice pane mounts). */
+    private plottedInfo;
+    private plottedHeight;
+    constructor(plotly: PlotlyService, osd: OpenSeadragonVisualizerService, napari: NapariVisualizerService, store: VisualizerStore, config: VizConfig, regionStore: RegionStore, selectionStore: SpatialSelectionStore, intensity: IntensityProfileService, spatialData?: SpatialDataPort | null);
+    /** A class's colour: its classification colour, else its region source's, else a default. */
+    private classColor;
+    /** The sections beside the split volume view (nulls while it is not split). */
+    getSectionViews$(): Observable<SectionViews>;
+    /** Move a section's plane to `at` (image px). */
+    setSectionPlane(axis: SectionAxis, at: number): void;
+    /** The slice picked by dragging the z plane in the volume: the host shows it (its slider). */
+    getSliceDrag$(): Observable<number>;
     private isImageType;
     /** The 2D napari types (image, region-centroid scatter, spatial omics) — a 2D fallback chain
      *  (OSD, then Plotly).
@@ -63,20 +147,50 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     private imageBackend;
     /** Backend currently on screen — what ongoing zoom/tool/region ops act on. */
     private renderer;
+    /**
+     * Backend region, tool and overlay calls act on: the slice pane's OSD while the volume view is
+     * split (regions are edited there), else the backend on screen. View calls (zoom, fit, colour,
+     * export) stay with {@link renderer}.
+     */
+    private regionBackend;
     get capabilities(): ViewerCapabilities;
-    load(imageInfo: IImageInfo, zIndex: number): Promise<any>;
+    load(imageInfo: IImageInfo, zIndex: number, signal?: AbortSignal): Promise<LoadedImage>;
     /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */
     private loadViaOsdThenPlotly;
-    plot(plotDiv: string, imageLoaded: any, imageInfo: IImageInfo, screenHeight: number, plotType: PlotType, inPlace?: boolean): Promise<boolean>;
+    plot(plotDiv: string, imageLoaded: unknown, imageInfo: IImageInfo, screenHeight: number, plotType: PlotType, inPlace?: boolean): Promise<boolean>;
+    /**
+     * Split the volume view: show the slice being edited in `div` (OpenSeadragon, with every region
+     * tool) beside the 3D view, or stop (null). Kept across re-plots of a volume view; another plot
+     * type takes the pane down and a volume view brings it back. Resolves whether the pane shows.
+     */
+    setSliceEditor(div: string | null): Promise<boolean>;
+    /** Mount (or refresh in place) OSD in the slice pane on the displayed slice. */
+    private mountSlice;
+    /** Take the slice pane's viewer down (the split stays wanted while {@link sliceDiv} is set). */
+    private unmountSlice;
     reloadAndPlot(): void;
     reset(): void;
     relayout(trueImageSize?: number[]): void;
     resetAxes(): void;
+    fitToView(): void;
+    /** @deprecated Use {@link fitToView}. */
     autoscale(): void;
     zoomIn(): void;
     zoomOut(): void;
     setDragMode(mode: string | false): void;
+    /** Every backend, on screen or not. */
+    private backends;
+    /**
+     * 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(): IOsdViewOptions;
+    private readonly viewOptions;
+    /** @deprecated Use `getOsdViewOptions().setNavigatorVisible()`. */
     setNavigatorVisible(visible: boolean): void;
+    /** @deprecated Use `getOsdViewOptions().setImageSmoothingEnabled()`. */
     setImageSmoothingEnabled(enabled: boolean): void;
     setShowStack(showstack: boolean): void;
     setZIndex(zIndex: number): void;
@@ -95,9 +209,15 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     downloadImage(): void;
     exportComposite(): void;
     setPlotType(plotType: PlotType): void;
+    /** @deprecated Use `getSurface3dControls()`. */
     setSurfaceDragMode(mode: string): void;
+    /** @deprecated Use `getSurface3dControls()`. */
     resetSurfaceCamera(): void;
+    /** The 3D decimate factor of the backend on screen (napari-js), else null. */
+    getVolumeResolution(): IVolumeResolution | null;
+    /** @deprecated Use `getVolumeResolution()?.set()`. */
     setResolutionScale(scale: number): void;
+    /** @deprecated Use `getVolumeResolution()?.get()`. */
     getResolutionScale(): number;
     /** 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). */
@@ -107,13 +227,14 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     cancelLoading(): void;
     isStackLoading(): Observable<boolean>;
     getStackLoadingProgress(): Observable<number>;
-    getAutoscaleEvent(): Observable<any>;
+    getAutoscaleEvent(): Observable<void>;
+    /** The line-ROI profiles: sampled by the backend-neutral IntensityProfileService. */
     getIntensityProfile$(): Observable<IntensityProfile[]>;
     renderIntensityInset(divId: string, profiles: IntensityProfile[]): void;
     setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean, fillColor?: string, append?: boolean): void;
     getRegions(): Region[];
-    getRegionPolygons(): any[];
-    getRegionUpdateEvent(): Observable<any[]>;
+    getRegionPolygons(): Polygon[];
+    getRegionUpdateEvent(): Observable<Region[]>;
     setSelectedShapeIndices(indices: number[]): void;
     selectRegion(region: Region): void;
     getSelectedShapeIndices$(): Observable<number[]>;
@@ -129,9 +250,6 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     upsertClass(preset: ClassPreset): void;
     removeClass(name: string): void;
     resetPresets(): void;
-    plotPreviousShapes(): void;
-    setPreviousShapes(shapes: any[]): void;
-    getPreviousShapes(): any[];
     undo(): void;
     redo(): void;
     canUndo(): boolean;
@@ -140,11 +258,77 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     getCanRedo$(): Observable<boolean>;
     resetUndoHistory(): void;
     importRegions(geoJsonStr: string): Region[];
+    /** Download `regions` as GeoJSON, named after the image last plotted. */
     exportRegions(regions: Region[]): void;
     getGeoJsonString(regions: Region[]): string;
+    /** Hold a large region set as a tiled region source (see RegionStore.attachRegionSource). */
+    attachRegionSource(source: RegionSource | RegionSourceOpener, slices?: RegionSourceSlices): void;
+    importRegionSource(geoJsonStr: string): Promise<boolean>;
+    dropRegionSource(): Promise<void>;
+    getRegionSourceView$(): Observable<RegionSourceView | null>;
+    getRegionSourceIndex(query: Omit<RegionIndexQuery, 'exclude'>): Promise<RegionIndexPage>;
+    selectSourceFeatures(ids: readonly string[], additive?: boolean): Promise<number[]>;
+    deleteSourceFeatures(ids: readonly string[]): void;
+    getRegionStyle$(): Observable<RegionStyle>;
+    setRegionStyle(patch: Partial<RegionStyle>): void;
+    /** Whether a napari volume (or isosurface) view is on screen: regions can be shown in 3D. */
+    getVolumeView$(): Observable<boolean>;
+    /** Whether the volume view's slice pane is wanted (it shows while a volume view is on screen). */
+    getSliceEditor$(): Observable<boolean>;
+    /** Whether the volume view draws the region reconstructions through the volume. */
+    getRegionsThroughVolume$(): Observable<boolean>;
+    /**
+     * Draw the region reconstructions through the volume (it hides none of them: surfaces inside its
+     * bright structures, an OCT's layer boundaries) or hidden behind what it shows (the default).
+     */
+    setRegionsThroughVolume(through: boolean): void;
+    /** The class groups shown in 3D on this image ([] after a switch to another image). */
+    getRegionClasses3d$(): Observable<ReadonlyArray<{
+        key: string;
+        classes: readonly string[];
+    }>>;
+    /** Hide every region surface and forget them (a build still running is dropped). */
+    private clearRegionClasses3d;
+    /** Highlight the surfaces of these group keys in the volume view (none: all as usual). */
+    highlightRegionClasses3d(keys: readonly string[]): void;
+    /** A surface clicked in the volume view with the selection tool (its group key), or none (null). */
+    getRegionPicked3d$(): Observable<{
+        key: string | null;
+        additive: boolean;
+    }>;
+    /**
+     * Show these groups of classes in the volume view as 3D reconstructions (each group one surface
+     * in its colour: an atlas structure with its substructures), and only these; [] hides them.
+     * Reconstructed from every slice's outlines at the volume's resolution, cached per image.
+     */
+    showRegionClasses3d(groups: ReadonlyArray<{
+        key: string;
+        classes: readonly string[];
+        color: string;
+        label?: string;
+    }>): Promise<void>;
+    /**
+     * The regions changed: when the live slice's regions of some classes did (an edit, an undo, not
+     * a slice or image switch), their reconstructions are stale. They are dropped, and those shown
+     * in 3D are rebuilt once the edits pause.
+     */
+    private onRegionsChanged;
+    /** Fingerprint the live slice's classes, unless already: what the next edit is compared with. */
+    private trackLiveClasses;
+    /** Which slice of which image the live regions are. */
+    private liveSliceKey;
+    /** Each class's volume over the whole stack, in px² × slices (see RegionStore.classVolumes). */
+    getClassVolumes(classes: readonly string[]): Promise<Record<string, number>>;
+    getRegionSourceClassCounts(stack?: boolean): Promise<Record<string, number>>;
+    getHiddenClasses$(): Observable<ReadonlySet<string>>;
+    setClassesHidden(classes: readonly string[], hidden: boolean): void;
+    selectRegionClasses(classes: readonly string[], additive?: boolean): Promise<void>;
+    getGeoJsonStringWithSource(regions: Region[], slice?: number): Promise<string>;
     enterStackMode(slices: Map<number, Region[]>, initialZ?: number, saveLayout?: 'combined' | 'per-slice-file'): void;
     exitStackMode(): void;
     isStackMode(): boolean;
+    /** The slice the regions are shown for (recorded outside stack mode too). */
+    getDisplaySlice(): number;
     getStackSaveLayout(): 'combined' | 'per-slice-file';
     setDisplaySlice(z: number): void;
     getSliceRegions(): Region[];
@@ -170,26 +354,32 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     setAnnotationRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean, fillColor?: string): void;
     getSelectedRegions$(): Observable<Region[]>;
     setSelectedRegions(regions: Region[]): void;
-    setWandMode(active: boolean, options?: any): void;
-    setWandOptions(options: any): void;
+    setActiveTool(id: string | null, options?: CanvasToolOptions): void;
+    /** @deprecated Use {@link setActiveTool}. */
+    setWandMode(active: boolean, options?: IWandOptions): void;
+    setWandOptions(options: IWandOptions): void;
     clearActiveWandRegion(): void;
-    setBrushMode(active: boolean, options?: any): void;
-    setBrushOptions(options: any): void;
+    /** @deprecated Use {@link setActiveTool}. */
+    setBrushMode(active: boolean, options?: IBrushOptions): void;
+    setBrushOptions(options: IBrushOptions): void;
+    /** @deprecated Use {@link setActiveTool}. */
     setVertexEraserMode(active: boolean): void;
     setVertexEraserRadius(radius: number): void;
+    /** @deprecated Use {@link setActiveTool}. */
     setZoomToBoxMode(active: boolean): void;
     segmentRectangles(): Promise<number>;
     segmentRectanglesCellpose(): Promise<number>;
     setSamModel(id: string): void;
+    /** @deprecated Use {@link setActiveTool}. */
     setSamPointMode(active: boolean): void;
     commitSamPoints(): void;
     clearSamPoints(): void;
-    getColormap(): Observable<any>;
-    setColormap(colormap: any): void;
-    getColormapOptions(): any;
+    getColormap(): Observable<ColormapNode | null>;
+    setColormap(colormap: ColormapNode): void;
+    getColormapOptions(): ColormapNode[];
     getReverseScale(): Observable<boolean>;
-    setReverseScale(reverscale: any): void;
-    setImageMeta(imageMeta: IImageMetadata[]): void;
+    setReverseScale(reverse: boolean): void;
+    setImageMeta(imageMeta: IImageMetadata[], imageKey?: string): void;
     getImageMeta(): Observable<IImageMetadata[]>;
     getHistogram(channelIndex: number, bins: number): IHistogram | null;
     getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null>;
@@ -207,65 +397,64 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     getInvert$(): Observable<boolean>;
     setInvert(on: boolean): void;
     /**
-     * The active backend's region overlay. Falls back to Plotly's when the active backend
+     * The active backend's region overlay (the slice pane's while the volume view is split). Falls
+     * back to Plotly's when the active backend
      * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a
      * usable overlay.
      */
     getRegionOverlay(): IRegionOverlay;
-    /**
-     * Isosurface controls when available — always Plotly's, since the isosurface
-     * plot type renders on Plotly (OSD only handles the image type).
-     */
+    /** Isosurface controls of the backend on screen, when it renders isosurfaces. */
     getIsosurfaceControls(): IIsosurfaceControls | null;
-    /** 3D scene controls — always Plotly's, since the 3D plot types render on
-     *  Plotly (OSD only handles the image type). */
+    /** 3D scene controls of the backend on screen (Plotly or napari-js), or null on a
+     *  2D-only one. */
     getSurface3dControls(): ISurface3dControls | null;
-    /** Intensity (line-ROI) controls — always Plotly's, since the line profiles
-     *  render their inset on Plotly regardless of which backend draws the image. */
+    /** 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(): IIntensityControls | null;
     /**
-     * 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(): ISpatialControls | 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.
-     */
-    private canColorBy;
-    /** Memoised so consumers can hold the object across calls. */
-    private spatialControls;
-    /** Latest dataset, mirrored so `selectFromRegions()` can answer synchronously
-     *  — it runs from a button click and must not await a round-trip. */
-    private currentSpatialDataset;
+    /** Created on first use; owns the dataset subscription. */
+    private spatialFacade;
     /** 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. */
     private currentZIndex;
-    private spatialDatasetSub;
-    /** 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. */
+    /** 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(): void;
+    /**
+     * 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.
+     */
+    getIntensitySampling(): IIntensitySampling;
+    private readonly intensitySampling;
+    /** @deprecated Use `getIntensitySampling().ensureIntensitySampling()`. */
     ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void>;
-    /** 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). */
+    private pointSamplingAtPlot;
+    /** @deprecated Use `getIntensitySampling().getViewportChange$()`. */
     getViewportChange$(): Observable<{
         x: number;
         y: number;
         width: number;
         height: number;
     }>;
-    /** 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: number, y: number, width: number, height: number, zIndex: number): void;
+    /** 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(): void;
+    /** @deprecated Use {@link detach}. */
     unsubscribe(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RoutingVisualizerService, [null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoutingVisualizerService, [null, null, null, null, null, null, null, null, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<RoutingVisualizerService>;
 }