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

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

@@ -4,6 +4,7 @@ import { Region, Rectangle, Polygon, MultiPolygon } from '../models/region';
 import { VisualizerStore } from './visualizer-store.service';
 import { IRegionStore } from '../contracts/visualizer.contract';
 import { IRegionEditApi } from '../contracts/region-store.contract';
+import { StackSaveLayout } from './region-scope-cache';
 import * as i0 from "@angular/core";
 /**
  * Backend-neutral region store — the single source of truth for region state.
@@ -21,45 +22,33 @@ import * as i0 from "@angular/core";
  *  - {@link IRegionEditApi} — Region-native geometry edits (move/resize, and
  *    add/delete/move vertex) the OSD overlay drives.
  *
+ * Copy-on-write (review RT-13): no operation changes a stored {@link Region}
+ * (or the regions array) in place. An edit builds a replacement — the geometry
+ * through the pure `models/polygon-edit` functions — and swaps it in, so the
+ * undo history ({@link RegionHistory}) can keep shallow snapshots that share
+ * every untouched region instead of deep-cloning the whole set per step.
+ * Callers must follow the same rule with the instances {@link getRegions}
+ * returns: treat them as read-only, and commit a changed copy.
+ *
  * Classification colours live in {@link VisualizerStore} (shared by both
- * backends); GeoJSON import/export and the closed-polygon projection reuse the
- * neutral {@link PlotUtilities} helpers. All coordinates are image pixels.
+ * backends); GeoJSON import/export is `models/region-geojson`. All coordinates
+ * are image pixels.
  */
 export declare class RegionStore implements IRegionStore, IRegionEditApi {
     private store;
     private static readonly UNDO_LIMIT;
     private static readonly UNDO_COALESCE_MS;
-    /** Per-image region cache. `regions` is always a snapshot of the entry for
-     *  `currentImageKey`. */
-    private regionsByImageKey;
-    private currentImageKey;
     /** The current image's regions — the live, edited array. */
     private regions;
-    /** Last saved snapshot, restorable via plotPreviousShapes(). */
-    private previousRegions;
     /**
      * Undo/redo history (jit-ui#85): up to {@link UNDO_LIMIT} snapshots of the
-     * region set, each a deep clone captured immediately *before* a
-     * region-editing action. {@link undo} pops the newest off `undoStack`, pushes
-     * the current state onto `redoStack`, and restores it — so it can be invoked
-     * up to {@link UNDO_LIMIT} times in a row. {@link redo} is the mirror. Any new
-     * region action clears `redoStack` (the redo future is no longer reachable).
-     *
-     * A continuous gesture (a wand/brush/vertex drag commits to the store many
-     * times) is coalesced into a single entry: the first commit of a burst
-     * captures the pre-burst state and every commit within
-     * {@link UNDO_COALESCE_MS} of the previous one is folded into it. History
-     * never crosses an image load/switch — {@link resetUndoHistory} clears it.
+     * region set, each taken just *before* a region-editing action; continuous
+     * gestures and rapid commits coalesce (see {@link RegionHistory}). Snapshots
+     * are shallow — the regions array as it was — which is safe because nothing
+     * here mutates a region or an array in place (RT-13). History never crosses an
+     * image load/switch — {@link resetUndoHistory} clears it.
      */
-    private undoStack;
-    private redoStack;
-    /** True while a coalescing burst is open (further commits fold into it). */
-    private undoBurstOpen;
-    private undoBurstTimer;
-    /** True while restoring a snapshot, so the restore records no new history. */
-    private restoringUndo;
-    private readonly canUndo$;
-    private readonly canRedo$;
+    private readonly history;
     /** Monotonic id source — ids never repeat within the service lifetime, so
      *  selection stays correct across delete/add cycles even when names collide. */
     private nextId;
@@ -68,39 +57,27 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
     private fillColor;
     private isRegionSavedOn;
     /**
-     * Per-slice region support for z-stacks (jit-ui#93). While {@link stackMode}
-     * is on (a z-stack is loaded), the live `regions` array always holds ONE
-     * slice — the {@link currentSliceZ} slice — so the on-canvas overlays, the
-     * selection projection, and the Regions table keep working unchanged
-     * (they all read {@link getRegions}). The other slices live in
-     * {@link regionsBySlice}; {@link setDisplaySlice} swaps the live set on scrub
-     * and {@link getSliceRegions} flattens every slice (each tagged with its
-     * zero-based {@link Region.z}) for save/export. Off by default (stackMode
-     * false, z 0), so single-plane images are completely unaffected.
+     * Per-image cache and, for z-stacks, per-slice regions (jit-ui#93). In stack
+     * mode the live `regions` array holds ONE slice — the display slice — so the
+     * overlays, the selection projection and the Regions table work unchanged
+     * (they all read {@link getRegions}); {@link setDisplaySlice} swaps the live
+     * set on scrub and {@link getSliceRegions} flattens every slice (each tagged
+     * with its zero-based {@link Region.z}) for save/export. Off by default, so
+     * single-plane images are unaffected.
      */
-    private regionsBySlice;
-    private stackMode;
-    private currentSliceZ;
-    /** How a stack's regions round-trip to disk (jit-ui#93): `combined` writes one
-     *  z-indexed geojson (single-file z-stack, QuPath schema); `per-slice-file`
-     *  writes one geojson per slice-file (a folder of numbered images). */
-    private stackSaveLayout;
-    /** Slices that were loaded with regions (jit-ui#93). A per-slice-file save
-     *  re-writes these even when now empty, so clearing a slice's regions and
-     *  saving removes its previously-saved geojson (writes an empty one). */
-    private stackInitialNonEmpty;
-    /** Selection is tracked by region *id* internally (stable across edits) and
-     *  projected to array indices on the IRegionStore boundary. */
-    private selectedIds;
-    private readonly selectedIndices$;
+    private readonly scope;
+    /** Selection by region *id* (stable across edits), projected to array
+     *  indices on the IRegionStore boundary. */
+    private readonly selection;
     private readonly regionUpdate$;
     /** Non-coalesced sibling of regionUpdate$: fires on every change even during a
      *  batched drag, so live consumers (intensity inset) update per frame. */
     private readonly regionLiveEdit$;
+    /** See {@link getRegionSetReplaced$}. */
+    private readonly regionSetReplaced$;
     /** Emit coalescing for live drags (see IRegionEditApi.beginBatch). */
     private batchDepth;
     private pendingEmit;
-    private readonly plotUtilities;
     constructor(store: VisualizerStore);
     /**
      * Replace (or, with `append`, add to) the current image's regions. Mints ids
@@ -109,7 +86,14 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
      * not stored — mirrors the previous Plotly behaviour.
      */
     setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean, fillColor?: string, append?: boolean): void;
-    /** The canonical accessor: current image's regions (live instances). */
+    /**
+     * The canonical accessor: the current image's regions. A fresh array, but the
+     * instances are the stored ones, shared with the undo history: treat them as
+     * read-only and change a region through the store's operations (or by
+     * committing a copy). Typed `Region[]` rather than
+     * `ReadonlyArray<Readonly<Region>>` because the IRegionStore contract and the
+     * backends still take a mutable array.
+     */
     getRegions(): Region[];
     /** True while a z-stack is loaded and the store holds regions per slice. */
     isStackMode(): boolean;
@@ -118,7 +102,7 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
     /** How the current stack persists to disk (jit-ui#93): `combined` = one
      *  z-indexed geojson (single-file z-stack); `per-slice-file` = one geojson per
      *  slice-file (folder stack). Meaningless outside stack mode. */
-    getStackSaveLayout(): 'combined' | 'per-slice-file';
+    getStackSaveLayout(): StackSaveLayout;
     /**
      * Enter per-slice stack mode. `slices` maps each zero-based slice index to
      * the regions imported for that slice; the store makes `initialZ`'s slice the
@@ -128,9 +112,11 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
      * every slice for save/export. Ids/names/classification colours are minted
      * exactly as {@link setRegions} does.
      */
-    enterStackMode(slices: Map<number, Region[]>, initialZ?: number, saveLayout?: 'combined' | 'per-slice-file'): void;
+    enterStackMode(slices: Map<number, Region[]>, initialZ?: number, saveLayout?: StackSaveLayout): void;
     /** Leave stack mode (single-plane image, or the stack was closed). */
     exitStackMode(): void;
+    /** The live-set swap of {@link setDisplaySlice}. */
+    private showSlice;
     /**
      * Show a different slice: capture the current slice's (possibly edited)
      * regions back into the per-slice store, then load the target slice's regions
@@ -138,6 +124,8 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
      * this only records the requested slice index (a no-op otherwise: single-plane
      * regions stay on the default plane — addRegion tags Region.z only in stack
      * mode, so the recorded index is unused until a stack is entered). (jit-ui#93)
+     * Either way {@link getRegionSetReplaced$} emits: the slice on screen changed
+     * under any in-progress tool work.
      */
     setDisplaySlice(z: number): void;
     /**
@@ -157,16 +145,36 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
     /** Mint ids/names + apply classification colours + tag the slice index, as
      *  {@link setRegions} does, for regions entering the per-slice store. */
     private normalizeSlice;
+    /**
+     * Regions entering the store: mint ids and default names, hydrate JSON bounds
+     * into class instances — everything downstream (rendering, geometry de-dup,
+     * moveRegion, GeoJSON export) discriminates them with `instanceof`
+     * (jit-ui#124) — and apply classification colours. A region that is new to
+     * the store (no id yet) is completed in place; one that already has an id may
+     * be a stored instance shared with the undo history, so it is copied if it
+     * changes.
+     */
+    private admit;
     /**
      * Closed polygons projected for image-processing consumers (segmentation,
-     * trace builders). Open polylines are annotation-only and excluded. Reuses
-     * the neutral PlotUtilities projection so output matches the previous path.
+     * crop requests, trace builders), straight from each region's bounds: a
+     * rectangle's corners, a polygon with its holes (a bézier as its curve), one
+     * polygon per part of a multi-polygon. Open polylines are annotation-only and
+     * excluded. Coordinates are rounded to whole pixels.
      */
-    getRegionPolygons(): any[];
+    getRegionPolygons(): Polygon[];
     getRegionUpdateEvent(): Observable<any[]>;
     /** Live (non-coalesced) region-change stream — fires per frame during a drag.
      *  Used by the intensity-profile inset so it tracks line ROIs live. */
     getRegionLiveEdit$(): Observable<Region[]>;
+    /**
+     * Emits after every {@link undo}, {@link redo} and {@link setDisplaySlice} call
+     * (even one that changed nothing): the region set was replaced under whatever
+     * a canvas tool was building on (a brush stroke, a SAM point prompt), so the
+     * backends reset their canvas tools on it. Not emitted for ordinary edits —
+     * a tool's own commit must not reset it.
+     */
+    getRegionSetReplaced$(): Observable<void>;
     /** Select regions by array index (or [] to clear). Stored internally by id
      *  so the selection survives subsequent edits/reorders. */
     setSelectedShapeIndices(indices: number[]): void;
@@ -183,16 +191,11 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
     getShowShapeLabel(): boolean;
     getShapeColor(): string;
     getFillColor(): string;
-    /** Convenience setters (not on the contract) for toolbar wiring. */
+    /** Show or hide region labels (not on the contract; specs drive it directly).
+     *  @deprecated Nothing in the library calls it; will be removed next minor. */
     setShowShapeLabel(show: boolean): void;
-    setShapeColor(color: string): void;
-    setFillColor(color: string): void;
     getClassificationColors(): Map<string, string>;
     setClassificationColor(label: string, color: string): void;
-    /** Re-show the last saved snapshot (transient — does not alter stored state). */
-    plotPreviousShapes(): void;
-    setPreviousShapes(shapes: any[]): void;
-    getPreviousShapes(): any[];
     /** Emits whether an undo step is currently available — drives the toolbar
      *  Undo button's enabled state (greyed out when false). */
     getCanUndo$(): Observable<boolean>;
@@ -224,35 +227,32 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
      *  crosses images). */
     resetUndoHistory(): void;
     /** Make `snapshot` the live region set and notify both backends. Shared by
-     *  {@link undo} and {@link redo}; the snapshot is already a detached deep
-     *  clone, so it becomes the live array directly. */
+     *  {@link undo} and {@link redo}; nothing records history while it runs. */
     private restoreSnapshot;
     /**
      * Capture the pre-action region set into the bounded undo history. Called at
-     * the top of every mutating operation, *before* it changes `regions`, so the
-     * snapshot is the state to return to. Rapid commits from one gesture coalesce
-     * into a single entry (see {@link undoStack}). A fresh action also abandons
-     * any redo future.
+     * the top of every mutating operation, *before* it changes `regions`. The
+     * snapshot is the array itself: every operation replaces `regions` (and any
+     * region it edits) rather than changing them, so it never changes after this.
      */
     private recordUndoSnapshot;
-    /** Push the current can-undo / can-redo availability to subscribers. */
-    private emitUndoState;
-    /** (Re)arm the idle timer that closes the current coalescing burst. */
-    private armUndoBurst;
-    private closeUndoBurst;
-    private cloneRegions;
-    /** Deep clone a region so an in-place geometry edit can't mutate a stored
-     *  history snapshot (bounds are cloned via {@link cloneBounds}). */
-    private cloneRegion;
     importRegions(geoJsonStr: string): Region[];
-    exportRegions(regions: Region[]): void;
+    /** Download `regions` as GeoJSON, named after `fileName` (extension
+     *  replaced by `.geojson`) or `rois.geojson` without one. */
+    exportRegions(regions: Region[], fileName?: string): void;
     getGeoJsonString(regions: Region[]): string;
     addRegion(region: Region): number;
     removeRegion(id: number): void;
+    /**
+     * Remove the regions with these ids, if present. With `{ recordUndo: false }`
+     * no undo step is taken — for clearing transient shapes that were never the
+     * user's work (the 3D view's screen-space lassos on an orbit, NAPARI-SVC-11).
+     */
+    removeRegions(ids: Iterable<number>, opts?: {
+        recordUndo?: boolean;
+    }): void;
     updateBounds(id: number, bounds: Rectangle | Polygon | MultiPolygon): void;
     moveRegion(id: number, dx: number, dy: number): void;
-    /** Translate a polygon's vertices and any holes in place by (dx, dy). */
-    private translatePolygon;
     moveVertex(id: number, index: number, x: number, y: number): void;
     /** Move a vertex on a polygon's interior ring (hole) — jit-ui#85. */
     moveHoleVertex(id: number, holeIndex: number, index: number, x: number, y: number): void;
@@ -266,50 +266,42 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
     addVertex(id: number, segIndex: number, x: number, y: number): void;
     deleteVertex(id: number, index: number): void;
     setBezier(id: number, bezier: boolean): void;
-    /** Turn bezier on (and seed editable handles from the smooth default) or off
-     *  (and drop the handles). */
-    private applyBezier;
-    /** (Re)seed per-hole bezier handles from the Catmull-Rom default, parallel to `poly.holes`. */
-    private seedHoleHandles;
     /** Drag a bezier control point on a hole ring vertex (donut bezier editing). */
     moveHoleBezierHandle(id: number, holeIndex: number, index: number, side: 'in' | 'out', x: number, y: number): void;
     moveBezierHandle(id: number, index: number, side: 'in' | 'out', x: number, y: number): void;
+    /** Apply a copy-on-write polygon edit to region `id`: record, swap in, emit. */
+    private editPolygon;
+    /** Swap `next` in for the stored region with its id (a new array), then sync and emit. */
+    private replaceRegion;
+    /** Coalesce `regionUpdate$` until the matching {@link endBatch} (live drags);
+     *  the batch is also one undo gesture ({@link beginGesture}). */
     beginBatch(): void;
     endBatch(): void;
+    /**
+     * Mark the start of one user gesture (e.g. a wand/brush mousedown): every
+     * commit until the matching {@link endGesture} becomes a single undo step,
+     * without delaying `regionUpdate$` (tools render through it while dragging).
+     * Calls nest. A gesture never folds into an earlier timed burst.
+     */
+    beginGesture(): void;
+    /** End the gesture opened by {@link beginGesture}; the next commit starts a new step. */
+    endGesture(): void;
     /**
      * Switch the active image: snapshot the outgoing regions, restore the
      * incoming image's (or [] if none), clear selection, and notify. Idempotent
      * for the same image (so repeated replots of one image keep its regions).
      */
     setActiveImage(imageInfo: IImageInfo): void;
-    /** Drop the entire per-image cache (logout / project switch). */
-    clearRegionsByImageKey(): void;
-    private deriveImageKey;
-    /**
-     * Resolve each region's colour from the annotation-class preset set (jit-ui#70).
-     * The presets are the source of truth for colour — this **overrides any colour
-     * embedded in the GeoJSON** (which the YOLO worker writes today). A matching
-     * preset gives the class colour; an unknown class gets a deterministic fallback
-     * colour (and, only when `autoPromote` is on, is added to the editable list).
-     * Regions the user explicitly recoloured (`colorOverridden`) are left untouched.
-     */
-    private applyClassificationColors;
+    /** Apply the preset set's class colours (see {@link applyPresetColors}),
+     *  promoting unknown classes into the shared store when the set asks for it. */
+    private withClassificationColors;
     private syncCache;
     private emit;
-    /** Project selected ids to current array indices, pruning ids that no longer
-     *  exist, and emit if the index set changed. */
+    /** Project the selected ids onto the current regions (pruning gone ones);
+     *  emits only if the index set changed. */
     private emitSelection;
-    private indicesEqual;
     private findById;
     private indexOfId;
-    /** The region's bounds as a Polygon, or undefined if it isn't a polygon. */
-    private polygonOf;
-    private clonePolygon;
-    private cloneBounds;
-    private regionsEqual;
-    private polygonsEqual;
-    /** Compare two polygons' interior-ring (hole) sets for the dedupe path. */
-    private holesEqual;
     static ɵfac: i0.ɵɵFactoryDeclaration<RegionStore, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<RegionStore>;
 }

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,6 +31,8 @@ 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;
@@ -48,17 +44,7 @@ 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;
     private normalizePresetSet;
     /** Queue a debounced save. No-ops until the initial load resolves (and when no port is bound). */
@@ -86,7 +72,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,
@@ -125,19 +120,13 @@ export declare class VisualizerStore {
     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";