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

package/lib/visualizer.component.d.ts

@@ -1,25 +1,45 @@
-import { ChangeDetectorRef, AfterViewInit, ElementRef, EventEmitter, Injector, NgZone, OnChanges, OnDestroy, OnInit, SimpleChanges, Type } from '@angular/core';
-import { Subscription } from 'rxjs';
-import { MenuItem, MessageService, TreeNode } from 'primeng/api';
+import { AfterViewInit, ChangeDetectorRef, DestroyRef, ElementRef, EventEmitter, Injector, NgZone, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { MenuItem, MessageService } from 'primeng/api';
 import { ContextMenu } from 'primeng/contextmenu';
 import { IImageInfo } from './contracts/image.contract';
 import { ImageStatePort } from './contracts/ports/image-state.port';
 import { Polygon } from './models/region';
 import { RegionOpsService } from './region-ops.service';
 import { VisualizerStore } from './store/visualizer-store.service';
+import { ImageRenderSession } from './render-session';
 import { PlotType, PlotTypeDescriptor, PlotTypeId } from './contracts/plot-type';
 import { PlotTypeContribution, PlotTypeOption } from './contracts/plot-type-contribution.contract';
 import { PlotModeController } from './plot-mode/plot-mode-controller';
+import { ToolParamsModel } from './plot-mode/tool-params-model';
+import { ContributionHost, PlotModePanelView, ToolDialogView } from './plot-mode/contribution-host';
 import { IVisualizer } from './contracts/visualizer.contract';
 import { SamToolService } from './toolbar/segmentation/sam-tool.service';
 import { SamPointToolService } from './toolbar/segmentation/sam-point-tool.service';
 import { CellSegmentToolService } from './toolbar/segmentation/cell-segment-tool.service';
-import { NumberParamSpec, SelectParamSpec, ToolParamSpec, ToolbarContribution, ToolbarDialogToolContribution, ToolbarToolContribution } from './contracts/toolbar-tool.contract';
+import { SegmentationRunner } from './toolbar/segmentation/segmentation-runner';
+import { ToolbarContribution, ToolbarDialogToolContribution, ToolbarToolContribution } from './contracts/toolbar-tool.contract';
 import { ToolbarToolVisibility } from './contracts/toolbar-config';
 import { VizConfig } from './contracts/viz-config';
 import { SpatialDataPort } from './contracts/ports/spatial-data.port';
+import { ContextMenuActions } from './visualizer/visualizer-context-menu';
+import { RegionActions } from './visualizer/region-actions';
+import { ToolModes } from './visualizer/tool-modes';
+import { FloatingPos } from './visualizer/floating-drag.directive';
+import { IntensityInsetComponent } from './intensity-inset/intensity-inset.component';
+import { SpatialDatasetBinder } from './visualizer/spatial-dataset-binder';
 import * as i0 from "@angular/core";
-export declare class VisualizerComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {
+/**
+ * The viewer (`<visualizer>`): the plot surface, its toolbar, the loading overlay and
+ * the dialogs it opens (Channels & Histogram, spatial-omics controls, Region Editor,
+ * contributed modes and tools). It orchestrates rendering through the `VISUALIZER`
+ * contract and reads the image from the host's `IMAGE_STATE_PORT`.
+ *
+ * OnPush. Template events re-render it; state that lands asynchronously goes through
+ * {@link changed} (or a signal: the loading overlay), and the collaborators that must
+ * render synchronously (the render session's overlay, a contributed panel's slot, the
+ * context menu before it opens) still call `detectChanges()`.
+ */
+export declare class VisualizerComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy, ContextMenuActions {
     private state;
     plotService: IVisualizer;
     messageService: MessageService;
@@ -33,6 +53,8 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
     private vizConfig?;
     private spatialData?;
     private injector?;
+    private hostRef?;
+    private readonly destroyRef;
     /** Per-instance toast key. MessageService is a global singleton, so two live
      *  `<visualizer>` instances (main viewer + pipeline-dialog preview) sharing
      *  one key would each render the same message — a duplicate toast. A unique
@@ -51,8 +73,8 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
      * releases on destroy, so the surviving viewer picks them up.
      */
     private static readonly liveInstances;
-    readonly vizToastKey = "sci-viz-notice";
-    readonly vizAlertToastKey = "sci-viz-alert";
+    protected readonly vizToastKey = "sci-viz-notice";
+    protected readonly vizAlertToastKey = "sci-viz-alert";
     /**
      * Whether this instance renders the shared outlets. The owner is simply the
      * oldest live visualizer — a `Set` iterates in insertion order, so when the
@@ -62,8 +84,10 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
      * initialised would leave nobody rendering the outlets, and every notice from
      * the root service would silently vanish again.
      */
-    get ownsSharedToasts(): boolean;
+    protected get ownsSharedToasts(): boolean;
+    /** Each new image: whether it is a z-stack. */
     isStackEvent: EventEmitter<any>;
+    /** Each new image: whether it is single-channel (grayscale). */
     isGrayscaleEvent: EventEmitter<any>;
     /** Which toolbar groups to show. A partial override merges over the full set,
      *  so `{ specialTools: false }` hides only that group. Defaults to everything. */
@@ -76,327 +100,175 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
     testMode: boolean;
     /** Image-smoothing state for the toolbar's Smoothen toggle (OSD only).
      *  Defaults to `false` so OSD shows raw pixels (nearest-neighbour). */
-    imageSmoothingEnabled: boolean;
-    loadingMessage: string;
-    zoom: boolean;
+    protected imageSmoothingEnabled: boolean;
     fileName: string | undefined;
     private loadedFileName;
-    imageInfo: IImageInfo | undefined;
-    private unsub;
-    private previewSubscription;
-    stackLoading: boolean;
-    imgLoading: boolean;
-    loadingPercentage: number;
-    cacheProgress: number | null;
-    sharpening: boolean;
+    protected imageInfo: IImageInfo | undefined;
+    protected readonly loadingMessage: import("@angular/core").WritableSignal<string>;
+    /** The host is loading at zoom (the overlay message moves out of the way). */
+    protected readonly zoom: import("@angular/core").WritableSignal<boolean>;
+    protected readonly stackLoading: import("@angular/core").WritableSignal<boolean>;
+    protected readonly imgLoading: import("@angular/core").WritableSignal<boolean>;
+    protected readonly loadingPercentage: import("@angular/core").WritableSignal<number>;
+    protected readonly cacheProgress: import("@angular/core").WritableSignal<number | null>;
     /** A jit-service cache copy is actively in progress (determinate 0..99). Drives the cache
      *  progress bar independently of `imgLoading` so the bar can't be dropped — or masked by the
      *  "Sharpening preview..." overlay — mid-download if the loading flag flips early. */
-    get isCaching(): boolean;
-    private running;
-    /**
-     * Monotonic render generation. Bumped when a render starts, so a render that
-     * has been superseded by a newer image can be recognised and made inert: its
-     * callbacks return early instead of painting, clearing `running`, releasing
-     * the newer render's overlay, or applying its ROIs.
-     */
-    private renderToken;
-    /** Set once the template, and with it the plot div, exists (see ngAfterViewInit). */
-    private viewReady;
-    /** An image-less dataset whose draw waits for the view: see plotSpatialWithoutImage. */
-    private pendingSpatialDraw;
-    zIndex: number;
-    maxIndex: number;
+    protected readonly isCaching: import("@angular/core").Signal<boolean>;
+    /** Emits once when this view is destroyed; the collaborators end their subscriptions on it. */
+    private readonly destroyed$;
+    /** Host image-info objects whose one-shot `initialZIndex` was already applied. */
+    private readonly consumedSliceHints;
+    protected zIndex: number;
+    protected maxIndex: number;
     contextMenu: ContextMenu;
-    contextMenuItems: MenuItem[];
-    activeDragMode: string | null;
-    /** Whether a region action is available to undo (jit-ui#85). Mirrors the
-     *  shared RegionStore's history depth; drives the toolbar Undo button. */
-    canUndoRegion: boolean;
-    /** Whether an undone region action is available to redo (jit-ui#85). */
-    canRedoRegion: boolean;
-    /** Custom-threshold Simplify dialog (jit-ui#85). */
-    displaySimplifyDialog: boolean;
-    simplifyThreshold: number;
-    /** Current region selection (array indices) — mirrored from the store so the
-     *  context-menu region actions can read it synchronously (jit-ui#85). */
-    private selectedIndices;
-    /** Wand sensitivity — higher = stricter (smaller selection). Matches QuPath default. */
-    wandSensitivity: number;
-    /** Brush diameter in image-pixel coordinates (drives the painted disc size). */
-    brushSize: number;
-    /** Class the brush paints while a plot mode armed it (PlotModeTools.armBrush); null = plain brush. */
-    private brushClass;
+    protected contextMenuItems: MenuItem[];
+    /** The armed tool mode and the toolbar's tool settings. */
+    protected readonly tools: ToolModes;
+    protected get activeDragMode(): string | null;
+    protected set activeDragMode(mode: string | null);
+    protected get wandSensitivity(): number;
+    protected set wandSensitivity(v: number);
+    protected get brushSize(): number;
+    protected get vertexEraserRadius(): number;
+    protected set vertexEraserRadius(v: number);
+    /** Region set-operations on the selection, and the store mirrors they read (jit-ui#85). */
+    protected readonly regionActions: RegionActions;
+    /** Custom-threshold Simplify dialog visibility (see {@link RegionActions}). */
+    protected get displaySimplifyDialog(): boolean;
+    protected set displaySimplifyDialog(v: boolean);
     /** SAM model picker options + current selection (jit-ui#90 P1). Only models
      *  with a hosted ONNX pair (configured via setSamModelUrls at app init) are
      *  offered, so the picker can't select a model that can't run. */
-    samModels: {
+    protected samModels: {
         id: string;
         label: string;
     }[];
-    samModelId: string;
+    protected samModelId: string;
     /**
      * No-prompt tools registered through {@link TOOLBAR_TOOLS}, filtered to those
      * with configured models and sorted. This library registers none — a host
      * supplies them — so an open build has an empty array here and the toolbar
      * and help dialog simply omit that group.
      */
-    contributedTools: ToolbarToolContribution[];
-    /**
-     * Dialog tools registered through {@link TOOLBAR_TOOLS} (`kind: 'dialog'`),
-     * sorted. Their buttons sit with the host's own actions and show in the Image
-     * view only; each opens a floating dialog the tool fills.
-     */
-    dialogTools: ToolbarDialogToolContribution[];
+    protected contributedTools: ToolbarToolContribution[];
+    /** Checkpoints and parameter values of {@link contributedTools}, and their dialog. */
+    protected readonly toolParams: ToolParamsModel;
+    /** Contributed plot modes and dialog tools, and their live sessions. */
+    readonly contributions: ContributionHost;
+    /** Dialog tools registered through {@link TOOLBAR_TOOLS} (`kind: 'dialog'`). */
+    protected get dialogTools(): ToolbarDialogToolContribution[];
     /** The dialog tool the user has open (its session may be between renders). */
-    openDialogToolId: string | null;
+    protected get openDialogToolId(): string | null;
     /** The open dialog tool's live dialog, as the template renders it. */
-    toolDialog: {
-        title: string;
-        width: string;
-        host: HTMLElement;
-    } | null;
-    /** Dialog-tool sessions: the same lifecycle and isolation as contributed plot modes. */
-    private readonly toolDialogs;
-    /** Active checkpoint per contributed tool. */
-    toolModelIds: Record<string, string>;
+    protected get toolDialog(): ToolDialogView | null;
+    protected readonly samToastKey: string;
     /**
-     * Parameter values per contributed tool, seeded from each tool's own defaults
-     * — which encode the scale and crowding its checkpoint was trained for.
+     * Outlet for the library's own result/error notices, keyed to this instance so they
+     * do not depend on the host mounting a keyless `<p-toast>` (most hosts don't, and a
+     * failed segmentation then looked like a dead button). Deliberately NOT the sticky
+     * toast's key: that is cleared when a run settles, which would wipe the result.
      */
-    toolParams: Record<string, Record<string, unknown>>;
-    /** Which tool's parameter dialog is open, or null. */
-    openParamsToolId: string | null;
-    /** SAM download/segment toast state (bound by the `sam` p-toast template). */
-    samStatus: string;
-    samProgress: number;
-    samDownloading: boolean;
-    samBusy: boolean;
-    /** Whether the shared `sam` toast is currently shown (avoids stacking it on
-     *  every point click, which re-runs inference). */
-    private samToastShown;
-    readonly samToastKey: string;
-    /**
-     * Outlet for the library's own result/error notices.
-     *
-     * PrimeNG routes a message to a `<p-toast>` only when the keys match — a
-     * keyless message reaches a keyless toast and nothing else. These notices used
-     * to be emitted with no key, so they rendered only in hosts that happen to
-     * mount a bare `<p-toast>` (jit-ui does, in its file-tree component). Every
-     * other host — including this repo's own browser example — dropped them
-     * silently, which made a failed or no-op segmentation look like a dead button:
-     * the sticky progress toast is cleared in the same tick by hideSamToast, and
-     * the message explaining why never appeared anywhere.
-     *
-     * Keyed to this component instance so the library renders its own outlet and
-     * is not dependent on host markup. Deliberately NOT the sticky toast's key:
-     * {@link hideSamToast} clears that key in the `finally`, which would wipe the
-     * result the moment it was posted, and the sticky toast's custom template is
-     * built for the live status + progress bar.
-     */
-    readonly resultToastKey: string;
-    /** Subscriptions to the point tool's live feeds (status/busy/download). */
-    private samPointSub;
-    /** Vertex eraser radius in image-pixel coordinates. */
-    vertexEraserRadius: number;
-    colormapsOptions: any;
-    reversescale: boolean;
-    selectedColormap: any;
+    protected readonly resultToastKey: string;
+    /** Segmentation runs and their sticky progress toast. */
+    protected readonly segmentation: SegmentationRunner;
     /** Channels & Histogram dialog visibility (opened from the toolbar). */
-    showChannelHistogram: boolean;
+    protected showChannelHistogram: boolean;
     /** Spatial-omics controls dialog visibility (toolbar button). */
-    showSpatialControls: boolean;
+    protected showSpatialControls: boolean;
     /** Region Editor dialog visibility (opened from the toolbar). */
-    showRegionEditor: boolean;
+    protected showRegionEditor: boolean;
     /** Region Editor dialog width. On open it is set to the configured host
      *  element's current width, or — when no selector is configured / the element
      *  isn't found — to a quarter of the page (see openRegionEditor). */
-    regionEditorWidth: string;
-    stackOptions: {
-        name: string;
-        val: string;
-    }[];
-    selectedStackOption: {
-        name: string;
-        val: string;
-    } | undefined;
-    readonly plotDivName: string;
+    protected regionEditorWidth: string;
+    protected readonly plotDivName: string;
+    /** The render pipeline: the newest image (or image-less dataset) always wins. */
+    protected readonly render: ImageRenderSession;
     plotType: PlotType;
-    isHeatmap: boolean;
-    activeSurface3dMode: string;
+    protected isHeatmap: boolean;
+    protected activeSurface3dMode: string;
     /** Whether the napari 3D coordinate-axes / scale gizmo is shown (volume/isosurface). */
-    axesVisible: boolean;
-    wireframeActive: boolean;
+    protected axesVisible: boolean;
+    protected wireframeActive: boolean;
     /** napari 3D decimate factor (1 = Full … 8 = ⅛; default ½); changing it re-plots. */
-    resolutionScale: number;
+    protected resolutionScale: number;
     /** The selector's entries: the built-in plot types the active backend
      *  advertises (3D gated by capability), then any contributed modes
      *  ({@link PLOT_TYPE_CONTRIBUTIONS}). */
-    plotTypeMenu: PlotTypeOption[];
+    protected plotTypeMenu: PlotTypeOption[];
     /**
      * The built-in plot types on offer — {@link plotTypeMenu} without contributed
      * modes. Kept with its original type so existing readers are unaffected.
      */
-    plotTypeOptions: PlotTypeDescriptor[];
+    protected plotTypeOptions: PlotTypeDescriptor[];
     /**
      * What the selector shows: a built-in type or a contributed mode's id. Every
      * rendering and tool decision goes through {@link basePlotType} instead, so a
      * contributed mode behaves exactly like the built-in type it rides on.
      */
-    selectedPlotTypeId: PlotTypeId;
+    protected selectedPlotTypeId: PlotTypeId;
     /**
      * The built-in plot type being rendered. With no contributed mode active this
      * is the selection itself; during one it is the mode's `baseType`. Kept with its
      * original `PlotType` type for existing readers — use {@link selectedPlotTypeId}
      * for the selector's id. Assigning selects that built-in type.
      */
-    get selectedPlotType(): PlotType;
-    set selectedPlotType(type: PlotType);
+    protected get selectedPlotType(): PlotType;
+    protected set selectedPlotType(type: PlotType);
     /** Contributed plot modes and their single live session. */
-    readonly plotModes: PlotModeController;
-    /**
-     * The live contributed mode's side panel, as the template renders it: an
-     * Angular component with its own injector, or a plain host element a `mount`
-     * panel rendered into. Null while no contributed session is live.
-     */
-    plotModePanel: {
-        title: string;
-        component: Type<unknown> | null;
-        injector: Injector | null;
-        host: HTMLElement | null;
-    } | null;
-    private destroying;
+    get plotModes(): PlotModeController;
+    /** The live contributed mode's side panel; null while no contributed session is live. */
+    protected get plotModePanel(): PlotModePanelView | null;
     /** Where a `mount` panel's host element is attached once the dialog renders. */
     set plotModePanelSlot(ref: ElementRef<HTMLElement> | undefined);
     /** The built-in type actually rendered for {@link selectedPlotTypeId}: itself
      *  for a built-in type, `baseType` for a contributed mode. */
-    get basePlotType(): PlotType;
-    /** Floating intensity-profile inset (LINE mode). */
-    readonly intensityInsetDiv = "intensity-inset-plot";
-    profilePanelPos: {
-        x: number;
-        y: number;
-    };
-    private profilePanelDragging;
-    private profilePanelStart;
+    protected get basePlotType(): PlotType;
+    /** Div the floating intensity-profile inset is charted into. Per instance, like
+     *  {@link plotDivName}: the backend resolves it by id, so a fixed id made two live
+     *  viewers draw both insets into whichever div came first in the document. */
+    protected readonly intensityInsetDiv: string;
     /** Toolbar docking: docked across the top by default; dragging its handle
      *  detaches it into a floating, movable window (frees the top row for the
      *  visualization). */
-    toolbarFloating: boolean;
-    toolbarPos: {
+    protected toolbarFloating: boolean;
+    protected toolbarPos: {
         x: number;
         y: number;
     };
-    private toolbarDragging;
-    private toolbarStart;
-    private latestProfiles;
-    /** Drives the intensity inset panel's visibility — true whenever any
-     *  intensity-profile line exists (independent of the current plot type). */
-    hasProfiles: boolean;
-    private intensityProfileSub?;
-    private viewportChangeSub?;
-    private profileDragMoveListener?;
-    private profileDragUpListener?;
-    private profileResizeListener?;
+    /** Where a toolbar-handle drag starts from: grabbing the docked toolbar floats it. */
+    protected readonly toolbarDragOrigin: () => FloatingPos;
+    /** The floating intensity-profile inset (always mounted; shows itself while lines exist). */
+    inset?: IntensityInsetComponent;
     /** True while the 3D spatial cloud is the active mode. The controls drop the ROI
      *  selection there: region tools are screen-space, and against an orbiting
      *  camera a drawn rectangle has no fixed meaning in the data. */
-    get isSpatial3dMode(): boolean;
-    /** LINE plot type shows the image + draggable line ROI + intensity inset. */
-    get isProfileMode(): boolean;
+    protected get isSpatial3dMode(): boolean;
     /** True for the Image plot type, which renders as a natively pan/zoom-able
      *  raster — so the backend-agnostic zoom/pan toolbar tools are hidden. The
      *  component drives this off the plot type, not the active backend. */
-    get isImageView(): boolean;
+    protected get isImageView(): boolean;
     /** Isosurface band as a 0–255 slider position, mapped onto the volume's real
      *  intensity range by the renderer. Defaults to the full range. */
-    isoRange: number[];
-    /** Whether a spatial-omics dataset is currently published on
-     *  `SPATIAL_DATA_PORT` — gates the spatial plot types in the selector. */
-    /** Bound by the toolbar, which offers the plot modes for a dataset with no image too. */
-    hasSpatialDataset: boolean;
-    /** The spatial dataset on offer, for drawing one that brings no image (see reloadAndPlot). */
-    private spatialDataset;
-    /** Whether that dataset's observations carry a z, gating the 3D spatial mode. */
-    private hasSpatial3dDataset;
-    /** Whether it carries a registered volume. Change detection only: a volume
-     *  appearing is what publishes it as the image, and the plot-type gates then
-     *  see an ordinary grayscale stack. */
-    private hasSpatialVolume;
-    /** Dataset identity + capability shape the last emission was handled at, so a
-     *  switch between two datasets of the same shape is not mistaken for a repeat. */
-    private spatialDatasetKey;
-    /** Dataset + geometry the currently published volume image was built from, so a
-     *  re-emitted dataset doesn't re-fetch megabytes or reset the user's scrub. */
-    private volumeImageKey;
-    /** Blob URLs backing that image — ours to revoke. */
-    private volumeImageUrls;
-    private spatialDatasetSubscription?;
-    plotWidthSubscription?: Subscription;
-    imageLoadingSubscription?: Subscription;
-    imgLoadingMessageSubscription?: Subscription;
-    isZoomSubscription?: Subscription;
-    filenameSubscription?: Subscription;
-    autoscaleSubscription?: Subscription;
-    private plotContextMenuListener?;
-    private keydownListener?;
-    private wheelListener?;
+    protected isoRange: number[];
+    /** The spatial-omics dataset on offer and the gates it puts on the selector. */
+    protected readonly spatial: SpatialDatasetBinder;
+    /** Whether a spatial-omics dataset is published on `SPATIAL_DATA_PORT` — gates the
+     *  spatial plot types; the toolbar offers the plot modes for an image-less one too. */
+    protected get hasSpatialDataset(): boolean;
+    /** Keyboard, wheel and context-menu handling; created once the view exists. */
+    private shortcuts?;
     /** Debounced z-slice scrubbing (see SliceScrubber — refactoring plan Step 7). */
     private readonly scrubber;
-    constructor(state: ImageStatePort, plotService: IVisualizer, messageService: MessageService, ngZone: NgZone, cdr: ChangeDetectorRef, session: VisualizerStore, samTool: SamToolService, cellSegmentTool: CellSegmentToolService, samPointTool: SamPointToolService, regionOps: RegionOpsService, vizConfig?: VizConfig | undefined, toolContributions?: readonly ToolbarContribution[], spatialData?: SpatialDataPort | undefined, plotTypeContributions?: readonly PlotTypeContribution[], injector?: Injector | undefined);
-    /**
-     * Plot types offered in the selector for the current image:
-     *  - Outside **test mode**, only the curated default set (descriptors with a
-     *    `productionLabel`) is offered, shown under suffix-free names — Image,
-     *    Heatmap, Contour and the napari Surface / Volume / Isosurface. Test mode
-     *    exposes every backend's type under its full (backend-suffixed) label.
-     *  - 3D types hidden when the backend can't render a 3D scene.
-     *  - stack-only types (volume, isosurface) hidden unless the file is a stack —
-     *    a volume needs multiple z-slices.
-     *  - scalar-intensity types (contour, surface, isosurface) hidden for RGB
-     *    images — they map a single intensity per pixel. Image and Heatmap render
-     *    any image.
-     *  - spatial-omics types hidden until a `SpatialDataset` is published on
-     *    `SPATIAL_DATA_PORT` — the mode has nothing to draw without observations,
-     *    exactly as a volume has nothing to draw without a stack.
-     */
-    /**
-     * Track whether a spatial-omics dataset is available. A dataset appearing (or
-     * being cleared) changes which plot types make sense, so it drives the same
-     * recompute + reconcile that the image stream and the test-mode toggle do.
-     *
-     * No-op when the host provides no `SPATIAL_DATA_PORT` — the spatial types then
-     * stay hidden for the life of the component.
-     */
+    constructor(state: ImageStatePort, plotService: IVisualizer, messageService: MessageService, ngZone: NgZone, cdr: ChangeDetectorRef, session: VisualizerStore, samTool: SamToolService, cellSegmentTool: CellSegmentToolService, samPointTool: SamPointToolService, regionOps: RegionOpsService, vizConfig?: VizConfig | undefined, toolContributions?: readonly ToolbarContribution[], spatialData?: SpatialDataPort | undefined, plotTypeContributions?: readonly PlotTypeContribution[], injector?: Injector | undefined, hostRef?: ElementRef<HTMLElement> | undefined, destroyRef?: DestroyRef);
+    /** Follow the spatial-omics dataset: a dataset appearing, switching or being cleared
+     *  re-gates the selector exactly as the image stream and the test-mode toggle do. */
     private watchSpatialDataset;
-    /**
-     * Publish a dataset's reference volume AS the image, and open the 2D Image view
-     * on it.
-     *
-     * The volume is a 3D image delivered in one file, so for a dataset that has no
-     * section image it is the honest thing to put on screen: the slice bar scrubs z,
-     * and the contrast window, colormaps and region tools all work because the
-     * volume genuinely is the image now. The 3D cloud stays one menu pick away.
-     *
-     * Keyed by dataset + geometry: the dataset stream re-emits on things like a
-     * colour-column change, and rebuilding then would re-fetch the voxels and throw
-     * the user back to the middle slice.
-     */
-    private showVolumeAsImage;
-    /** Forget the published volume image so re-selecting the dataset rebuilds it.
-     *  The URLs deliberately stay alive: the host may still be displaying that image
-     *  at this instant, and revoking under it would break every later tile read. They
-     *  are freed when the next volume replaces them, or on destroy. */
-    private dropVolumeImage;
-    private revokeVolumeImageUrls;
+    /** Recompute the selector's entries for the current image, dataset and test mode
+     *  (see {@link computePlotTypeMenu}). */
     private computePlotTypeOptions;
     ngOnChanges(changes: SimpleChanges): void;
-    /** If the active plot type is no longer in the offered options (e.g. test mode
-     *  turned off while a test-only type was active, or a scalar type carried onto
-     *  an RGB image), fall back to the default 2D Image view. */
-    /** Whether the live spatial dataset brings pixels of its own — a tissue image it
-     *  registers onto, or a volume that is published as a z-stack image. */
-    private spatialDatasetHasPixels;
     /**
      * The host published NO image — a spatial dataset that brings none does this.
      *
@@ -405,216 +277,145 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
      * `isStack`/`isGrayscale` decision is made against a file that is no longer loaded.
      */
     private onImageCleared;
+    /** If the active plot type is no longer in the offered options (e.g. test mode
+     *  turned off while a test-only type was active, or a scalar type carried onto
+     *  an RGB image), fall back to the default 2D Image view. */
     private reconcileSelectedPlotType;
     ngOnInit(): void;
+    /**
+     * Follow `source` until destroy. Host streams can emit outside the Angular zone (a
+     * serverless host clears its loading flag from an image decode or an OpenSeadragon
+     * callback); setting a signal there marks this OnPush view but schedules no change
+     * detection, so the update is applied inside the zone, as {@link changed} does.
+     */
+    private mirror;
+    /**
+     * State this view shows changed outside one of its template events (a stream, a
+     * resolved promise, a host call): mark the OnPush view for check, re-entering the
+     * zone when it changed outside it so a change-detection pass follows.
+     */
+    private changed;
+    /**
+     * Lay a new image out once the old view is gone: the stack flag, the slice bounds (one
+     * url per slice, so the last index is length-1), and the one-shot `initialZIndex` hint
+     * (e.g. the file the user clicked within a numbered series). The hint is consumed so
+     * re-delivering the same info (a plot-type switch, reloadAndPlot) does not reset the
+     * user's scrub; the host's object is never written to (a host store may freeze it) —
+     * the component keeps a copy without the hint, and remembers the host object.
+     */
+    private layOutSlices;
     ngAfterViewInit(): void;
     /** The plot div exists now: run an image-less draw that arrived before it did. */
     private onViewReady;
-    onProfilePanelDragStart(e: MouseEvent): void;
-    /** Grab the toolbar handle: detach it into a floating window (if still docked)
-     *  and start dragging. */
-    onToolbarDragStart(e: MouseEvent): void;
+    /** What the keyboard, wheel and context-menu shortcuts act on. Their listeners live
+     *  outside this view, so every action that changes what it shows marks it for check. */
+    private shortcutHost;
     /** Snap the floating toolbar back to its docked position across the top. */
-    dockToolbar(): void;
-    /** Render the intensity inset chart from the latest profile data. The actual
-     *  charting is owned by the visualizer service — the component just decides
-     *  when (profile mode + a fresh profile). */
-    private renderIntensityInset;
+    protected dockToolbar(): void;
     /** Toolbar "Intensity" group: add another line ROI (next bright colour). */
-    addProfileLine(): Promise<void>;
+    protected addProfileLine(): Promise<void>;
     ngOnDestroy(): void;
+    /** What the host gets through `setDiagram` — see {@link VisualizerHandle}. */
+    private readonly hostHandle;
     hasRegions(): boolean;
-    /**
-     * This method is called in mainFacade.configRequest() - DO NOT DELETE
-     */
+    /** The current regions as polygons (also on the host handle). */
     getRegionPolygons(): Polygon[];
-    /**
-     * Select the color scale type: called by the color scale select button
-     * @param event
-     */
-    toggleReverseScale(): void;
-    /**
-     * Select a color map: called by the color map dropdown button
-     * @param colormapNode
-     */
-    selectColormap(colormapNode: TreeNode): void;
     /** Open the Channels & Histogram dialog (toolbar button). */
-    openChannelHistogram(): void;
+    protected openChannelHistogram(): void;
     /** Toolbar → open the spatial-omics controls. */
-    openSpatialControls(): void;
+    protected openSpatialControls(): void;
     /** Open the Region Editor dialog (toolbar button). The editor stays linked to
      *  this plotting instance through the root RegionStore singleton, so it works
      *  the same as the former right-panel Regions tab. */
-    openRegionEditor(): void;
-    /**
-     * Called by the stack/single image dropdown button
-     * @param showstack
-     */
-    selectStackOption(selectedStackOption: any): void;
-    updateZIndex(urls?: string[]): void;
+    protected openRegionEditor(): void;
+    /** The toolbar's Single image / Stack toggle. */
+    protected selectStackOption(selectedStackOption: {
+        name: string;
+        val: string;
+    }): void;
+    /** Clamp the slice index into [0, maxIndex] and push it to the renderer. */
+    protected updateZIndex(): void;
     /**
      * Live z-slice scrub for the Image view: the renderer swaps the displayed
      * slice in place (no re-mount), so dragging the slider steps through the
      * stack the same way the heatmap frame slider does.
      */
-    onZSlide(z: number | undefined): void;
+    protected onZSlide(z: number | undefined): void;
     /**
      * Live (debounced) scrub while dragging the Image-view z-slider: update the
      * slice as the user drags, but coalesce rapid changes so we don't fire a
      * slice swap on every pixel. The final value also lands via onZSlide (onSlideEnd).
      */
-    onZScrub(z: number | undefined): void;
-    /**
-     * Keyboard stack navigation: ←/→ step the z-slice in the Image view, the same
-     * way the slider does. Only active for a loaded stack in Image view, and
-     * ignored while a form field is focused so typing isn't hijacked. Up/Down are
-     * left to OpenSeadragon (panning).
-     */
-    onKeydown(e: KeyboardEvent): void;
+    protected onZScrub(z: number | undefined): void;
     /** Move the displayed slice by `delta`, clamped to the stack bounds. */
     stepSlice(delta: number): void;
-    reloadAndPlot(): void;
-    /**
-     * Draw a spatial mode with no image behind it: the observations alone, framed on their own
-     * extent, as the seqFISH example shows them. The image info is a placeholder naming the
-     * dataset, so regions drawn here are kept per dataset like any image's.
-     */
-    private plotSpatialWithoutImage;
-    cancelLoading(): void;
-    downloadImage(): void;
+    protected reloadAndPlot(): void;
+    protected cancelLoading(): void;
+    protected downloadImage(): void;
     autoscaleImage(): void;
     /** Toolbar pixel/smooth toggle: flip smoothing and apply to the active backend. */
-    onToggleImageSmoothing(): void;
+    protected onToggleImageSmoothing(): void;
     resetAxes(): void;
     toggleDragMode(mode: string): void;
-    /** Arm `mode` (or nothing) across every tool, keeping the toolbar in step. */
-    private applyDragMode;
-    /** Region draw/select/edit modes routed through the region overlay. The
-     *  The vertex tools (drawpolygon/addpoint/deletepoint/move) are
-     *  handled by the OpenSeadragon overlay; Plotly's overlay maps them to no-op. */
-    private isRegionMode;
     /** Live-update the isosurface as the range slider moves. The control is only
      *  available when the active backend renders isosurfaces (ISOSURFACE mode). */
-    onIsoRangeChange(values: number[] | undefined): void;
-    onWandSensitivityChange(value: number | undefined): void;
-    onBrushSizeChange(value: number | undefined): void;
-    onVertexEraserRadiusChange(value: number | undefined): void;
+    protected onIsoRangeChange(values: number[] | undefined): void;
+    protected onWandSensitivityChange(value: number | undefined): void;
+    protected onBrushSizeChange(value: number | undefined): void;
+    protected onVertexEraserRadiusChange(value: number | undefined): void;
     zoomIn(): void;
     zoomOut(): void;
     deleteRegion(): void;
     /** Undo the most recent region action (jit-ui#85). Up to 10 steps back. */
-    undoRegion(): void;
+    protected undoRegion(): void;
     /** Redo the most recently undone region action (jit-ui#85). */
-    redoRegion(): void;
-    /** The currently-selected regions (live store instances). */
-    private get selectedRegions();
-    /** Regions eligible for set-ops: closed areas (rect / closed polygon /
-     *  multi-polygon), excluding intensity-profile lines. */
-    private opEligible;
-    /** Image pixel dimensions for the raster ops; falls back to the selection's
-     *  extent when the image size isn't known (keeps clamping sane). */
-    private opImageDims;
-    /** True when ≥2 eligible regions are selected (Merge available). */
-    get canMergeRegions(): boolean;
-    /** True when any selected region is multi-part (Ungroup available). */
-    get canUngroupRegions(): boolean;
-    /** True when ≥1 eligible region is selected (Inverse / Simplify available). */
-    get hasEligibleSelection(): boolean;
-    /** Select every region on the image (excludes intensity-profile lines). */
+    protected redoRegion(): void;
     selectAllRegions(): void;
-    /** Merge the selected regions into a single (possibly multi-part) region. */
     mergeRegions(): void;
-    /** Split each selected multi-part region into one region per part. */
     ungroupRegions(): void;
-    /** Replace the selection with its inverse inside the image rectangle. */
     inverseRegions(): void;
-    /** Douglas–Peucker simplify each selected region by `thresholdPx`. */
     simplifyRegions(thresholdPx: number): void;
-    /** Open the custom-threshold simplify dialog. */
     openSimplifyDialog(): void;
-    /**
-     * Commit a set-op: drop the `remove` regions, append `add`, and select the
-     * results. Goes through setRegions so it's undo-tracked and re-rendered;
-     * profile lines and unselected regions are preserved.
-     */
-    private replaceRegions;
     /** Box-prompted SAM segmentation of the drawn rectangles (jit-ui#90). A sticky
      *  `sam` toast shows live status + a download progress bar (first run pulls the
      *  encoder, ~170 MB); it stays open until the run finishes (bar hits 100%). */
-    segmentRegions(): Promise<void>;
+    protected segmentRegions(): Promise<void>;
     /** Auto-segment cells inside each drawn rectangle with cellpose-SAM, client-side
      *  (jit-ui#90). Each box is cropped (browser slide-crop) then run through the
      *  cellpose-js model; the same sticky `sam` toast + progress bar is reused. */
-    segmentCellpose(): Promise<void>;
-    /**
-     * Parameters currently bound by the generic parameter dialog, for whichever
-     * tool is open. Seeded lazily: a tool's defaults are only asked for when the
-     * user first touches it, so registering a tool costs nothing until used.
-     */
+    protected segmentCellpose(): Promise<void>;
     paramsFor(toolId: string): Record<string, unknown>;
-    /** Active checkpoint for a tool, falling back to the tool's own default. */
-    modelIdFor(tool: ToolbarToolContribution): string;
-    /** Switching checkpoint re-seeds the parameters, since the defaults belong to
-     *  the model rather than to the tool. */
-    onToolModelChange(e: {
+    protected onToolModelChange(e: {
         toolId: string;
         modelId: string;
     }): void;
-    /** A tool's defaults for a checkpoint, with that checkpoint's own overrides
-     *  applied on top — per-model defaults beat per-tool ones. */
-    private seedParams;
-    /**
-     * Narrow a param spec for the template.
-     *
-     * `*ngSwitchCase` does not narrow a discriminated union in Angular's template
-     * type checker the way a `switch` does in TypeScript, so the template asks for
-     * the variant it has already matched on.
-     */
-    numberParam(p: ToolParamSpec): NumberParamSpec;
-    selectParam(p: ToolParamSpec): SelectParamSpec;
-    openToolParams(toolId: string): void;
-    /** The tool whose parameter dialog is open, for the generic dialog's header
-     *  and field list. */
-    get openParamsTool(): ToolbarToolContribution | undefined;
-    resetToolParams(toolId: string): void;
+    protected openToolParams(toolId: string): void;
+    protected closeToolParams(): void;
+    protected resetToolParams(toolId: string): void;
     /** Run a contributed tool over the current view. No prompt: these sweep the
      *  whole view rather than being pointed at something. Reuses the shared
      *  segmentation toast so progress reads the same as the SAM/cellpose tools. */
-    runTool(toolId: string): Promise<void>;
-    /** Shared driver for the box-prompt segment tools: wires the tool's status +
-     *  download progress into the sticky `sam` toast, runs `op`, and reports the
-     *  region count. Keeps the toast open until the run settles (bar hits 100%). */
-    private runSegmentWithToast;
-    /** Show the shared sticky `sam` toast once (idempotent — re-adding would stack
-     *  a new toast on every point click). */
-    private showSamToast;
-    /** Dismiss the shared `sam` toast and reset its progress/spinner state. */
-    private hideSamToast;
+    protected runTool(toolId: string): Promise<void>;
     /** Pick the SAM model the segment tools use (jit-ui#90 P1). */
-    onSamModelChange(id: string): void;
+    protected onSamModelChange(id: string): void;
     /** Convert the selected region to a smooth bezier curve. */
     toBezierRegion(): void;
     /** Convert the selected region back to a straight-edged polygon. */
     toPolygonRegion(): void;
-    /**
-     * Immediate region actions on the current selection (jit-ui#85): merge,
-     * ungroup, inverse, simplify, the Bézier conversions, and delete — the
-     * one-shot geometry transforms, grouped apart from the tool/mode toggles and
-     * shown only when something is selected. Each item is gated on what the
-     * selection supports.
-     */
-    private buildRegionActionItems;
+    /** The right-click menu for the current view, armed mode and selection. */
     private buildContextMenuItems;
+    private contextMenuState;
+    /** 3D scene interaction mode (orbit / turntable / pan / zoom); no-op on a 2D-only backend. */
     toggleSurface3dMode(mode: string): void;
     resetSurfaceCamera(): void;
     /** Toggle the napari 3D coordinate-axes / scale gizmo (volume/isosurface). No-op on backends
      *  that don't render one (the control method is optional). */
-    toggleAxes(): void;
+    protected toggleAxes(): void;
     /** Toggle the napari surface wireframe (edges vs filled). No-op on backends without a surface. */
-    toggleWireframe(): void;
+    protected toggleWireframe(): void;
     /** Change the napari 3D decimate factor. Decimation changes the fetched/assembled data, so this
      *  re-plots the current 3D type at the new resolution (unlike axes/wireframe, which are live). */
-    selectResolution(scale: number): void;
+    protected selectResolution(scale: number): void;
     /**
      * Switch the active plot type (heatmap, surface, contour, scatter, line,
      * scatter3d, isosurface). Keeps `isHeatmap` as the 2D-vs-3D flag the rest of
@@ -622,59 +423,12 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
      * moving to a 3D type, then re-plots.
      */
     onSelectPlotType(selected: PlotTypeId): void;
-    /**
-     * Start the selected contributed mode's session, once its base view has
-     * plotted. No-op for a built-in type, or when the base on screen is not the
-     * one the mode rides on. A backend that cannot provide a viewport for it
-     * (e.g. OSD fell back to Plotly) counts as a failed activation.
-     */
-    private activateSelectedPlotMode;
-    /** Render the live mode's panel. Activation can resolve outside Angular (an
-     *  OSD callback, a contribution's own promise), hence the zone re-entry. */
-    private showPlotModePanel;
-    /** Drop the panel (destroying a component panel) before the session ends. */
-    private hidePlotModePanel;
-    /**
-     * A contributed mode could not start. Its base type is already on screen —
-     * the base plotted first — so just select it: nothing needs to re-plot.
-     */
-    private fallBackFromPlotMode;
-    /** Run change detection; returns what it threw (logged), or null. */
-    private detectChangesSafely;
     /** The toolbar button: open the tool's dialog, or close it if it is open. */
-    toggleDialogTool(id: string): void;
+    protected toggleDialogTool(id: string): void;
     /** Close the open dialog tool: its body is torn down, then its session ends. */
-    closeDialogTool(): void;
-    /** Start (or restart, after a re-render) the open dialog tool's session. */
-    private activateOpenDialogTool;
-    /** The live dialog body's teardown, and a pending wait for its host to connect. */
-    private toolDialogTeardown;
-    private toolDialogFrame;
-    /**
-     * The session is live: render the dialog, then mount the tool's body once the host
-     * element is in the document, so `mount()` can measure it and start widgets that need
-     * a connected element.
-     */
-    private showToolDialog;
-    /** How many animation frames to wait for the dialog to attach the body's host. */
-    private static readonly TOOL_DIALOG_ATTACH_FRAMES;
-    /**
-     * Mount `tool`'s body into `host` once it is connected (the dialog may attach it a
-     * frame later, when it moves itself to `<body>`). If it never connects within
-     * {@link TOOL_DIALOG_ATTACH_FRAMES} it is mounted anyway, with a warning, rather than
-     * leaving an empty dialog. A throwing `mount()` fails the session like a failed start.
-     */
-    private mountToolDialogBody;
-    /** The session is about to end: tear the body down first, then drop the dialog. */
-    private hideToolDialog;
-    /** A dialog tool could not start: close it and say so. */
-    private dialogToolFailed;
+    protected closeDialogTool(): void;
     /** Where the open dialog tool's host element is attached once its dialog renders. */
     set toolDialogSlot(ref: ElementRef<HTMLElement> | undefined);
-    /** Toolbar tools for contributed modes. Calls can come from outside Angular, hence the zone. */
-    private readonly plotModeTools;
-    /** Deactivate whatever tool is armed and clear every tool mode. */
-    private deactivateActiveTool;
-    static ɵfac: i0.ɵɵFactoryDeclaration<VisualizerComponent, [null, null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<VisualizerComponent, "visualizer", never, { "toolbarTools": { "alias": "toolbarTools"; "required": false; }; "testMode": { "alias": "testMode"; "required": false; }; }, { "isStackEvent": "isStackEvent"; "isGrayscaleEvent": "isGrayscaleEvent"; }, never, ["*"], false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisualizerComponent, [null, null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisualizerComponent, "visualizer", never, { "toolbarTools": { "alias": "toolbarTools"; "required": false; }; "testMode": { "alias": "testMode"; "required": false; }; }, { "isStackEvent": "isStackEvent"; "isGrayscaleEvent": "isGrayscaleEvent"; }, never, ["*"], true, never>;
 }