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

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

@@ -1,4 +1,3 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { ClassPreset, PresetSet } from '../models/class-preset';
 import { PreferencesPort } from '../contracts/ports/preferences.port';
@@ -9,25 +8,20 @@ import * as i0 from "@angular/core";
 /**
  * Backend-neutral store for the **visualization session** — the state that
  * describes *how* the current image is being viewed, independent of which
- * rendering backend (Plotly or OpenSeadragon) is on screen:
+ * rendering backend (Plotly, OpenSeadragon or napari-js) is on screen:
  *
  *  - the active colormap / LUT and its reverse-scale toggle,
- *  - the current image's physical metadata (µm/pixel etc.),
- *  - the classification label → colour map,
+ *  - the current image's physical metadata (µm/pixel etc.) and its per-channel
+ *    display state (window, gamma, tint, visibility; grayscale / invert),
+ *  - the annotation-class presets (the classification label → colour map),
+ *  - the spatial-omics view state,
  *  - which on-canvas tool is currently active.
  *
- * Both backends read and write this single instance, so they stay in lock-step
- * regardless of which one is rendering. Previously this state lived inside
- * `PlotlyService`, which forced the OpenSeadragon backend to depend on the
- * Plotly service purely to read the shared colormap; this store removes that
- * coupling — neither backend owns the session state.
- *
- * NOTE: region *geometry* (the drawn shapes / per-image region cache) still
- * lives in `PlotlyService` for now; extracting it into a sibling region store
- * is a separate follow-up.
+ * Every backend reads and writes this single instance (one per visualizer chain),
+ * so they stay in lock-step regardless of which one is rendering; none of them
+ * owns the session state. Region geometry lives in the sibling `RegionStore`.
  */
 export declare class VisualizerStore {
-    private readonly http;
     private readonly prefsPort;
     private readonly colormap$;
     private readonly reverseScale$;
@@ -37,9 +31,13 @@ export declare class VisualizerStore {
      *  single-scalar 3D view (the napari Surface) follows for a multichannel image. */
     private readonly selectedChannel$;
     private defaultChannelStates;
+    /** The image the current channel states were derived for (see setImageMeta). */
+    private channelImageKey;
     private readonly grayscale$;
     private readonly invert$;
     private presetSet;
+    /** Session-only class colours from imported files (see PresetSet.importedColors). */
+    private importedColors;
     private readonly presetSet$;
     private readonly savePresets$;
     private presetsLoaded;
@@ -48,18 +46,10 @@ export declare class VisualizerStore {
      *  Held here, next to the colormap/channel state, so the active backend reacts
      *  to an edit exactly as it does for an image. */
     private readonly spatialView$;
-    constructor(http?: HttpClient | null, prefsPort?: PreferencesPort | null);
-    /**
-     * Resolve the colormap tree's LUT keys (e.g. "GREYS_LUT") to their colour
-     * arrays from a served JSON asset. The ~630 KB of LUT data lives outside the
-     * bundle (as `/assets/plotting/colormap-luts.json`) so it never enters the TS
-     * / webpack module graph — that data-in-source was the main driver of the
-     * build's >2 GB heap. Named Plotly scales (e.g. "Viridis") aren't keys in the
-     * JSON, so they're left untouched. The default LUT ("Greys Inv" → the Plotly
-     * "Greys" scale) needs no JSON, so the first render works before this resolves.
-     */
-    private loadColormapLuts;
+    constructor(prefsPort?: PreferencesPort | null);
     private initPresetPersistence;
+    /** Publish the preset set with this session's imported class colours. */
+    private emitPresetSet;
     private normalizePresetSet;
     /** Queue a debounced save. No-ops until the initial load resolves (and when no port is bound). */
     private queuePresetSave;
@@ -86,7 +76,16 @@ export declare class VisualizerStore {
      * Editor) show µm²/mm² instead of px². No-op when neither axis is positive.
      */
     setPhysicalPixelSize(mppX?: number, mppY?: number): void;
-    setImageMeta(imageMeta: IImageMetadata[]): void;
+    /**
+     * Publish the current image's metadata and derive its channels.
+     *
+     * `imageKey` identifies the image (its file name). A re-plot of the SAME image
+     * keeps the user's window/gamma/tint edits; a different image gets its own
+     * derived channels even at the same channel count — keying on the count alone
+     * left a DAPI/GFP/RFP stack's names, tints and windows on a following
+     * CD3/CD8/PanCK one. Without a key, only a change of channel count re-derives.
+     */
+    setImageMeta(imageMeta: IImageMetadata[], imageKey?: string): void;
     /** Channels for an image:
      *   - RGB (rgbChannels ≥ 3) → Red/Green/Blue;
      *   - multichannel fluorescence (channelCount > 1) → one channel per band,
@@ -119,25 +118,25 @@ export declare class VisualizerStore {
     /** Upsert a single class colour (used by the editor's per-class colour picker). */
     setClassificationColor(label: string, color: string): void;
     getPresetSet(): PresetSet;
+    /**
+     * Remember the class colours an imported file carried (label → colour), so its regions keep
+     * them: a class with a preset keeps the preset's colour, and the latest import wins for the
+     * rest. Not persisted.
+     */
+    rememberImportedClassColors(colors: ReadonlyMap<string, string>): void;
     getPresetSet$(): Observable<PresetSet>;
     setPresetSet(set: PresetSet): void;
     /** Add or update a class (keyed by exact stored `name`). */
     upsertClass(preset: ClassPreset): void;
     removeClass(name: string): void;
     resetPresets(): void;
-    /** Force a (debounced) write-back of the current preset set. */
-    persistPresets(): void;
     getSpatialView$(): Observable<SpatialViewState>;
     /** Synchronous read, for a renderer building its first frame. */
     currentSpatialView(): SpatialViewState;
     /** Patch the spatial view state; emits once with the merged value. */
     setSpatialView(partial: Partial<SpatialViewState>): void;
-    /** Reset to defaults — e.g. when a different dataset is selected, where the
-     *  previous colour column almost certainly does not exist. */
-    resetSpatialView(): void;
     getActiveTool$(): Observable<string | null>;
-    getActiveTool(): string | null;
     setActiveTool(tool: string | null): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<VisualizerStore, [{ optional: true; }, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisualizerStore, [{ optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<VisualizerStore>;
 }

package/lib/toast-outlets.d.ts

@@ -10,9 +10,10 @@
  * failed or no-op action looked like a dead button.
  *
  * These keys are owned by the library and their outlets are rendered by
- * {@link VisualizerComponent}, so the feedback works in any host. A host that
- * wants these notices somewhere else should not render an outlet with the same
- * key — two matching outlets show the message twice.
+ * {@link VisualizerComponent}, so the feedback works in any host. Both keys are
+ * exported from the package so a host can tell them apart from its own; it should
+ * not render an outlet with the same key — two matching outlets show the message
+ * twice.
  */
 /** General notices: save results, validation, action outcomes. Default position. */
 export declare const VIZ_TOAST_KEY = "sci-viz-notice";

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

@@ -1,6 +1,5 @@
-import { WandService } from '../wand/wand.service';
-import { WandToolHost } from '../wand/wand-tool.service';
-import * as i0 from "@angular/core";
+import { UndoGestureTarget } from '../tool-kit/undo-gesture';
+import { CanvasToolHost, ICanvasTool } from '../tool-kit/canvas-tool';
 /** Brush parameters. `size` is the brush *diameter* in matrix (image) pixels. */
 export interface BrushOptions {
     size?: number;
@@ -14,14 +13,9 @@ export interface BrushOptions {
     label?: string;
     color?: string;
 }
-/**
- * The brush host is identical to the wand's — both need the cached-image
- * coordinate frame, the overlay container, the coordinate transform, and
- * read/write access to the shared region list. The brush ignores the wand's
- * pixel values (it paints a geometric disc rather than flood-filling by colour),
- * so reusing {@link WandToolHost} lets each backend bind the same host object.
- */
-export type BrushToolHost = WandToolHost;
+/** @deprecated One host serves every canvas tool: use {@link CanvasToolHost}. The
+ *  brush reads only the readback's coordinate frame, not its pixel values. */
+export type BrushToolHost = CanvasToolHost;
 /**
  * QuPath-style brush tool. Painting a stroke unions a disc of the configured
  * size into the active region as the cursor drags; holding <kbd>Shift</kbd>
@@ -33,37 +27,26 @@ export type BrushToolHost = WandToolHost;
  * No pixel sampling and no cursor indicator: the painted stroke itself shows the
  * brush size. The overlay canvas only captures the pointer.
  *
- * Lifecycle mirrors the wand: a backend binds its host once, then toggles the
- * tool with `setMode(true | false, options)`.
+ * Lifecycle mirrors the wand: a plain class, one instance per backend's
+ * `CanvasToolManager`, armed with `activate(host, options)` / `deactivate()`.
  *
  * Holes / donuts (jit-ui#85): brushing a ring that encloses an unpainted area
- * keeps the enclosed hole — {@link WandService.maskToPolygons} traces interior
+ * keeps the enclosed hole — the contour tracer (`geometry/contour`) traces interior
  * rings into {@link Polygon.holes}, which adopt/merge preserve (the re-rasterize
  * punches the holes back out). The OpenSeadragon overlay renders them with
  * even-odd fill and GeoJSON round-trips them as extra Polygon rings. The Plotly
  * (Heatmap) backend currently renders the filled exterior only.
  */
-export declare class BrushToolService {
-    private wandService;
+export declare class BrushTool implements ICanvasTool<BrushOptions> {
+    readonly id = "brush";
     private host;
-    private overlay;
-    private active;
+    private readonly overlay;
     /**
-     * Accumulated brush region (bbox-relative mask). Persists across mouseup so a
-     * subsequent stroke extends the *same* region until the user switches tool —
-     * matching QuPath, and the wand.
+     * Accumulated brush region (bbox-relative mask), shared logic with the wand.
+     * Persists across mouseup so a subsequent stroke extends the *same* region
+     * until the user switches tool — matching QuPath, and the wand.
      */
-    private stroke;
-    /** Id of the region this stroke is editing (null = a fresh region). For an
-     *  erase that splits the region, this tracks the largest resulting piece. */
-    private strokeRegionId;
-    /** Readback ratio/origin signature the active stroke is tied to; a change (zoom/pan) invalidates
-     *  it so it isn't re-committed at a different scale (jit-ui#102). */
-    private strokeRatioSig;
-    /** Ids of the extra regions produced when an erase stroke splits a region
-     *  into disconnected pieces — reused across drag ticks so the split pieces
-     *  keep stable identities instead of being recreated each tick. */
-    private strokeExtraIds;
+    private readonly editor;
     /** Previous cursor position (matrix coords) within the current drag, so fast
      *  drags paint a continuous stroke rather than disconnected dabs. */
     private lastMatrix;
@@ -71,14 +54,17 @@ export declare class BrushToolService {
     private size;
     /** The class being painted ({@link BrushOptions.label} / `color`); null = plain brush. */
     private paintClass;
-    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: BrushToolHost): void;
-    /** Toggle the brush on/off. */
-    setMode(active: boolean, options?: BrushOptions): 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(gestureTarget?: UndoGestureTarget | null);
+    /** Arm the brush on `host`. Arming sets the class in full: no label/color
+     *  means the plain brush; a missing size keeps the previous one. */
+    activate(host: CanvasToolHost, options?: BrushOptions): void;
+    /** Disarm: remove the overlay, drop the active region and the class. */
+    deactivate(): void;
+    /** Drop the active brush region so the next stroke starts a new one. */
+    reset(): void;
     /**
      * Update size and/or class while armed. The class changes only when `label`
      * or `color` is passed (as a key, even `undefined`), so a size-only update
@@ -88,13 +74,10 @@ export declare class BrushToolService {
     setOptions(options?: BrushOptions): void;
     /** Live-update the brush size (matrix-pixel diameter). */
     setSize(size: number): void;
-    /** Drop the active brush region so the next stroke starts a new one. */
-    clearActiveRegion(): void;
     private createOverlay;
-    private destroyOverlay;
-    private onMouseDown;
-    private onMouseMove;
-    private onMouseUp;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
     private resetStroke;
     /**
      * Paint (or erase) a disc — or a swept line of discs since the previous
@@ -104,61 +87,11 @@ export declare class BrushToolService {
     private applyAtClient;
     /**
      * OR (add) or AND-NOT (erase) a filled disc of `radius` matrix-pixels centred
-     * at (cx, cy) into the accumulator, growing its bbox to fit when adding.
+     * at (cx, cy) into the accumulator, growing its bbox (clipped to the
+     * readback) to fit when adding.
      */
     private stampDisc;
-    /**
-     * Ensure the accumulator's bbox covers [px0,py0,px1,py1) (clamped to the
-     * image), allocating/copying a larger mask when it must grow. Returns false if
-     * the requested box is empty after clamping.
-     */
-    private ensureStrokeCovers;
-    /** True if (matrixX, matrixY) lies inside the current stroke accumulator. */
-    private pointInStroke;
-    /**
-     * Remove the region(s) referenced by the stroke and reset it — used when an
-     * erase stroke deletes every pixel.
-     */
-    private dropActiveShape;
     /** Whether the stroke may adopt or merge `region`: always for the plain brush,
      *  otherwise only a region of the class being painted. */
     private paintsInto;
-    /** A region's closed-polygon vertices (image/data coords), or null when it
-     *  isn't a fillable closed polygon (rectangles, open polylines). */
-    private regionVerts;
-    /** Whether a region can be faithfully rasterized at this zoom (rx/ry = data units per matrix px).
-     *  Editing rasterizes + re-traces the region, so one whose matrix-space bbox exceeds the
-     *  rasterizer cap would come back rescaled/corrupted (e.g. a whole-slide annotation while zoomed
-     *  out) — skip adopt/merge for those and only edit them near native zoom (jit-ui#102). */
-    private fitsForEdit;
-    /** 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
-     * stroke accumulator so subsequent brush input extends it rather than starting
-     * a new region.
-     */
-    private tryAdoptShapeAt;
-    /**
-     * Fold every region whose rasterized mask overlaps the stroke mask into the
-     * stroke and remove it from the list, so brushing across regions merges them.
-     */
-    private mergeOverlappingShapes;
-    /**
-     * Commit the stroke's connected pieces as regions — the largest keeps the
-     * stroke's region identity, additional pieces (from an erase that split the
-     * region) become their own regions tracked in `strokeExtraIds` so they keep
-     * stable identities across drag ticks. The store mints ids on commit, which
-     * we read back so subsequent ticks replace the same regions.
-     */
-    private commitComponents;
-    /**
-     * Build a Region for one component and insert it into `regions`: replace the
-     * region with `id` in place if it exists, otherwise append a new one. Returns
-     * the Region instance (its id is minted later by the store when new).
-     */
-    private upsertComponent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BrushToolService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BrushToolService>;
 }

package/lib/toolbar/canvas-tools.d.ts

@@ -0,0 +1,20 @@
+import { WandService } from './wand/wand.service';
+import { SamPointToolService } from './segmentation/sam-point-tool.service';
+import { CanvasToolHost } from './tool-kit/canvas-tool';
+import { CanvasToolManager } from './tool-kit/canvas-tool-manager';
+import { UndoGestureTarget } from './tool-kit/undo-gesture';
+/** What a backend supplies to build its canvas tools — all from its own injector. */
+export interface CanvasToolDeps {
+    /** The (stateless) wand patch sampler. */
+    wandService: WandService;
+    /** The chain's region store: makes each wand/brush/eraser drag one undo step. */
+    regionStore: UndoGestureTarget | null;
+    /** The chain's SAM point feeds; the point tool reports through them. */
+    samPoint: SamPointToolService;
+}
+/**
+ * A backend's canvas-tool manager: fresh wand, brush, vertex eraser,
+ * zoom-to-box and SAM point tools over `host`. Each backend calls this once, so
+ * no tool instance — and no tool state — is shared between backends (RT-21).
+ */
+export declare function createCanvasToolManager(host: CanvasToolHost, deps: CanvasToolDeps): CanvasToolManager;

package/lib/toolbar/crop/slide-crop.d.ts

@@ -1,4 +1,4 @@
-import { CachedImageData } from '../wand/wand-tool.service';
+import type { CachedImageData } from '../wand/wand-tool.service';
 /** A client-side crop of the loaded image — the browser equivalent of the JIT
  *  server slide-crop, taken from the pixels already in the viewer. */
 export interface CroppedImage {
@@ -19,12 +19,18 @@ export interface DataBox {
 }
 /**
  * Browser "slide crop": extract the box region (data coords) from a cached image
- * frame as an RGBA image, clamped to the image bounds. Grayscale frames are
- * replicated across R/G/B; RGB tuples are copied through. Returns null when the
- * box is empty/outside the image.
+ * frame as an RGBA image, clamped to the image bounds. Returns null when the box
+ * is empty/outside the image.
  *
  * The output feeds an automatic segmenter (e.g. cellpose-SAM): run it on the
  * crop, then offset the resulting masks by (matrixX0, matrixY0) to place them
  * back on the full frame.
  */
 export declare function cropImageRegion(cached: CachedImageData, frameIndex: number, box: DataBox): CroppedImage | null;
+/**
+ * RGBA pixels of the `w`×`h` matrix window at (x0, y0) of a cached frame,
+ * nested or packed (see `tool-kit/frame-pixels`). Grayscale frames are
+ * replicated across R/G/B; RGB tuples are copied through. Missing pixels become
+ * opaque black.
+ */
+export declare function frameRegionToRgba(cached: CachedImageData, frameIndex: number, x0: number, y0: number, w: number, h: number): Uint8ClampedArray;

package/lib/toolbar/plot-type-selector/plot-type-selector.component.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter } from '@angular/core';
+import { PlotTypeId } from '../../contracts/plot-type';
+import { PlotTypeOption } from '../../contracts/plot-type-contribution.contract';
+import * as i0 from "@angular/core";
+/**
+ * The toolbar's plot-type group: the plot-type dropdown, the isosurface band
+ * slider for the isosurface modes, and the add-intensity-line button for the
+ * views that draw profile lines. Presentational: the host owns the values.
+ */
+export declare class PlotTypeSelectorComponent {
+    /** Plot types the active backend advertises, then any contributed modes. */
+    options: PlotTypeOption[];
+    /** The selected built-in type or contributed mode id. */
+    selected: PlotTypeId;
+    /** An isosurface mode: show the iso band slider. */
+    isosurface: boolean;
+    /** Isosurface band as a 0–255 slider position. */
+    isoRange: number[];
+    /** The view draws intensity profile lines: show the add-line button. */
+    intensityLines: boolean;
+    /** A plot type or contributed mode was picked from the dropdown. */
+    selectPlotType: EventEmitter<string>;
+    /** The iso band slider moved: the new `[low, high]` pair (or nothing). */
+    isoRangeChange: EventEmitter<number[] | undefined>;
+    /** Add another coloured intensity line ROI + inset trace. */
+    addProfileLine: EventEmitter<void>;
+    /** Iso slider bounds — UI constants (the band is host-owned). */
+    protected readonly isoValueMin = 0;
+    protected readonly isoValueMax = 255;
+    protected readonly isoValueStep = 1;
+    /** A plot-type icon is a PrimeNG font glyph (e.g. `pi pi-image`) rather than an
+     *  SVG asset path — drives which element the item template renders. */
+    protected isPiIcon(icon: string | undefined): boolean;
+    /** The iso band slider reports its `[low, high]` pair (or nothing). */
+    protected onIsoRange(value: number | number[] | undefined): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlotTypeSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PlotTypeSelectorComponent, "toolbar-plot-type-selector", never, { "options": { "alias": "options"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "isosurface": { "alias": "isosurface"; "required": false; }; "isoRange": { "alias": "isoRange"; "required": false; }; "intensityLines": { "alias": "intensityLines"; "required": false; }; }, { "selectPlotType": "selectPlotType"; "isoRangeChange": "isoRangeChange"; "addProfileLine": "addProfileLine"; }, never, never, true, never>;
+}

package/lib/toolbar/region-tools/region-tool-buttons.d.ts

@@ -0,0 +1,21 @@
+/** A drawing tool's toggle button in the toolbar's region group. */
+export interface RegionToolButton {
+    /** The drag mode the button toggles. */
+    mode: string;
+    /** Accessible name. */
+    label: string;
+    /** Tooltip (HTML). */
+    tooltip: string;
+    /** A PrimeNG glyph (`pi pi-…`), or else {@link img}. */
+    icon?: string;
+    /** An SVG under `assets/plotting/`, recoloured for its on/off state. */
+    img?: string;
+    /** `not3d`: absent from the 3D cloud's screen-space lasso (no raster to
+     *  sample / an open polyline is no region); `vertex`: needs a backend with a
+     *  vertex-editing overlay (OSD + napari-js image). */
+    gate?: 'not3d' | 'vertex';
+    /** The tool's parameter slider, shown while it is active. */
+    slider?: 'brush' | 'wand' | 'eraser';
+}
+/** The region drawing tools, in toolbar order. */
+export declare const REGION_TOOL_BUTTONS: readonly RegionToolButton[];

package/lib/toolbar/region-tools/region-tools.component.d.ts

@@ -0,0 +1,62 @@
+import { EventEmitter } from '@angular/core';
+import { RegionToolButton } from './region-tool-buttons';
+import * as i0 from "@angular/core";
+/**
+ * The toolbar's region group: open the Region Editor, the drawing tools (one
+ * table-driven toggle per {@link REGION_TOOL_BUTTONS} entry, with the active
+ * tool's parameter slider), undo / redo and delete. Presentational: the host
+ * owns the active mode and every value.
+ */
+export declare class RegionToolsComponent {
+    /** The armed drawing tool's mode, or null. */
+    activeDragMode: string | null;
+    /** The 3D cloud's screen-space lasso: no brush or polyline. */
+    is3dRegions: boolean;
+    /** Only the selection tool (a volume view: it picks the regions' surfaces in 3D). */
+    selectOnly: boolean;
+    /** The backend has a vertex-editing overlay (OSD + napari-js image). */
+    vertexTools: boolean;
+    /** Magic-wand sensitivity (the wand's slider value). */
+    wandSensitivity: number;
+    /** Brush diameter in image pixels. */
+    brushSize: number;
+    /** Vertex-eraser radius in image pixels. */
+    vertexEraserRadius: number;
+    /** A region action can be undone (enables Undo). */
+    canUndo: boolean;
+    /** An undone region action can be redone (enables Redo). */
+    canRedo: boolean;
+    /** Open the Region Editor dialog. */
+    openRegionEditor: EventEmitter<void>;
+    /** A drawing tool's button was clicked (its mode). */
+    toggleDragMode: EventEmitter<string>;
+    /** Undo the last region action. */
+    undoRegion: EventEmitter<void>;
+    /** Redo the last undone region action. */
+    redoRegion: EventEmitter<void>;
+    /** Delete the selected region. */
+    deleteRegion: EventEmitter<void>;
+    /** The wand sensitivity slider moved. */
+    wandSensitivityChange: EventEmitter<number | undefined>;
+    /** The brush size slider moved. */
+    brushSizeChange: EventEmitter<number | undefined>;
+    /** The vertex-eraser radius slider moved. */
+    vertexEraserRadiusChange: EventEmitter<number | undefined>;
+    protected readonly buttons: readonly RegionToolButton[];
+    /** Slider bounds — toolbar UI constants (the values are host-owned). */
+    protected readonly wandSensitivityMin = 0.5;
+    protected readonly wandSensitivityMax = 10;
+    protected readonly wandSensitivityStep = 0.1;
+    protected readonly brushSizeMin = 5;
+    protected readonly brushSizeMax = 300;
+    protected readonly brushSizeStep = 5;
+    protected readonly vertexEraserRadiusMin = 5;
+    protected readonly vertexEraserRadiusMax = 300;
+    protected readonly vertexEraserRadiusStep = 5;
+    protected readonly trackByMode: (_: number, b: RegionToolButton) => string;
+    protected shown(b: RegionToolButton): boolean;
+    /** A single slider's value (a range slider never feeds these). */
+    protected asNumber(v: number | number[] | undefined): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegionToolsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegionToolsComponent, "toolbar-region-tools", never, { "activeDragMode": { "alias": "activeDragMode"; "required": false; }; "is3dRegions": { "alias": "is3dRegions"; "required": false; }; "selectOnly": { "alias": "selectOnly"; "required": false; }; "vertexTools": { "alias": "vertexTools"; "required": false; }; "wandSensitivity": { "alias": "wandSensitivity"; "required": false; }; "brushSize": { "alias": "brushSize"; "required": false; }; "vertexEraserRadius": { "alias": "vertexEraserRadius"; "required": false; }; "canUndo": { "alias": "canUndo"; "required": false; }; "canRedo": { "alias": "canRedo"; "required": false; }; }, { "openRegionEditor": "openRegionEditor"; "toggleDragMode": "toggleDragMode"; "undoRegion": "undoRegion"; "redoRegion": "redoRegion"; "deleteRegion": "deleteRegion"; "wandSensitivityChange": "wandSensitivityChange"; "brushSizeChange": "brushSizeChange"; "vertexEraserRadiusChange": "vertexEraserRadiusChange"; }, never, never, true, never>;
+}

package/lib/toolbar/segmentation/cell-segment-tool.service.d.ts

@@ -1,6 +1,4 @@
-import { BehaviorSubject } from 'rxjs';
-import { WandService } from '../wand/wand.service';
-import { WandToolHost } from '../wand/wand-tool.service';
+import { CanvasToolHost } from '../tool-kit/canvas-tool';
 import { ICellSegmenter } from '../../contracts/cell-segmenter.contract';
 import * as i0 from "@angular/core";
 /**
@@ -14,19 +12,17 @@ import * as i0 from "@angular/core";
  * box prompt, so the box just bounds the crop it segments automatically.
  */
 export declare class CellSegmentToolService {
-    private wandService;
-    private host;
-    readonly status$: BehaviorSubject<string>;
-    readonly busy$: BehaviorSubject<boolean>;
-    readonly progress$: BehaviorSubject<number>;
-    constructor(wandService: WandService);
-    bindHost(host: WandToolHost): void;
+    private readonly state;
+    readonly status$: import("rxjs").BehaviorSubject<string>;
+    readonly busy$: import("rxjs").BehaviorSubject<boolean>;
+    readonly progress$: import("rxjs").BehaviorSubject<number>;
     /**
-     * Crop + cellpose-segment every rectangle; append the cell regions and drop
-     * the prompt rectangles that produced cells. Returns the number of regions added.
+     * Crop + cellpose-segment every rectangle of the backend behind `host`; append
+     * the cell regions and drop the prompt rectangles that produced cells. Returns
+     * the number of regions added; 0 (ignored) while a previous run is still going.
+     * The host is passed per run, so no backend's host outlives its call.
      */
-    segmentBoxes(segmenter: ICellSegmenter): Promise<number>;
-    private makeRegion;
+    segmentBoxes(host: CanvasToolHost, segmenter: ICellSegmenter): Promise<number>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CellSegmentToolService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CellSegmentToolService>;
 }

package/lib/toolbar/segmentation/cellpose-segmenter.service.d.ts

@@ -17,8 +17,17 @@ import * as i0 from "@angular/core";
 export declare class CellposeSegmenterService implements ICellSegmenter {
     private instance;
     private loading;
+    /** Bumped by {@link setModelUrl}, so a load of the previous URL is discarded. */
+    private generation;
     private modelUrl;
-    /** Point the segmenter at a different hosted CPSAM ONNX (before first use). */
+    /** Every in-flight caller's callbacks: one shared load reports to all of them. */
+    private readonly progressListeners;
+    private readonly statusListeners;
+    /**
+     * Point the segmenter at a different hosted CPSAM ONNX. Changing the URL after
+     * the model loaded (or while it loads) disposes it, so the next run loads the
+     * new model instead of silently keeping the old one.
+     */
     setModelUrl(url: string): void;
     segmentCells(image: {
         data: Uint8ClampedArray;
@@ -27,7 +36,8 @@ export declare class CellposeSegmenterService implements ICellSegmenter {
     }, progress?: CellSegmentProgress): Promise<CellSegmentation>;
     /**
      * The shared Cellpose instance, lazily created on first use and reused
-     * thereafter (deduped across concurrent callers). Exposed so a host pipeline
+     * thereafter (deduped across concurrent callers, each of which receives the
+     * load's progress). A failed load is retried on the next call. Exposed so a host pipeline
      * engine can run richer `segment()` options on the same instance. `onProgress`
      * reports raw downloaded/total bytes (`total` is null when unknown); `onStatus`
      * reports worker-init phase strings.

package/lib/toolbar/segmentation/onnx-sam-session.d.ts

@@ -1,15 +1,30 @@
 import { ISamSession, SamEmbedding, SamMaskResult, SamModelDef, SamPrompt } from '../../contracts/sam.contract';
+/**
+ * onnxruntime-web implementation of {@link ISamSession} (jit-ui#90), with two
+ * execution modes chosen per model:
+ *
+ *  - **in-process** (main thread) — for small WASM models flagged `inProcess`
+ *    (e.g. micro-sam ViT-T). Fast load + inference with no Web Worker spawn /
+ *    second ORT runtime / message round-trips; the brief encode runs on the main
+ *    thread (fine for a tiny model).
+ *  - **worker** — for WebGPU models (e.g. ViT-B, patho-sam fp16) whose heavy
+ *    encode would otherwise freeze the tab. Runs in {@link ./onnx-sam.worker} so
+ *    the UI stays responsive (the spinner animates).
+ *
+ * Both modes share their inference math via {@link ./sam-onnx-core}. Lazy-imported
+ * by the SAM tools so onnxruntime-web / the worker never load in unit tests or
+ * the initial bundle.
+ */
 export declare class OnnxSamSession implements ISamSession {
     private mode;
     private loaded;
-    private model;
     private inputSize;
     private worker;
-    private seq;
-    private readonly pending;
+    private readonly calls;
     private encoder;
     private decoder;
     private nextToken;
+    /** The few most recently used embeddings, by token (one per recently viewed image). */
     private readonly embeddings;
     loadModel(model: SamModelDef, onProgress?: (fraction: number) => void): Promise<void>;
     isLoaded(): boolean;
@@ -19,7 +34,11 @@ export declare class OnnxSamSession implements ISamSession {
         height: number;
     }): Promise<SamEmbedding>;
     decode(embedding: SamEmbedding, prompt: SamPrompt): Promise<SamMaskResult>;
+    /** Release the worker / ORT sessions. Calls still in flight reject (RT-8), so
+     *  their callers' `finally` blocks run (e.g. a tool's busy flag clears). */
     dispose(): void;
     private ensureWorker;
+    /** Terminate the worker (if any) and reject every call still waiting on it. */
+    private dropWorker;
     private call;
 }

package/lib/toolbar/segmentation/pending-calls.d.ts

@@ -0,0 +1,31 @@
+/** A reply from the SAM worker: progress for, or the result of, call `id`. */
+export interface WorkerReply {
+    id: number;
+    type: string;
+    /** Present on `type: 'progress'` replies. */
+    fraction?: number;
+    /** Present on `type: 'error'` replies. */
+    error?: string;
+    [key: string]: unknown;
+}
+/**
+ * Request/response bookkeeping for a worker RPC: each call gets an id and a
+ * promise that its reply settles. Every exit path (dispose, a worker crash)
+ * must {@link rejectAll}, or awaiting callers never reach their `finally` and a
+ * tool's busy flag sticks forever (RT-8).
+ */
+export declare class PendingCalls {
+    private seq;
+    private readonly pending;
+    /** Calls still awaiting a reply. */
+    get size(): number;
+    /** Register a new call; post the message with the returned id. */
+    open(onProgress?: (fraction: number) => void): {
+        id: number;
+        promise: Promise<WorkerReply>;
+    };
+    /** Route a worker reply to its call: progress, error or result. */
+    handle(reply: WorkerReply): void;
+    /** Reject every pending call with `err` and forget them. */
+    rejectAll(err: Error): void;
+}