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

package/lib/toolbar/wand/wand-tool.service.d.ts

@@ -1,98 +1,49 @@
 import { WandOptions, WandService } from './wand.service';
-import { IViewportHost, IRegionDataHost } from '../../contracts/coordinate-transform.contract';
-import * as i0 from "@angular/core";
+import { UndoGestureTarget } from '../tool-kit/undo-gesture';
+import { CanvasToolHost, ICanvasTool } from '../tool-kit/canvas-tool';
+export type { CachedImageData } from '../tool-kit/canvas-tool';
+/** @deprecated One host serves every canvas tool: use {@link CanvasToolHost}. */
+export type WandToolHost = CanvasToolHost;
 /**
- * The pixel data and frame state PlotlyService caches for sampling. Returned
- * by `WandToolHost.getCachedImageData()`.
- */
-export interface CachedImageData {
-    /** 2-D matrices, one per stack frame (length 1 for non-stack images). */
-    frames: any[];
-    /** Image-pixel width of each frame matrix. */
-    width: number;
-    /** Image-pixel height of each frame matrix. */
-    height: number;
-    /**
-     * Plot-data-coords-per-image-pixel along x (and y — they're the same
-     * for heatmap and image traces).
-     */
-    ratios: number[];
-    /** Whether each frame is a 2-D scalar matrix (true) or 3-channel RGB (false). */
-    isGrayscale: boolean;
-    /**
-     * Data-coords of matrix pixel (0,0). Lets the matrix be a *crop* of the data
-     * space rather than starting at the origin — e.g. the OSD backend samples the
-     * currently rendered viewport, so when zoomed in the matrix covers only the
-     * visible sub-region at screen resolution. Defaults to 0 (full-frame matrix,
-     * as Plotly provides). matrixIndex = (data - origin) / ratio.
-     */
-    originX?: number;
-    originY?: number;
-}
-/**
- * The collaboration interface the wand tool needs from PlotlyService.
+ * The wand drawing tool. Owns its pointer overlay and stroke accumulator
+ * (shared with the brush, see {@link MaskStrokeEditor}). Reads/writes regions
+ * via its {@link CanvasToolHost} so it stays decoupled from the backends.
  *
- * Keeping it explicit makes the dependency one-way: WandToolService never
- * imports PlotlyService directly. PlotlyService satisfies this interface
- * structurally and binds itself via `bindHost(this)`.
+ * A plain class: each backend's `CanvasToolManager` owns one instance and arms
+ * it with `activate(host, options)` / `deactivate()`.
  */
-export interface WandToolHost extends IViewportHost, IRegionDataHost {
-    /** Pixel data for sampling. null when no image is loaded yet. */
-    getCachedImageData(): CachedImageData | null;
-    /** Index of the currently visible frame in a stack (0 for non-stack). */
-    getActiveFrameIndex(): number;
-    /** Current image's filename — stamped onto new shapes for filtering. */
-    getFileName(): string | undefined;
-    /** Default stroke colour for new shapes. */
-    getShapeColor(): string;
-}
-/**
- * The wand drawing tool. Owns its own canvas overlay, mouse handlers, and
- * stroke accumulator. Reads/writes the shape list via the WandToolHost
- * interface so it stays decoupled from PlotlyService internals.
- *
- * Lifecycle: PlotlyService injects this service, calls `bindHost(this)` once
- * during its own construction, then calls `setMode(true | false, options)` to
- * activate/deactivate the tool.
- */
-export declare class WandToolService {
-    private wandService;
+export declare class WandTool implements ICanvasTool<WandOptions> {
+    private readonly wandService;
+    readonly id = "wand";
     private host;
-    private overlay;
-    private active;
+    private readonly overlay;
     /**
-     * Accumulated wand region. Every per-tick patch mask is OR'd into `mask`
-     * over a bbox that grows with the stroke, so the region keeps expanding
-     * as the user drags. The accumulator persists across mouseup/mousedown so
-     * that subsequent strokes extend the *same* region — matching QuPath's
-     * brush behaviour where the active annotation stays editable until the
-     * user switches tool.
+     * Accumulated wand region. Every per-tick patch mask is OR'd into the stroke
+     * over a bbox that grows with the stroke, so the region keeps expanding as
+     * the user drags. The accumulator persists across mouseup/mousedown so that
+     * subsequent strokes extend the *same* region — matching QuPath's brush
+     * behaviour where the active annotation stays editable until the user
+     * switches tool.
      */
-    private stroke;
-    /** Id of the region this wand stroke is editing (null = a fresh region). */
-    private strokeRegionId;
-    /** Readback ratio/origin signature the active stroke's matrix coords are tied to; a change
-     *  (zoom/pan) invalidates the stroke so it isn't re-committed at a different scale (jit-ui#102). */
-    private strokeRatioSig;
+    private readonly editor;
     private dragging;
     private options;
-    private readonly boundMouseDown;
-    private readonly boundMouseMove;
-    private readonly boundMouseUp;
-    constructor(wandService: WandService);
-    /** Wire the tool to its host. Must be called once before `setMode(true)`. */
-    bindHost(host: WandToolHost): void;
-    /** Toggle the wand on/off. */
-    setMode(active: boolean, options?: WandOptions): void;
+    /** Makes each drag one undo step, however long the user pauses (RT-12). */
+    private readonly gesture;
+    /** @param gestureTarget the region store, so each drag is one undo step. */
+    constructor(wandService: WandService, gestureTarget?: UndoGestureTarget | null);
+    /** Arm the wand on `host` with `options` (replacing the previous options). */
+    activate(host: CanvasToolHost, options?: WandOptions): void;
+    /** Disarm: remove the overlay and drop the active region. */
+    deactivate(): void;
     /** Merge new options (e.g. live sensitivity slider updates). */
     setOptions(options: WandOptions): void;
     /** Drop the active wand region so the next click starts a new one. */
-    clearActiveRegion(): void;
+    reset(): void;
     private createOverlay;
-    private destroyOverlay;
-    private onMouseDown;
-    private onMouseMove;
-    private onMouseUp;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
     private resetStroke;
     /**
      * Sample the cached image at the click location, OR (or AND-NOT) the
@@ -102,48 +53,12 @@ export declare class WandToolService {
      * exact-match flood fill.
      */
     private applyAtClient;
-    /** True if (matrixX, matrixY) lies inside the current stroke accumulator. */
-    private pointInStroke;
-    /**
-     * Remove the region referenced by `strokeRegionId` from the region list and
-     * reset the active stroke — used when an erase stroke deletes every pixel.
-     */
-    private dropActiveShape;
-    /**
-     * Whether a region can be faithfully rasterized into the wand stroke at the current view
-     * resolution (rx/ry = data units per matrix pixel). Editing rasterizes the region to the
-     * viewport grid and re-traces it, so a region whose matrix-space bbox exceeds the rasterizer's
-     * cap would be clipped/down-quantized and come back rescaled/corrupted (jit-ui#102) — e.g. a
-     * whole-slide annotation while zoomed out. Skip adopt/merge for those: leave them untouched and
-     * only edit them near native zoom.
-     */
-    private fitsForEdit;
-    /** A region's closed-polygon vertices (image/data coords), or null when it
-     *  isn't a fillable closed polygon (rectangles, open polylines). */
-    private regionVerts;
-    /** Convert a region's hole rings from image/data coords into matrix coords so
-     *  they line up with the stroke accumulator (jit-ui#85). */
-    private holesToMatrix;
-    /**
-     * If (matrixX, matrixY) falls inside an existing region, rasterize it into
-     * the wand stroke accumulator so subsequent wand input extends it rather than
-     * starting a new region.
-     */
-    private tryAdoptShapeAt;
-    /**
-     * Iterate every region; if its rasterized mask overlaps the wand stroke mask
-     * by at least one pixel, OR it into the stroke and remove it from the list.
-     * Called every tick so chained merges resolve. If the wand has no region id
-     * yet, the merged region's id is adopted so the merged region replaces it.
-     */
-    private mergeOverlappingShapes;
+    /** The visible frame of the readback, as the region grow reads it. */
+    private wandImage;
     /**
-     * Commit the in-progress polygon as a region — a new region on the first tick
-     * of a stroke, or an in-place replacement of the active region on later ticks
-     * — then ask the host to render. The store mints an id on the first commit,
-     * which we adopt so subsequent ticks replace the same region.
+     * OR (add) or AND-NOT (erase) the patch mask, centred on matrix point
+     * (cx, cy), into the stroke, growing the stroke to cover it first when
+     * adding. False when a fresh stroke has nothing inside the readback.
      */
-    private commitStroke;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WandToolService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WandToolService>;
+    private stampPatch;
 }

package/lib/toolbar/wand/wand.service.d.ts

@@ -1,133 +1,39 @@
 import { Polygon } from '../../models/region';
-import { IWandOptions, WandType } from '../../contracts/display-types';
+import { BBoxMask } from '../../geometry/raster';
+import { WandImage, WandOptions, WandPatchMask } from './wand-region-grow';
 import * as i0 from "@angular/core";
-export type { WandType };
-export type WandOptions = IWandOptions;
-export interface WandImage {
-    /**
-     * Grayscale: number[][] where data[y][x] is intensity.
-     * RGB: [r,g,b][][] where data[y][x] is a 3-tuple.
-     */
-    data: number[][] | number[][][];
-    width: number;
-    height: number;
-    isGrayscale: boolean;
-}
+export type { WandImage, WandOptions, WandPatchMask, WandType } from './wand-region-grow';
 /**
- * Wand region-growing tool, modelled after QuPath's WandToolEventHandler.
+ * Thin DI façade over the wand's pure modules, kept for one release so the
+ * injected consumers (the canvas tools, the backends) keep compiling.
+ *
+ * - region grow: `toolbar/wand/wand-region-grow`
+ * - rasterizer: `geometry/raster`; ring tests: `geometry/ring`
+ * - contour tracing: `geometry/contour`
  *
- * Given an image and a click position, extracts a square patch around the
- * click, optionally blurs it, computes a local threshold, runs a fixed-range
- * flood fill from the centre, closes the resulting mask, and returns the
- * traced contour as a polygon in image coordinates.
+ * @deprecated Import the pure functions instead; this service will be removed.
  */
 export declare class WandService {
-    /**
-     * @param image full-image pixel matrix (already in memory).
-     * @param cx click x in image-pixel coordinates.
-     * @param cy click y in image-pixel coordinates.
-     * @param options wand parameters; missing fields fall back to defaults.
-     * @returns a Polygon in image-pixel coordinates, or null if no region grew.
-     */
+    /** See {@link computeWandRegion} in `toolbar/wand/wand-region-grow`. */
     computeRegion(image: WandImage, cx: number, cy: number, options?: WandOptions): Polygon | null;
-    /**
-     * Compute the wand's per-click flood-fill mask in patch-local coordinates.
-     * Same algorithm as `computeRegion` but stops before contour tracing — useful
-     * for accumulating per-tick masks across a brush-style stroke.
-     *
-     * @returns mask of size W*W (0/1) plus W, or null if patchSize is invalid.
-     */
-    computePatchMask(image: WandImage, cx: number, cy: number, options?: WandOptions): {
-        mask: Uint8Array;
-        size: number;
-    } | null;
-    /**
-     * Standard ray-cast point-in-polygon test. (px, py) and the polygon
-     * vertices must be in the same coordinate system.
-     */
+    /** See {@link computeWandPatchMask} in `toolbar/wand/wand-region-grow`. */
+    computePatchMask(image: WandImage, cx: number, cy: number, options?: WandOptions): WandPatchMask | null;
+    /** Ray-cast point-in-ring test; see {@link pointInRing}. */
     pointInPolygon(px: number, py: number, xpoints: number[], ypoints: number[]): boolean;
-    /**
-     * Drop every vertex whose Euclidean distance to (cx, cy) is less than
-     * `radius`. Returns trimmed parallel arrays plus how many vertices were
-     * removed (so the caller can detect a no-op tick and skip the relayout).
-     */
+    /** See {@link dropVerticesWithinRadius} in `geometry/ring`. */
     dropVerticesWithinRadius(xpoints: number[], ypoints: number[], cx: number, cy: number, radius: number): {
         xpoints: number[];
         ypoints: number[];
         removed: number;
     };
-    /**
-     * Rasterize a closed polygon into a bbox-relative mask suitable as a
-     * starting point for a wand stroke accumulator.
-     *
-     * Returns the bbox origin (clamped to the image) plus the filled mask, or
-     * null if the polygon is degenerate or fully outside the image.
-     */
-    rasterizePolygon(xpoints: number[], ypoints: number[], imageWidth: number, imageHeight: number, holes?: number[][][]): {
-        bx: number;
-        by: number;
-        bw: number;
-        bh: number;
-        mask: Uint8Array;
-    } | null;
-    /**
-     * Point-in-region test that honours interior rings (holes): inside the
-     * exterior AND outside every hole (even-odd). Coordinates must share the
-     * polygon's frame. With no holes this is exactly {@link pointInPolygon}.
-     */
+    /** See {@link rasterizePolygon} in `geometry/raster`. */
+    rasterizePolygon(xpoints: number[], ypoints: number[], imageWidth: number, imageHeight: number, holes?: number[][][]): BBoxMask | null;
+    /** See {@link pointInPolygonWithHoles} in `geometry/ring`. */
     pointInPolygonWithHoles(px: number, py: number, xpoints: number[], ypoints: number[], holes?: number[][][]): boolean;
-    /**
-     * Trace the largest 4-connected blob in `mask` (sized w*h) and return a
-     * Polygon translated into image-pixel coordinates via (originX, originY).
-     * The traced vertices are NOT clamped to the image bounds: a region drawn while
-     * panned/zoomed keeps its true coordinates even where they fall outside the visible
-     * window (jit-ui#102). `imageWidth`/`imageHeight` are kept for signature compatibility
-     * but no longer used.
-     */
-    maskToPolygon(mask: Uint8Array, w: number, h: number, _imageWidth: number, _imageHeight: number, originX: number, originY: number): Polygon | null;
-    /**
-     * Trace EVERY 4-connected blob in `mask` (sized w*h) whose area is at least
-     * `minSize` pixels, returning one Polygon per blob in image-pixel coordinates
-     * (translated via originX/originY, clamped to imageWidth/imageHeight), ordered
-     * largest-first. Unlike {@link maskToPolygon} (largest blob only), this lets
-     * the brush eraser split a region in two when a stroke cuts through it rather
-     * than discarding the smaller piece.
-     */
-    maskToPolygons(mask: Uint8Array, w: number, h: number, imageWidth: number, imageHeight: number, originX: number, originY: number, minSize?: number, minHoleSize?: number): Polygon[];
-    /**
-     * Find interior rings (holes) of each foreground component in `mask`: a
-     * 4-connected run of background (0) pixels that is fully enclosed — i.e. not
-     * reachable from the grid border through background — is a hole, attributed to
-     * the foreground component that borders it most. Returns `fgLabel → rings`,
-     * each ring a list of `[x, y]` image-pixel pairs (same convention as a
-     * polygon's `coordinates`). Holes smaller than `minHoleSize` are dropped.
-     */
-    private detectHoles;
-    /**
-     * Trace each instance in an integer label map (0 = background) into a Polygon
-     * — used to turn a cellpose-style segmentation into region outlines. Labels
-     * with area below `minSize` are skipped. Coords are translated via
-     * originX/originY and clamped to imageWidth/imageHeight.
-     */
-    labelsToPolygons(labels: Uint32Array, w: number, h: number, imageWidth: number, imageHeight: number, originX: number, originY: number, minSize?: number): Polygon[];
-    private extractPatch;
-    private gaussianBlur;
-    private perChannelThreshold;
-    private labDistanceMap;
-    /**
-     * Fixed-range scanline flood fill from the patch centre. A neighbour is
-     * accepted iff for every channel `|p[c] - seed[c]| <= threshold[c]`.
-     */
-    private floodFill;
-    private morphClose;
-    private dilate;
-    private erode;
-    /**
-     * Returns the outer boundary of the largest 4-connected blob in the mask
-     * sized w*h.
-     */
-    private traceContour;
-    private mooreBoundary;
+    /** See {@link maskToPolygons} in `geometry/contour`. */
+    maskToPolygons(mask: Uint8Array, w: number, h: number, originX: number, originY: number, minSize?: number, minHoleSize?: number): Polygon[];
+    /** See {@link labelsToPolygons} in `geometry/contour`. */
+    labelsToPolygons(labels: Uint32Array, w: number, h: number, originX: number, originY: number, minSize?: number): Polygon[];
     static ɵfac: i0.ɵɵFactoryDeclaration<WandService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WandService>;
 }

package/lib/toolbar/zoom-to-box/zoom-to-box-tool.service.d.ts

@@ -1,49 +1,29 @@
-import * as i0 from "@angular/core";
+import { CanvasToolHost, ICanvasTool } from '../tool-kit/canvas-tool';
 /**
- * Collaboration interface the zoom-to-box tool needs from PlotlyService.
+ * @deprecated One host serves every canvas tool: use {@link CanvasToolHost}.
+ * The overlay now attaches to `getOverlayContainer()` (formerly the element
+ * with id `getPlotDiv()`), and `pixelToData` / `applyZoomToBox` are its
+ * optional zoom-to-box members.
  */
-export interface ZoomToBoxToolHost {
-    /** DOM id of the plot element the overlay canvas attaches to. */
-    getPlotDiv(): string;
-    /**
-     * Convert an overlay-pixel point (relative to the plot element's top-left)
-     * into the backend's data coordinates — Plotly axis data for Plotly,
-     * image-pixel coords for OpenSeadragon. Keeps the tool backend-agnostic.
-     */
-    pixelToData(px: number, py: number): {
-        x: number;
-        y: number;
-    };
-    /**
-     * Apply the user-selected zoom rectangle, ordered `[xMin, xMax, yMax, yMin]`.
-     * The host decides what that means: Plotly does a high-def re-fetch / axis
-     * relayout, OpenSeadragon fits the viewport to the image rectangle.
-     */
-    applyZoomToBox(coordinates: number[]): void;
-}
+export type ZoomToBoxToolHost = CanvasToolHost;
 /**
  * Custom canvas overlay for click-and-drag rectangular zoom. Plotly's
  * built-in `dragmode: 'zoom'` works on heatmap/image traces too, but it
  * doesn't drive the high-def zoom pipeline — this overlay does, by handing
  * the selected coordinates back to the host.
  */
-export declare class ZoomToBoxToolService {
+export declare class ZoomToBoxTool implements ICanvasTool<void> {
+    readonly id = "zoomToBox";
     private host;
-    private overlay;
+    private readonly overlay;
     private startPx;
-    private readonly boundMouseDown;
-    private readonly boundMouseMove;
-    private readonly boundMouseUp;
-    constructor();
-    bindHost(host: ZoomToBoxToolHost): void;
-    setMode(active: boolean): void;
-    private createOverlay;
-    private destroyOverlay;
-    private onMouseDown;
-    private onMouseMove;
-    private onMouseUp;
+    /** Lay the selection overlay over `host`'s plot. */
+    activate(host: CanvasToolHost): void;
+    /** Remove the overlay and any half-drawn box. */
+    deactivate(): void;
+    /** Primary button only (the overlay filters the others). */
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
     private drawSelection;
-    private clearCanvas;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ZoomToBoxToolService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ZoomToBoxToolService>;
 }

package/lib/util/mark-for-check.d.ts

@@ -0,0 +1,11 @@
+import { ChangeDetectorRef, NgZone } from '@angular/core';
+/**
+ * Mark an OnPush view for check, from wherever the change came from.
+ *
+ * `markForCheck()` only flags the view; a change-detection pass runs when the zone next
+ * settles. A change that arrives outside the zone — a store emission from an overlay's
+ * pointer handler, an OpenSeadragon or napari-js callback, a host stream — settles no
+ * zone, so the view would keep showing stale state until some unrelated event runs
+ * change detection. Re-entering the zone in that case schedules the pass.
+ */
+export declare function markForCheckInZone(cdr: ChangeDetectorRef, zone: NgZone): void;

package/lib/util/supersede.d.ts

@@ -0,0 +1,53 @@
+/**
+ * One task of a {@link Supersede}: the check a load makes after each await, and the
+ * signal it hands to whatever it awaits so that work can stop too, not just its result.
+ *
+ * Callable for compatibility with the first version of this helper, whose `next()`
+ * returned the bare check: `task()` is `task.isCurrent()`.
+ */
+export interface SupersedeTask {
+    (): boolean;
+    /** True until a newer task starts or the owner {@link Supersede.cancel cancels}. */
+    isCurrent(): boolean;
+    /**
+     * Aborted at the moment this task stops being current. Pass it to `fetch`, a worker
+     * call or `IDataRenderer.load()` so superseded work is dropped at the source.
+     */
+    readonly signal: AbortSignal;
+}
+/**
+ * "Latest wins" sequencing for one async concern.
+ *
+ * Every load that can be overtaken — a fetch the user changes their mind about before it
+ * lands — takes a task from {@link next} before its first await and checks it after each
+ * one. A newer task, or {@link cancel}, makes every older one stale and aborts its
+ * {@link SupersedeTask.signal}, so a slow response cannot paint over what the user has
+ * moved on to, and work that honours the signal stops instead of finishing for nobody.
+ *
+ * One instance per concern, never shared: two unrelated loads on one instance cancel each
+ * other, which is how a redraw used to drop a pending colour-source load. A dataset switch
+ * cancels all of them together.
+ */
+export declare class Supersede {
+    private generation;
+    private controller;
+    /**
+     * Start a task, superseding (and aborting) every earlier one.
+     *
+     * @returns the new task; it stays current until a newer task starts or
+     *   {@link cancel} runs.
+     */
+    next(): SupersedeTask;
+    /**
+     * The task of the current generation, WITHOUT starting a new one: a snapshot that goes
+     * stale (and aborts) on the next {@link next} or {@link cancel}. For work that belongs
+     * to whatever is current rather than competing with it — a cache fill that must not
+     * outlive the dataset it was started for, say.
+     */
+    current(): SupersedeTask;
+    /** Make every task started so far stale and abort its signal, without starting one. */
+    cancel(): void;
+    /** @deprecated Use {@link cancel}; kept for one release. */
+    invalidate(): void;
+    private advance;
+}

package/lib/visualization.module.d.ts

@@ -1,49 +1,28 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./visualizer.component";
-import * as i2 from "./toolbar/toolbar.component";
-import * as i3 from "./region-editor/region-editor.component";
-import * as i4 from "./hex-color-picker/hex-color-picker.component";
-import * as i5 from "./channel-histogram/channel-histogram.component";
-import * as i6 from "./spatial-controls/spatial-controls.component";
-import * as i7 from "./spatial-controls/spatial-charts/spatial-charts.component";
-import * as i8 from "@angular/common";
-import * as i9 from "@angular/forms";
-import * as i10 from "primeng/toolbar";
-import * as i11 from "primeng/button";
-import * as i12 from "primeng/menu";
-import * as i13 from "primeng/dropdown";
-import * as i14 from "primeng/slider";
-import * as i15 from "primeng/treeselect";
-import * as i16 from "primeng/inputnumber";
-import * as i17 from "primeng/dialog";
-import * as i18 from "primeng/contextmenu";
-import * as i19 from "primeng/progressbar";
-import * as i20 from "primeng/toast";
-import * as i21 from "primeng/tooltip";
-import * as i22 from "primeng/ripple";
-import * as i23 from "primeng/table";
-import * as i24 from "primeng/paginator";
-import * as i25 from "primeng/overlaypanel";
-import * as i26 from "primeng/confirmdialog";
-import * as i27 from "primeng/inputtext";
-import * as i28 from "primeng/checkbox";
-import * as i29 from "primeng/multiselect";
-import * as i30 from "primeng/radiobutton";
-import * as i31 from "primeng/selectbutton";
-import * as i32 from "primeng/autocomplete";
+import * as i2 from "./region-editor/region-editor.component";
+import * as i3 from "./hex-color-picker/hex-color-picker.component";
+import * as i4 from "./channel-histogram/channel-histogram.component";
+import * as i5 from "./spatial-controls/spatial-controls.component";
+import * as i6 from "./spatial-controls/spatial-charts/spatial-charts.component";
 /**
  * Self-contained plotting UI: the {@link VisualizerComponent} (plot surface
- * + render orchestration), its {@link ToolbarComponent}, and the
- * {@link RegionEditorComponent} (the Regions tab table/editor). Consumers embed
- * `<visualizer>` / `<region-editor>` and need know nothing about the toolbar,
- * the rendering backends, or region file I/O (supplied via the REGION_IO_PORT).
+ * + render orchestration, with its toolbar), the {@link RegionEditorComponent}
+ * (the Regions table/editor), {@link HexColorPickerComponent}
+ * (`<hex-color-picker>`, `[color]` in, `(colorChange)` out),
+ * {@link ChannelHistogramComponent}, {@link SpatialControlsComponent} and
+ * {@link SpatialChartsComponent}. Consumers embed `<visualizer>` /
+ * `<region-editor>` and need know nothing about the toolbar, the rendering
+ * backends, or region file I/O (supplied via the REGION_IO_PORT).
  *
- * Also exports {@link HexColorPickerComponent} (`<hex-color-picker>`) as a
- * standalone reusable picker (`[color]` in, `(colorChange)` out) so consuming
- * apps can use it on its own, the same way as the visualizer and region editor.
+ * @deprecated A re-export shim, kept for one minor release: every component is
+ * standalone now. Import the components themselves (`imports: [VisualizerComponent]`)
+ * and bind the backend chain with {@link provideVisualization} — in the application's
+ * providers for one app-wide viewer chain, or a component's for an isolated one —
+ * instead of the root bindings this module adds.
  */
 export declare class VisualizationModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<VisualizationModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<VisualizationModule, [typeof i1.VisualizerComponent, typeof i2.ToolbarComponent, typeof i3.RegionEditorComponent, typeof i4.HexColorPickerComponent, typeof i5.ChannelHistogramComponent, typeof i6.SpatialControlsComponent, typeof i7.SpatialChartsComponent], [typeof i8.CommonModule, typeof i9.FormsModule, typeof i10.ToolbarModule, typeof i11.ButtonModule, typeof i12.MenuModule, typeof i13.DropdownModule, typeof i14.SliderModule, typeof i15.TreeSelectModule, typeof i16.InputNumberModule, typeof i17.DialogModule, typeof i18.ContextMenuModule, typeof i19.ProgressBarModule, typeof i20.ToastModule, typeof i21.TooltipModule, typeof i22.RippleModule, typeof i23.TableModule, typeof i24.PaginatorModule, typeof i25.OverlayPanelModule, typeof i26.ConfirmDialogModule, typeof i27.InputTextModule, typeof i28.CheckboxModule, typeof i29.MultiSelectModule, typeof i30.RadioButtonModule, typeof i31.SelectButtonModule, typeof i32.AutoCompleteModule], [typeof i1.VisualizerComponent, typeof i3.RegionEditorComponent, typeof i4.HexColorPickerComponent, typeof i5.ChannelHistogramComponent, typeof i6.SpatialControlsComponent, typeof i7.SpatialChartsComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisualizationModule, never, [typeof i1.VisualizerComponent, typeof i2.RegionEditorComponent, typeof i3.HexColorPickerComponent, typeof i4.ChannelHistogramComponent, typeof i5.SpatialControlsComponent, typeof i6.SpatialChartsComponent], [typeof i1.VisualizerComponent, typeof i2.RegionEditorComponent, typeof i3.HexColorPickerComponent, typeof i4.ChannelHistogramComponent, typeof i5.SpatialControlsComponent, typeof i6.SpatialChartsComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<VisualizationModule>;
 }

package/lib/visualizer/floating-drag.directive.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter, NgZone, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+/** A screen position, in CSS pixels. */
+export interface FloatingPos {
+    x: number;
+    y: number;
+}
+/**
+ * Drag handle of a floating, `position: fixed` panel (the intensity inset header,
+ * the toolbar dock handle). On mousedown it asks {@link origin} where the panel is —
+ * the host may detach a docked panel right there — then emits the new position on
+ * every move until mouseup.
+ *
+ * The move/up listeners exist only while a drag is in progress and run outside the
+ * Angular zone, re-entering it per emitted position: a permanent window mousemove
+ * listener made every pointer move anywhere in the host app run change detection.
+ */
+export declare class FloatingDragDirective implements OnDestroy {
+    private readonly zone;
+    /** Called on mousedown: the panel's position the drag starts from. */
+    origin: () => FloatingPos;
+    /** The panel's new position, per pointer move. */
+    readonly vizFloatingDragMove: EventEmitter<FloatingPos>;
+    private end;
+    constructor(zone: NgZone);
+    onMouseDown(e: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingDragDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FloatingDragDirective, "[vizFloatingDrag]", never, { "origin": { "alias": "vizFloatingDrag"; "required": false; }; }, { "vizFloatingDragMove": "vizFloatingDragMove"; }, never, never, true, never>;
+}

package/lib/visualizer/region-actions.d.ts

@@ -0,0 +1,54 @@
+import { Observable } from 'rxjs';
+import { Message } from 'primeng/api';
+import { IRegionStore } from '../contracts/visualizer.contract';
+import { Region } from '../models/region';
+import { RegionOpsService } from '../region-ops.service';
+/** The region-store members the set-operations read and write through. */
+export type RegionActionsTarget = Pick<IRegionStore, 'getRegions' | 'setRegions' | 'setSelectedShapeIndices' | 'getSelectedShapeIndices$' | 'getCanUndo$' | 'getCanRedo$'>;
+/**
+ * Region set-operations on the current selection (jit-ui#85) — select all, merge,
+ * ungroup, inverse, simplify — plus the store mirrors the toolbar and the context
+ * menu read synchronously: the selection and the undo/redo availability.
+ *
+ * Every operation commits through `setRegions`, so it is undo-tracked and the
+ * backend on screen re-renders; profile lines and unselected regions are kept.
+ */
+export declare class RegionActions {
+    private readonly target;
+    private readonly ops;
+    /** `[width, height]` of the image, when known — the frame inverse and merge rasterize in. */
+    private readonly imageSize;
+    private readonly notify;
+    /** Current selection (array indices), mirrored from the store. */
+    selectedIndices: number[];
+    /** Whether a region action is available to undo / redo; drive the toolbar buttons. */
+    canUndo: boolean;
+    canRedo: boolean;
+    /** Custom-threshold Simplify dialog. */
+    displaySimplifyDialog: boolean;
+    simplifyThreshold: number;
+    constructor(target: RegionActionsTarget, ops: RegionOpsService, 
+    /** `[width, height]` of the image, when known — the frame inverse and merge rasterize in. */
+    imageSize: () => number[] | undefined, notify: (message: Message) => void);
+    /** Mirror the store's selection and undo/redo depth until `until$` emits.
+     *  `changed` runs after an undo/redo flip (the toolbar binds those). */
+    bind(until$: Observable<unknown>, changed: () => void): void;
+    /** The currently-selected regions (live store instances). */
+    get selected(): Region[];
+    /** Select every region on the image (excludes intensity-profile lines). */
+    selectAll(): void;
+    /** Merge the selected regions into a single (possibly multi-part) region. */
+    merge(): void;
+    /** Split each selected multi-part region into one region per part. */
+    ungroup(): void;
+    /** Replace the selection with its inverse inside the image rectangle. */
+    inverse(): void;
+    /** Douglas–Peucker simplify each selected region by `thresholdPx`, closing the dialog. */
+    simplify(thresholdPx: number): void;
+    openSimplifyDialog(): void;
+    /** Commit a set-op: drop `remove`, append `add`, and select the results. */
+    private replace;
+    /** 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 frame;
+}