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

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

@@ -3,8 +3,17 @@ import { IImageInfo } from '../contracts/image.contract';
 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 { IRegionEditApi, IRegionSourceApi } from '../contracts/region-store.contract';
+import type { Mesh } from 'napari-js/geometry';
+import { SliceOutlines } from '../geometry/reconstruct';
+import { StackSaveLayout } from './region-scope-cache';
+import { RegionSourceOpener, RegionSourceSlices } from './region-source-scope';
+import type { RegionSource, RegionSourceView } from '../region-source/region-source';
+import type { RegionIndexPage, RegionIndexQuery } from '../region-source/region-tiles';
+import { RegionStyle } from '../region-overlay/region-style';
 import * as i0 from "@angular/core";
+/** Selecting classes takes at most this many region-source features into the regions. */
+export declare const SELECT_CLASSES_LIMIT = 5000;
 /**
  * Backend-neutral region store — the single source of truth for region state.
  *
@@ -21,45 +30,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 {
+export declare class RegionStore implements IRegionStore, IRegionEditApi, IRegionSourceApi {
     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.
-     */
-    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$;
+     * 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 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 +65,56 @@ 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.
-     */
-    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$;
+     * 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 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;
+    /**
+     * Large region sets held as tiled region sources rather than as regions (see
+     * {@link attachRegionSource}): per image and slice, with the ids taken out of each.
+     */
+    private readonly sources;
+    private readonly sourceView$;
+    /** The region look the user chose (overrides the source's hint), field by field. */
+    private userStyle;
+    /** The current source's style hint. */
+    private hintStyle;
+    private readonly regionStyle$;
+    /** Bumped on every change of the slice's source, so a late open is dropped. */
+    private sourceGeneration;
+    /** The source last published as the view: a source shown again does not turn the labels back on. */
+    private shownSource;
+    /** Bumped when a region source is attached or dropped: what is read from the sources is stale. */
+    private sourcesVersion;
+    /**
+     * The region sources' part of {@link classVolumes}, by class and what the sources hold (see
+     * {@link sourceStateKey}): an edit of the regions leaves it, so the volumes of a slice being drawn
+     * on cost no source reads.
+     */
+    private readonly sourceVolumeCache;
+    /** The region sources' outlines of the class sets reconstructed last (see {@link sourceOutlines}). */
+    private readonly sourceOutlineCache;
+    /** The classes hidden from view (names as given); every class is shown at first. */
+    private readonly hiddenClasses$;
+    /** {@link hiddenClasses$} by {@link presetKey}, as a region's label is matched. */
+    private hiddenKeys;
     constructor(store: VisualizerStore);
     /**
      * Replace (or, with `append`, add to) the current image's regions. Mints ids
@@ -109,7 +123,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 +139,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 +149,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 +161,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 +182,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 +228,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 +264,36 @@ 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;
+    /** The state an undo step restores. */
+    private snapshot;
+    /** Parse GeoJSON into regions, remembering the class colours the file carries so they are
+     *  kept for classes with no preset (see VisualizerStore.rememberImportedClassColors). */
     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 +307,205 @@ 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;
+    /**
+     * Hold a large region set as a tiled region source instead of as regions: the backends that
+     * draw sources (OpenSeadragon, napari) draw its features at the detail the zoom shows, from
+     * the tiles in view, and a feature joins the regions — exactly, as an ordinary editable
+     * {@link Region} with its {@link Region.sourceId} — only when it is selected or edited
+     * ({@link takeSourceFeatures}). Until then {@link getRegions} does not include it.
+     *
+     * `source` may be an opener, called the first time its slice is shown (and again if the
+     * source was closed to save memory). `slices` says which slice of the current image it
+     * serves: one (default: the slice shown; plane 0 of the source), or `'planes'`, every slice z
+     * from plane z of a z-indexed source. Replaces the source those slices had.
+     */
+    attachRegionSource(source: RegionSource | RegionSourceOpener, slices?: RegionSourceSlices): void;
+    /** Drop the current image's region sources (closing them) and what was taken from them. */
+    detachRegionSources(): void;
+    /**
+     * Drop the slice's region source, for regions imported in place of the slice's (a small file
+     * replacing a large one): a source of the slice's own is detached; a z-indexed source over every
+     * slice has this slice's features taken out (as deleted). The other slices keep theirs.
+     */
+    dropSliceRegionSource(): Promise<void>;
+    /** Whether the slice shown has a region source. */
+    hasRegionSource(): boolean;
+    /** The slice's region source as a source layer draws it; null without one (or until it opens). */
+    getRegionSourceView(): RegionSourceView | null;
+    /** {@link getRegionSourceView} and every change of it (slice, taken ids, class colours). */
+    getRegionSourceView$(): Observable<RegionSourceView | null>;
+    /**
+     * Take source features into the working set for editing: their exact geometry becomes
+     * ordinary regions (minted, coloured and slice-tagged as any region entering the store) and
+     * the source stops drawing them. Not an undo step of its own — undoing past it puts the
+     * features back in the source. Resolves the region ids, in the order asked (a feature already
+     * taken resolves to its region); [] when the slice changed meanwhile.
+     */
+    takeSourceFeatures(ids: readonly string[]): Promise<number[]>;
+    /** {@link takeSourceFeatures}, then select them (added to the selection with `additive`). */
+    selectSourceFeatures(ids: readonly string[], additive?: boolean): Promise<number[]>;
+    /**
+     * Features per class still in the slice's region source (not taken); {} without one. With
+     * `stack`, a z-stack's over every slice: its source's planes, or each slice's source added up.
+     */
+    getRegionSourceClassCounts(stack?: boolean): Promise<Record<string, number>>;
+    /**
+     * Select every region of these classes on the slice — the regions', and the region source's,
+     * which are taken into the regions (at most {@link SELECT_CLASSES_LIMIT} of them). Added to the
+     * selection with `additive`. Resolves the selected region ids.
+     */
+    selectClasses(classes: readonly string[], additive?: boolean): Promise<number[]>;
+    /**
+     * The 3D reconstruction of each group of classes over every slice of the stack (an atlas
+     * structure with its substructures, say): the outlines of the regions of those classes on every
+     * slice — the region sources' and those drawn or taken — stacked and meshed in a worker. Meshes
+     * are in image px (x, y) and slice indices (z). `pixelStep` is the in-plane voxel size (image
+     * px); the outlines are read at the matching level of detail. A group with no outline gets an
+     * empty mesh.
+     */
+    reconstructClasses(groups: ReadonlyArray<{
+        key: string;
+        classes: readonly string[];
+    }>, pixelStep?: number): Promise<Array<{
+        key: string;
+        mesh: Mesh;
+    }>>;
+    /**
+     * Each class's volume over the whole stack, in px² × slices: its outlines' area on every slice
+     * (its features' union, see `outlinesArea`), one slice thick (Cavalieri's estimator), from the
+     * exact outlines. Where a feature is, a region source's or a drawn or taken region, does not
+     * change it: taking one leaves the volume as it was. The region sources' part is cached until
+     * what they hold changes (a feature taken or deleted, another source); only the slices with
+     * drawn or taken regions of the class are measured again.
+     */
+    classVolumes(classes: readonly string[]): Promise<Map<string, number>>;
+    /** The region sources' part of a class's volume, cached by what they hold (see classVolumes). */
+    private sourceVolume;
+    /**
+     * Every slice's outlines of these classes, the region sources' then the regions': closed shapes'
+     * rings, and open polylines as `lines`.
+     */
+    private classOutlines;
+    /**
+     * The region sources' outlines of these classes on every slice, without the features taken or
+     * deleted. The last few class sets are kept until what the sources hold changes: rebuilding a
+     * surface after an edit reads nothing again.
+     */
+    private sourceOutlines;
+    private readSourceOutlines;
+    /**
+     * Every class's outlines on every slice, by class: the region sources' (one read for all, kept
+     * like {@link sourceOutlines}) and the drawn and taken regions'. What a section through the
+     * stack cuts (see `geometry/section`).
+     */
+    outlinesByClass(level: number): Promise<Map<string, SliceOutlines[]>>;
+    /** The drawn and taken regions' outlines of these classes, by slice. */
+    private regionOutlines;
+    /** Each drawn or taken region's outlines (of the `wanted` classes; null: every class) with its class. */
+    private labelledRegionOutlines;
+    /** What the region sources of the image hold (see {@link sourceStateKey}): it changes when a
+     *  feature is taken or deleted, or that is undone. */
+    getSourceStateKey(): string;
+    /**
+     * What the region sources of the image hold: the image, its sources (one attached or dropped
+     * bumps the version) and the features taken from them. A key for what is read from them.
+     */
+    private sourceStateKey;
+    /** Delete source features without taking them (one undo step). */
+    deleteSourceFeatures(ids: readonly string[]): void;
+    /**
+     * A page of the slice source's features not taken from it (file order), e.g. for the Region
+     * Editor's list; an empty page without a source.
+     */
+    getRegionSourceIndex(query: Omit<RegionIndexQuery, 'exclude'>): Promise<RegionIndexPage>;
+    /**
+     * `regions` as a GeoJSON FeatureCollection string merged with the region source behind them:
+     * the source's features that were not taken (or deleted), then `regions`. Without a source,
+     * {@link getGeoJsonString}. `slice` names a folder stack's slice (default the one shown);
+     * on a z-indexed stack's source (`'planes'`) the export spans every slice.
+     */
+    getGeoJsonWithSource(regions: Region[], slice?: number): Promise<string>;
+    /**
+     * Whether a region of class `label` goes unlabelled because a subclass of it (by the region
+     * source's class hierarchy) is among the regions too — an atlas's "Isocortex" under its areas.
+     * False without a hierarchy.
+     */
+    isLabelCovered(label: string | undefined): boolean;
+    private coveredFor;
+    /** The classes hidden from view (see {@link setClassesHidden}). */
+    getHiddenClasses(): ReadonlySet<string>;
+    /** {@link getHiddenClasses} and every change of it. */
+    getHiddenClasses$(): Observable<ReadonlySet<string>>;
+    /**
+     * Hide (or show again) these classes' regions: the overlays and the region source's layer stop
+     * drawing them, and a hidden region can be neither picked nor kept selected. The regions stay in
+     * the set (the table lists them; a save keeps them).
+     */
+    setClassesHidden(classes: readonly string[], hidden: boolean): void;
+    /** Whether regions labelled `label` are hidden (an unlabelled region never is). */
+    isClassHidden(label: string | null | undefined): boolean;
+    /** The region look: outlines, or filled (an atlas's look); see `region-style`. */
+    getRegionStyle(): RegionStyle;
+    /** {@link getRegionStyle} and every change of it. */
+    getRegionStyle$(): Observable<RegionStyle>;
+    /**
+     * Choose the region look, field by field; it overrides a region source's hint for the session.
+     * The overlays redraw.
+     */
+    setRegionStyle(patch: Partial<RegionStyle>): void;
+    /** The look now: the user's choice, else the source's hint, else outlines. */
+    private effectiveStyle;
+    /** Publish the look when it changed: the overlays redraw the regions, the source layer its features. */
+    private restyle;
+    /** Re-emit the source view with the current look and label setting. */
+    private republishView;
+    /** The slice a region source is keyed by: the display slice in stack mode, else 0. */
+    private get sourceSlice();
+    private currentTaken;
+    /** Replace the slice's taken ids and tell the source layers. */
+    private setTaken;
+    /**
+     * Look up (opening it if needed) the slice's source and publish it as the source view. The view
+     * is withdrawn at once: until the incoming source opens, nothing reads, takes or deletes from the
+     * outgoing one into the slice now shown.
+     */
+    private refreshSourceView;
     /**
      * 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>;
 }