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

package/esm2022/lib/store/region-store.service.mjs

@@ -1,12 +1,74 @@
 import { Injectable } from '@angular/core';
 import { BehaviorSubject, Subject } from 'rxjs';
-import { Region, Rectangle, Polygon, MultiPolygon, hydrateBounds } from '../models/region';
-import { PlotUtilities } from '../plot.utilities';
+import { Rectangle, Polygon, hydrateBounds } from '../models/region';
+import { downloadGeoJson, featureFromRegion, regionFromGeoJsonFeature, regionsFromGeoJson, regionsToGeoJson, } from '../models/region-geojson';
 import { VisualizerStore } from './visualizer-store.service';
-import { defaultHandleOffsets } from '../models/bezier';
-import { findPreset, fallbackColorFor } from './class-color.util';
+import { applyPresetColors, colorForLabel, presetKey } from './class-color.util';
+import { cloneBounds, makePolygon, rectToRing, regionPolygons, regionPolylines, replaceBounds, } from '../models/polygon-factory';
+import { outlinesArea } from '../geometry/reconstruct';
+import { reconstructInWorker } from '../region-source/worker-region-source';
+import * as edit from '../models/polygon-edit';
+import { regionsEqual, withRegionPatch, withRegionZ } from '../models/region-clone';
+import { RegionHistory } from './region-history';
+import { RegionSelection } from './region-selection';
+import { RegionScopeCache } from './region-scope-cache';
+import { RegionSourceScope } from './region-source-scope';
+import { DEFAULT_REGION_STYLE } from '../region-overlay/region-style';
 import * as i0 from "@angular/core";
 import * as i1 from "./visualizer-store.service";
+/** Selecting classes takes at most this many region-source features into the regions. */
+export const SELECT_CLASSES_LIMIT = 5000;
+/** Class sets whose region-source outlines are kept for rebuilding their surfaces. */
+const SOURCE_OUTLINE_CACHE_SIZE = 8;
+/** Classes whose region-source part of the volume is kept (see RegionStore.classVolumes). */
+const SOURCE_VOLUME_CACHE_SIZE = 64;
+/**
+ * Feature ids unique across outlines read from several places: each call gives one part's
+ * renumbering of its own ids (a part without them is one feature).
+ */
+function featureIds() {
+    let next = 0;
+    return () => {
+        const ids = new Map();
+        return (own) => {
+            let id = ids.get(own);
+            if (id === undefined)
+                ids.set(own, (id = next++));
+            return id;
+        };
+    };
+}
+/** A slice's parts as outlines. */
+function sliceOutlines(z, s) {
+    return {
+        z,
+        rings: s.rings,
+        ...(s.rings.length ? { ringGroups: s.ringGroups } : {}),
+        ...(s.lines.length ? { lines: s.lines } : {}),
+    };
+}
+/**
+ * Outlines by slice merged into one entry per slice (rings, then lines), in slice order, each
+ * part's features apart from the others' (they fill as their union).
+ */
+function mergeOutlines(parts) {
+    const byZ = new Map();
+    const nextPart = featureIds();
+    for (const part of parts) {
+        if (!part.rings.length && !part.lines?.length)
+            continue;
+        let slice = byZ.get(part.z);
+        if (!slice)
+            byZ.set(part.z, (slice = { rings: [], ringGroups: [], lines: [] }));
+        const id = nextPart();
+        part.rings.forEach((r, i) => {
+            slice.rings.push(r);
+            slice.ringGroups.push(id(part.ringGroups?.[i]));
+        });
+        slice.lines.push(...(part.lines ?? []));
+    }
+    return Array.from(byZ, ([z, s]) => sliceOutlines(z, s)).sort((a, b) => a.z - b.z);
+}
 /**
  * Backend-neutral region store — the single source of truth for region state.
  *
@@ -23,45 +85,34 @@ import * as i1 from "./visualizer-store.service";
  *  - {@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 class RegionStore {
     static { this.UNDO_LIMIT = 10; }
     static { this.UNDO_COALESCE_MS = 250; }
     constructor(store) {
         this.store = store;
-        /** Per-image region cache. `regions` is always a snapshot of the entry for
-         *  `currentImageKey`. */
-        this.regionsByImageKey = new Map();
         /** The current image's regions — the live, edited array. */
         this.regions = [];
-        /** Last saved snapshot, restorable via plotPreviousShapes(). */
-        this.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.
          */
-        this.undoStack = [];
-        this.redoStack = [];
-        /** True while a coalescing burst is open (further commits fold into it). */
-        this.undoBurstOpen = false;
-        this.undoBurstTimer = null;
-        /** True while restoring a snapshot, so the restore records no new history. */
-        this.restoringUndo = false;
-        this.canUndo$ = new BehaviorSubject(false);
-        this.canRedo$ = new BehaviorSubject(false);
+        this.history = new RegionHistory(RegionStore.UNDO_LIMIT, RegionStore.UNDO_COALESCE_MS);
         /** Monotonic id source — ids never repeat within the service lifetime, so
          *  selection stays correct across delete/add cycles even when names collide. */
         this.nextId = 1;
@@ -70,39 +121,61 @@ export class RegionStore {
         this.fillColor = '#ff00ff';
         this.isRegionSavedOn = true;
         /**
-         * 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.
          */
-        this.regionsBySlice = new Map();
-        this.stackMode = false;
-        this.currentSliceZ = 0;
-        /** 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). */
-        this.stackSaveLayout = 'combined';
-        /** 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). */
-        this.stackInitialNonEmpty = new Set();
-        /** Selection is tracked by region *id* internally (stable across edits) and
-         *  projected to array indices on the IRegionStore boundary. */
-        this.selectedIds = [];
-        this.selectedIndices$ = new BehaviorSubject([]);
+        this.scope = new RegionScopeCache();
+        /** Selection by region *id* (stable across edits), projected to array
+         *  indices on the IRegionStore boundary. */
+        this.selection = new RegionSelection();
         this.regionUpdate$ = new Subject();
         /** Non-coalesced sibling of regionUpdate$: fires on every change even during a
          *  batched drag, so live consumers (intensity inset) update per frame. */
         this.regionLiveEdit$ = new Subject();
+        /** See {@link getRegionSetReplaced$}. */
+        this.regionSetReplaced$ = new Subject();
         /** Emit coalescing for live drags (see IRegionEditApi.beginBatch). */
         this.batchDepth = 0;
         this.pendingEmit = false;
-        this.plotUtilities = new 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.
+         */
+        this.sources = new RegionSourceScope();
+        this.sourceView$ = new BehaviorSubject(null);
+        /** The region look the user chose (overrides the source's hint), field by field. */
+        this.userStyle = {};
+        this.regionStyle$ = new BehaviorSubject(DEFAULT_REGION_STYLE);
+        /** Bumped on every change of the slice's source, so a late open is dropped. */
+        this.sourceGeneration = 0;
+        /** The source last published as the view: a source shown again does not turn the labels back on. */
+        this.shownSource = null;
+        /** Bumped when a region source is attached or dropped: what is read from the sources is stale. */
+        this.sourcesVersion = 0;
+        /**
+         * 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.
+         */
+        this.sourceVolumeCache = new Map();
+        /** The region sources' outlines of the class sets reconstructed last (see {@link sourceOutlines}). */
+        this.sourceOutlineCache = new Map();
+        /** The classes hidden from view (names as given); every class is shown at first. */
+        this.hiddenClasses$ = new BehaviorSubject(new Set());
+        /** {@link hiddenClasses$} by {@link presetKey}, as a region's label is matched. */
+        this.hiddenKeys = new Set();
+        this.coveredFor = null;
+        // A class colour change recolours the source's features as it recolours regions.
+        this.store.getPresetSet$().subscribe(() => {
+            const view = this.sourceView$.value;
+            if (view)
+                this.sourceView$.next({ ...view });
+        });
     }
     // ── IRegionStore: CRUD ─────────────────────────────────────────────────
     /**
@@ -118,26 +191,19 @@ export class RegionStore {
             isRegionSaveOn = this.isRegionSavedOn;
         if (fillColor === undefined)
             fillColor = this.fillColor;
-        for (const region of regions) {
-            if (region.id == null)
-                region.id = this.nextId++;
-            if (region.name == null)
-                region.name = `shape${region.id}`;
-            // JSON in, class instances out — everything downstream (the overlays'
-            // rendering, geometry de-dup, moveRegion, GeoJSON export) discriminates
-            // the bounds with `instanceof` (jit-ui#124).
-            region.bounds = hydrateBounds(region.bounds);
-        }
-        this.applyClassificationColors(regions);
+        regions = this.admit(regions);
         this.isRegionSavedOn = isRegionSaveOn;
         if (isRegionSaveOn) {
             this.recordUndoSnapshot();
-            this.showShapeLabel = showRegionLabel;
+            if (this.showShapeLabel !== showRegionLabel) {
+                this.showShapeLabel = showRegionLabel;
+                this.republishView();
+            }
             this.fillColor = fillColor;
             if (append) {
                 // Reject by id collision (already tracked) or geometry equality (same
                 // coordinates) — the find button can push the same region repeatedly.
-                const added = regions.filter(r => !this.regions.some(existing => existing.id === r.id || this.regionsEqual(existing, r)));
+                const added = regions.filter((r) => !this.regions.some((existing) => existing.id === r.id || regionsEqual(existing, r)));
                 this.regions = this.regions.concat(added);
             }
             else {
@@ -152,19 +218,32 @@ export class RegionStore {
             this.regionUpdate$.next(regions.slice());
         }
     }
-    /** 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() {
         return this.regions.slice();
     }
     // ── Per-slice regions for z-stacks (jit-ui#93) ─────────────────────────
     /** True while a z-stack is loaded and the store holds regions per slice. */
-    isStackMode() { return this.stackMode; }
+    isStackMode() {
+        return this.scope.stackMode;
+    }
     /** The current display slice (zero-based). */
-    getDisplaySlice() { return this.currentSliceZ; }
+    getDisplaySlice() {
+        return this.scope.displaySlice;
+    }
     /** 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() { return this.stackSaveLayout; }
+    getStackSaveLayout() {
+        return this.scope.saveLayout;
+    }
     /**
      * 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
@@ -175,33 +254,34 @@ export class RegionStore {
      * exactly as {@link setRegions} does.
      */
     enterStackMode(slices, initialZ = 0, saveLayout = 'combined') {
-        this.stackMode = true;
-        this.stackSaveLayout = saveLayout;
-        this.currentSliceZ = initialZ || 0;
-        this.regionsBySlice = new Map();
-        this.stackInitialNonEmpty = new Set();
-        for (const [z, regs] of slices) {
-            const normalized = this.normalizeSlice(regs || [], z);
-            this.regionsBySlice.set(z, normalized);
-            if (normalized.length)
-                this.stackInitialNonEmpty.add(z);
-        }
-        this.regions = (this.regionsBySlice.get(this.currentSliceZ) ?? []).slice();
-        this.previousRegions = this.regions.slice();
-        this.selectedIds = [];
+        const admitted = new Map();
+        for (const [z, regs] of slices)
+            admitted.set(z, this.normalizeSlice(regs || [], z));
+        this.regions = this.scope.enterStack(admitted, initialZ, saveLayout);
+        this.selection.replace([]);
         this.syncCache();
         this.resetUndoHistory();
         this.emitSelection();
         this.emit();
+        this.refreshSourceView();
     }
     /** Leave stack mode (single-plane image, or the stack was closed). */
     exitStackMode() {
-        if (!this.stackMode)
+        this.scope.exitStack();
+        this.refreshSourceView();
+    }
+    /** The live-set swap of {@link setDisplaySlice}. */
+    showSlice(z) {
+        const next = this.scope.showSlice(z, this.regions);
+        if (!next)
             return;
-        this.stackMode = false;
-        this.currentSliceZ = 0;
-        this.regionsBySlice = new Map();
-        this.stackInitialNonEmpty = new Set();
+        this.regions = next;
+        this.selection.replace([]);
+        this.syncCache();
+        this.resetUndoHistory();
+        this.emitSelection();
+        this.emit();
+        this.refreshSourceView();
     }
     /**
      * Show a different slice: capture the current slice's (possibly edited)
@@ -210,24 +290,12 @@ export class RegionStore {
      * 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) {
-        const next = z || 0;
-        if (!this.stackMode) {
-            this.currentSliceZ = next;
-            return;
-        }
-        if (this.currentSliceZ === next)
-            return;
-        this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());
-        this.currentSliceZ = next;
-        this.regions = (this.regionsBySlice.get(next) ?? []).slice();
-        this.previousRegions = this.regions.slice();
-        this.selectedIds = [];
-        this.syncCache();
-        this.resetUndoHistory();
-        this.emitSelection();
-        this.emit();
+        this.showSlice(z);
+        this.regionSetReplaced$.next();
     }
     /**
      * Every slice's regions for save/export, each tagged with its zero-based
@@ -235,18 +303,7 @@ export class RegionStore {
      * first. Returns the flat single-plane set when not in stack mode. (jit-ui#93)
      */
     getSliceRegions() {
-        if (!this.stackMode)
-            return this.regions.slice();
-        this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());
-        const out = [];
-        const zs = Array.from(this.regionsBySlice.keys()).sort((a, b) => a - b);
-        for (const z of zs) {
-            for (const r of this.regionsBySlice.get(z)) {
-                r.z = z;
-                out.push(r);
-            }
-        }
-        return out;
+        return this.scope.sliceRegions(this.regions);
     }
     /**
      * Slices to write on a per-slice-file save (folder stack, jit-ui#93): every
@@ -256,48 +313,57 @@ export class RegionStore {
      * the current live slice is captured first. Empty outside stack mode.
      */
     getStackSaveSlices() {
-        const out = new Map();
-        if (!this.stackMode)
-            return out;
-        this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());
-        const zs = new Set(this.stackInitialNonEmpty);
-        for (const [z, regs] of this.regionsBySlice)
-            if (regs.length)
-                zs.add(z);
-        for (const z of Array.from(zs).sort((a, b) => a - b)) {
-            const regs = (this.regionsBySlice.get(z) ?? []).map((r) => { r.z = z; return r; });
-            out.set(z, regs);
-        }
-        return out;
+        const slices = this.scope.stackSaveSlices(this.regions);
+        // A slice whose region source lost features (taken, deleted) is re-written too.
+        const changed = this.sources.slicesWithTaken(this.scope.activeImage).filter((z) => !slices.has(z));
+        if (!changed.length)
+            return slices;
+        for (const z of changed)
+            slices.set(z, []);
+        return new Map(Array.from(slices).sort((a, b) => a[0] - b[0]));
     }
     /** Mint ids/names + apply classification colours + tag the slice index, as
      *  {@link setRegions} does, for regions entering the per-slice store. */
     normalizeSlice(regions, z) {
-        for (const region of regions) {
-            if (region.id == null)
+        // A fresh (imported) region is tagged in place; a stored one is copied.
+        return this.admit(regions.map((r) => (r.id == null ? Object.assign(r, { z }) : withRegionZ(r, z))));
+    }
+    /**
+     * 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.
+     */
+    admit(regions) {
+        const fresh = new Set();
+        const admitted = regions.map((region) => {
+            if (region.id == null) {
                 region.id = this.nextId++;
-            if (region.name == null)
-                region.name = `shape${region.id}`;
-            region.z = z;
-            region.bounds = hydrateBounds(region.bounds); // jit-ui#124
-        }
-        this.applyClassificationColors(regions);
-        return regions.slice();
+                if (region.name == null)
+                    region.name = `shape${region.id}`;
+                region.bounds = hydrateBounds(region.bounds);
+                fresh.add(region);
+                return region;
+            }
+            const bounds = hydrateBounds(region.bounds);
+            return region.name == null || bounds !== region.bounds
+                ? withRegionPatch(region, { name: region.name ?? `shape${region.id}`, bounds })
+                : region;
+        });
+        return this.withClassificationColors(admitted, (r) => fresh.has(r));
     }
     /**
      * 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() {
-        const ret = [];
-        for (const region of this.regions) {
-            const poly = this.plotUtilities.getPolygon({ ...region.getShape(this.showShapeLabel) });
-            if (poly == null || poly.closed === false)
-                continue;
-            ret.push(poly);
-        }
-        return ret;
+        return this.regions.flatMap((region) => regionPolygons(region));
     }
     getRegionUpdateEvent() {
         return this.regionUpdate$.asObservable();
@@ -307,23 +373,21 @@ export class RegionStore {
     getRegionLiveEdit$() {
         return this.regionLiveEdit$.asObservable();
     }
+    /**
+     * 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$() {
+        return this.regionSetReplaced$.asObservable();
+    }
     // ── IRegionStore: selection ────────────────────────────────────────────
     /** Select regions by array index (or [] to clear). Stored internally by id
      *  so the selection survives subsequent edits/reorders. */
     setSelectedShapeIndices(indices) {
-        const ids = [];
-        const seen = new Set();
-        for (const i of indices || []) {
-            if (!Number.isFinite(i) || i < 0 || i >= this.regions.length)
-                continue;
-            const id = this.regions[i].id;
-            if (!seen.has(id)) {
-                seen.add(id);
-                ids.push(id);
-            }
-        }
-        this.selectedIds = ids;
-        this.emitSelection();
+        this.selection.selectIndices(indices, this.regions);
     }
     /** Select a single region by identity (id). Backends call this from their
      *  `selectRegion()`; the OSD overlay + region editor highlight off the
@@ -331,66 +395,71 @@ export class RegionStore {
     selectRegion(region) {
         if (region?.id == null || this.indexOfId(region.id) < 0)
             return;
-        this.selectedIds = [region.id];
+        this.selection.replace([region.id]);
         this.emitSelection();
     }
     getSelectedShapeIndices$() {
-        return this.selectedIndices$.asObservable();
+        return this.selection.indices$;
     }
     /** Synchronous current selection (array indices) — for callers that need to
      *  read the selection without subscribing. */
     getSelectedShapeIndices() {
-        return this.selectedIndices$.value;
+        return this.selection.indices;
     }
     /** Delete the currently selected regions and clear the selection. */
     deleteActiveShape() {
-        if (this.selectedIds.length === 0)
+        if (this.selection.ids.length === 0)
             return;
         this.recordUndoSnapshot();
-        const ids = new Set(this.selectedIds);
-        this.regions = this.regions.filter(r => !ids.has(r.id));
-        this.selectedIds = [];
+        const ids = new Set(this.selection.ids);
+        this.regions = this.regions.filter((r) => !ids.has(r.id));
+        this.selection.replace([]);
         this.syncCache();
         this.emitSelection();
         this.emit();
     }
     // ── IRegionStore: colours / labels ─────────────────────────────────────
-    getShowShapeLabel() { return this.showShapeLabel; }
-    getShapeColor() { return this.shapeColor; }
-    getFillColor() { return this.fillColor; }
-    /** Convenience setters (not on the contract) for toolbar wiring. */
-    setShowShapeLabel(show) { this.showShapeLabel = show; }
-    setShapeColor(color) { this.shapeColor = color; }
-    setFillColor(color) { this.fillColor = color; }
-    getClassificationColors() { return this.store.getClassificationColors(); }
-    setClassificationColor(label, color) { this.store.setClassificationColor(label, color); }
-    // ── IRegionStore: previous-shapes buffer ───────────────────────────────
-    /** Re-show the last saved snapshot (transient — does not alter stored state). */
-    plotPreviousShapes() {
-        this.regionUpdate$.next(this.previousRegions.slice());
-    }
-    setPreviousShapes(shapes) { this.previousRegions = shapes.slice(); }
-    getPreviousShapes() { return this.previousRegions.slice(); }
+    getShowShapeLabel() {
+        return this.showShapeLabel;
+    }
+    getShapeColor() {
+        return this.shapeColor;
+    }
+    getFillColor() {
+        return this.fillColor;
+    }
+    /** 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) {
+        this.showShapeLabel = show;
+        this.republishView();
+    }
+    getClassificationColors() {
+        return this.store.getClassificationColors();
+    }
+    setClassificationColor(label, color) {
+        this.store.setClassificationColor(label, color);
+    }
     // ── IRegionStore: undo / redo (jit-ui#85) ──────────────────────────────
     /** Emits whether an undo step is currently available — drives the toolbar
      *  Undo button's enabled state (greyed out when false). */
     getCanUndo$() {
-        return this.canUndo$.asObservable();
+        return this.history.canUndo$;
     }
     /** Emits whether a redo step is currently available — drives the toolbar
      *  Redo button's enabled state. */
     getCanRedo$() {
-        return this.canRedo$.asObservable();
+        return this.history.canRedo$;
     }
     /** Synchronous read of {@link getCanUndo$} — true when at least one region
      *  action can be undone. */
     canUndo() {
-        return this.undoStack.length > 0;
+        return this.history.canUndo();
     }
     /** Synchronous read of {@link getCanRedo$} — true when an undone action can
      *  be re-applied. */
     canRedo() {
-        return this.redoStack.length > 0;
+        return this.history.canRedo();
     }
     /**
      * Undo the most recent region action, restoring the region set to its state
@@ -400,14 +469,10 @@ export class RegionStore {
      * nothing is left to undo.
      */
     undo() {
-        if (this.undoStack.length === 0)
-            return;
-        const snapshot = this.undoStack.pop();
-        // Stash the current (post-action) state so redo can re-apply it.
-        this.redoStack.push(this.cloneRegions(this.regions));
-        if (this.redoStack.length > RegionStore.UNDO_LIMIT)
-            this.redoStack.shift();
-        this.restoreSnapshot(snapshot);
+        const snapshot = this.history.undo(this.snapshot());
+        if (snapshot)
+            this.restoreSnapshot(snapshot);
+        this.regionSetReplaced$.next();
     }
     /**
      * Redo the action most recently undone, restoring the region set to the state
@@ -416,40 +481,26 @@ export class RegionStore {
      * fresh region action).
      */
     redo() {
-        if (this.redoStack.length === 0)
-            return;
-        const snapshot = this.redoStack.pop();
-        this.undoStack.push(this.cloneRegions(this.regions));
-        if (this.undoStack.length > RegionStore.UNDO_LIMIT)
-            this.undoStack.shift();
-        this.restoreSnapshot(snapshot);
+        const snapshot = this.history.redo(this.snapshot());
+        if (snapshot)
+            this.restoreSnapshot(snapshot);
+        this.regionSetReplaced$.next();
     }
     /** Discard the undo/redo history (e.g. on image load/switch — history never
      *  crosses images). */
     resetUndoHistory() {
-        this.undoStack = [];
-        this.redoStack = [];
-        this.closeUndoBurst();
-        if (this.canUndo$.value)
-            this.canUndo$.next(false);
-        if (this.canRedo$.value)
-            this.canRedo$.next(false);
+        this.history.reset();
     }
     /** 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. */
     restoreSnapshot(snapshot) {
-        // Close any open coalescing burst so the next edit starts a fresh entry,
-        // and flag the restore so it doesn't record itself back into the history.
-        this.closeUndoBurst();
-        this.restoringUndo = true;
-        this.regions = snapshot;
-        // Drop any selected ids the restored set no longer contains.
-        this.selectedIds = this.selectedIds.filter(id => this.indexOfId(id) >= 0);
-        this.syncCache();
-        this.emitSelection();
-        this.restoringUndo = false;
-        this.emitUndoState();
+        this.history.restore(() => {
+            this.regions = snapshot.regions.slice();
+            this.setTaken(snapshot.taken);
+            this.syncCache();
+            // Drops any selected ids the restored set no longer contains.
+            this.emitSelection();
+        });
         // Notify the live + coalesced streams so whichever backend is on screen
         // re-renders from the restored store state.
         this.regionLiveEdit$.next(this.regions.slice());
@@ -457,72 +508,38 @@ export class RegionStore {
     }
     /**
      * 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.
      */
     recordUndoSnapshot() {
-        if (this.restoringUndo)
-            return;
-        const startsBurst = !this.undoBurstOpen;
-        this.armUndoBurst();
-        if (!startsBurst)
-            return; // mid-burst — keep first snapshot
-        this.undoStack.push(this.cloneRegions(this.regions));
-        if (this.undoStack.length > RegionStore.UNDO_LIMIT)
-            this.undoStack.shift();
-        this.redoStack = []; // a new edit invalidates redo
-        this.emitUndoState();
-    }
-    /** Push the current can-undo / can-redo availability to subscribers. */
-    emitUndoState() {
-        const canUndo = this.undoStack.length > 0;
-        const canRedo = this.redoStack.length > 0;
-        if (this.canUndo$.value !== canUndo)
-            this.canUndo$.next(canUndo);
-        if (this.canRedo$.value !== canRedo)
-            this.canRedo$.next(canRedo);
-    }
-    /** (Re)arm the idle timer that closes the current coalescing burst. */
-    armUndoBurst() {
-        this.undoBurstOpen = true;
-        if (this.undoBurstTimer)
-            clearTimeout(this.undoBurstTimer);
-        this.undoBurstTimer = setTimeout(() => {
-            this.undoBurstOpen = false;
-            this.undoBurstTimer = null;
-        }, RegionStore.UNDO_COALESCE_MS);
-    }
-    closeUndoBurst() {
-        this.undoBurstOpen = false;
-        if (this.undoBurstTimer) {
-            clearTimeout(this.undoBurstTimer);
-            this.undoBurstTimer = null;
-        }
-    }
-    cloneRegions(regions) {
-        return regions.map(r => this.cloneRegion(r));
+        this.history.record(this.snapshot());
     }
-    /** Deep clone a region so an in-place geometry edit can't mutate a stored
-     *  history snapshot (bounds are cloned via {@link cloneBounds}). */
-    cloneRegion(r) {
-        const c = new Region();
-        Object.assign(c, r);
-        c.bounds = r.bounds ? this.cloneBounds(r.bounds) : r.bounds;
-        if (Array.isArray(r.tileCoordinates))
-            c.tileCoordinates = r.tileCoordinates.slice();
-        return c;
+    /** The state an undo step restores. */
+    snapshot() {
+        return { regions: this.regions, taken: this.currentTaken() };
     }
-    // ── IRegionStore: GeoJSON I/O (neutral helpers) ────────────────────────
+    // ── IRegionStore: GeoJSON I/O (models/region-geojson) ──────────────────
+    /** 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) {
-        return this.plotUtilities.importROIsFromGeoJson(geoJsonStr);
+        const regions = regionsFromGeoJson(geoJsonStr);
+        const colors = new Map();
+        for (const r of regions) {
+            if (r.label && r.color && !colors.has(r.label))
+                colors.set(r.label, r.color);
+        }
+        if (colors.size)
+            this.store.rememberImportedClassColors(colors);
+        return regions;
     }
-    exportRegions(regions) {
-        this.plotUtilities.saveToFile(this.plotUtilities.exportROIsToGeoJson(regions));
+    /** Download `regions` as GeoJSON, named after `fileName` (extension
+     *  replaced by `.geojson`) or `rois.geojson` without one. */
+    exportRegions(regions, fileName) {
+        downloadGeoJson(regionsToGeoJson(regions), fileName);
     }
     getGeoJsonString(regions) {
-        return this.plotUtilities.exportROIsToGeoJson(regions);
+        return regionsToGeoJson(regions);
     }
     // ── IRegionEditApi: structural edits ───────────────────────────────────
     addRegion(region) {
@@ -534,24 +551,34 @@ export class RegionStore {
         region.bounds = hydrateBounds(region.bounds); // jit-ui#124
         // A region drawn on a stack belongs to the slice currently displayed, so
         // it saves/reloads on that slice (jit-ui#93). No-op for single-plane images
-        // (currentSliceZ stays 0).
-        if (this.stackMode)
-            region.z = this.currentSliceZ;
-        this.applyClassificationColors([region]);
-        this.regions.push(region);
-        this.selectedIds = [region.id];
+        // (the display slice stays 0).
+        if (this.scope.stackMode)
+            region.z = this.scope.displaySlice;
+        // The caller's instance becomes the stored one (completed in place).
+        const [stored] = this.withClassificationColors([region], () => true);
+        this.regions = [...this.regions, stored];
+        this.selection.replace([stored.id]);
         this.syncCache();
         this.emitSelection();
         this.emit();
-        return region.id;
+        return stored.id;
     }
     removeRegion(id) {
-        const idx = this.indexOfId(id);
-        if (idx < 0)
+        this.removeRegions([id]);
+    }
+    /**
+     * 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, opts = {}) {
+        const drop = new Set(ids);
+        if (!this.regions.some((r) => drop.has(r.id)))
             return;
-        this.recordUndoSnapshot();
-        this.regions.splice(idx, 1);
-        this.selectedIds = this.selectedIds.filter(s => s !== id);
+        if (opts.recordUndo !== false)
+            this.recordUndoSnapshot();
+        this.regions = this.regions.filter((r) => !drop.has(r.id));
+        this.selection.retain((s) => !drop.has(s));
         this.syncCache();
         this.emitSelection();
         this.emit();
@@ -561,469 +588,758 @@ export class RegionStore {
         if (!r)
             return;
         this.recordUndoSnapshot();
-        r.bounds = this.cloneBounds(bounds);
-        this.syncCache();
-        this.emit();
+        // A copy, so the caller can keep using (and changing) the bounds it passed.
+        this.replaceRegion(replaceBounds(r, cloneBounds(bounds)));
     }
     moveRegion(id, dx, dy) {
         const r = this.findById(id);
         if (!r || !r.bounds)
             return;
         this.recordUndoSnapshot();
-        const b = r.bounds;
-        if (b instanceof Rectangle) {
-            b.x += dx;
-            b.y += dy;
-        }
-        else if (b instanceof Polygon) {
-            this.translatePolygon(b, dx, dy);
-        }
-        else if (b instanceof MultiPolygon) {
-            // Translate every part (and its holes) together (jit-ui#85).
-            for (const part of b.polygons)
-                this.translatePolygon(part, dx, dy);
-        }
-        this.syncCache();
-        this.emit();
-    }
-    /** Translate a polygon's vertices and any holes in place by (dx, dy). */
-    translatePolygon(p, dx, dy) {
-        p.xpoints = p.xpoints.map(x => x + dx);
-        p.ypoints = p.ypoints.map(y => y + dy);
-        p.coordinates = p.xpoints.map((x, i) => [x, p.ypoints[i]]);
-        if (p.holes)
-            p.holes = p.holes.map(ring => ring.map(([x, y]) => [x + dx, y + dy]));
+        // Every part (and its holes) moves together (jit-ui#85).
+        this.replaceRegion(replaceBounds(r, edit.translateBounds(r.bounds, dx, dy)));
     }
     // ── IRegionEditApi: vertex edits (polygons only) ───────────────────────
+    // Each one is a pure copy-on-write edit from models/polygon-edit; a null
+    // result (out of range, would degenerate) records nothing and emits nothing.
     moveVertex(id, index, x, y) {
-        const poly = this.polygonOf(id);
-        if (!poly || index < 0 || index >= poly.xpoints.length)
-            return;
-        this.recordUndoSnapshot();
-        poly.xpoints[index] = x;
-        poly.ypoints[index] = y;
-        poly.coordinates[index] = [x, y];
-        this.syncCache();
-        this.emit();
+        this.editPolygon(id, (p) => edit.moveVertex(p, index, x, y));
     }
     /** Move a vertex on a polygon's interior ring (hole) — jit-ui#85. */
     moveHoleVertex(id, holeIndex, index, x, y) {
-        const poly = this.polygonOf(id);
-        if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length)
-            return;
-        const ring = poly.holes[holeIndex];
-        if (index < 0 || index >= ring.length)
-            return;
-        this.recordUndoSnapshot();
-        ring[index] = [x, y];
-        this.syncCache();
-        this.emit();
+        this.editPolygon(id, (p) => edit.moveHoleVertex(p, holeIndex, index, x, y));
     }
     /** Insert a vertex on a polygon's interior ring (hole), after `segIndex`
      *  (the edge's start vertex). No-op for an out-of-range hole — jit-ui#85. */
     addHoleVertex(id, holeIndex, segIndex, x, y) {
-        const poly = this.polygonOf(id);
-        if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length)
-            return;
-        const ring = poly.holes[holeIndex];
-        this.recordUndoSnapshot();
-        const at = Math.max(0, Math.min(segIndex + 1, ring.length));
-        ring.splice(at, 0, [x, y]);
-        if (poly.bezier)
-            this.seedHoleHandles(poly); // keep hole handles aligned to the ring
-        this.syncCache();
-        this.emit();
+        this.editPolygon(id, (p) => edit.addHoleVertex(p, holeIndex, segIndex, x, y));
     }
     /** Delete the vertex at `index` on a polygon's interior ring (hole). Removing
      *  it below 3 vertices drops the whole hole (a ring with < 3 points bounds no
      *  area) — jit-ui#85. */
     deleteHoleVertex(id, holeIndex, index) {
-        const poly = this.polygonOf(id);
-        if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length)
-            return;
-        const ring = poly.holes[holeIndex];
-        if (index < 0 || index >= ring.length)
-            return;
-        this.recordUndoSnapshot();
-        if (ring.length <= 3) {
-            poly.holes.splice(holeIndex, 1);
-            if (poly.holes.length === 0)
-                poly.holes = undefined;
-        }
-        else {
-            ring.splice(index, 1);
-        }
-        if (poly.bezier)
-            this.seedHoleHandles(poly); // keep hole handles aligned to the ring(s)
-        this.syncCache();
-        this.emit();
+        this.editPolygon(id, (p) => edit.deleteHoleVertex(p, holeIndex, index));
     }
     addVertex(id, segIndex, x, y) {
-        const poly = this.polygonOf(id);
-        if (!poly)
-            return;
-        this.recordUndoSnapshot();
-        // Insert after segIndex (the start vertex of the edge). Clamp to range.
-        const at = Math.max(0, Math.min(segIndex + 1, poly.xpoints.length));
-        poly.xpoints.splice(at, 0, x);
-        poly.ypoints.splice(at, 0, y);
-        poly.coordinates = poly.xpoints.map((xx, i) => [xx, poly.ypoints[i]]);
-        poly.npoints = poly.xpoints.length;
-        // Give the new vertex smooth handles from its neighbours; keep the others'
-        // (possibly hand-edited) handles intact.
-        if (poly.bezier && poly.handlesIn && poly.handlesOut) {
-            const n = poly.xpoints.length;
-            const closed = poly.closed !== false;
-            const prev = closed ? (at - 1 + n) % n : Math.max(0, at - 1);
-            const next = closed ? (at + 1) % n : Math.min(n - 1, at + 1);
-            const tx = (poly.xpoints[next] - poly.xpoints[prev]) / 6;
-            const ty = (poly.ypoints[next] - poly.ypoints[prev]) / 6;
-            poly.handlesIn.splice(at, 0, [-tx, -ty]);
-            poly.handlesOut.splice(at, 0, [tx, ty]);
-        }
-        this.syncCache();
-        this.emit();
+        this.editPolygon(id, (p) => edit.addVertex(p, segIndex, x, y));
     }
     deleteVertex(id, index) {
-        const poly = this.polygonOf(id);
-        if (!poly || index < 0 || index >= poly.xpoints.length)
-            return;
-        const min = poly.closed === false ? 2 : 3;
-        if (poly.xpoints.length <= min)
-            return; // refuse to degenerate the polygon
-        this.recordUndoSnapshot();
-        poly.xpoints.splice(index, 1);
-        poly.ypoints.splice(index, 1);
-        poly.coordinates = poly.xpoints.map((xx, i) => [xx, poly.ypoints[i]]);
-        poly.npoints = poly.xpoints.length;
-        if (poly.bezier && poly.handlesIn && poly.handlesOut) {
-            poly.handlesIn.splice(index, 1);
-            poly.handlesOut.splice(index, 1);
-        }
-        this.syncCache();
-        this.emit();
+        this.editPolygon(id, (p) => edit.deleteVertex(p, index));
     }
     setBezier(id, bezier) {
         const r = this.findById(id);
         if (!r || !r.bounds)
             return;
+        let next = null;
         if (r.bounds instanceof Polygon) {
-            if (r.bounds.bezier === bezier)
-                return;
-            this.recordUndoSnapshot();
-            this.applyBezier(r.bounds, bezier);
+            next = edit.setBezier(r.bounds, bezier);
         }
         else if (r.bounds instanceof Rectangle && bezier) {
-            this.recordUndoSnapshot();
             // Smoothing a rectangle: convert it to a 4-anchor closed polygon first.
-            const b = r.bounds;
-            const xs = [b.x, b.x + b.width, b.x + b.width, b.x];
-            const ys = [b.y, b.y, b.y + b.height, b.y + b.height];
-            const poly = new Polygon();
-            poly.npoints = 4;
-            poly.xpoints = xs;
-            poly.ypoints = ys;
-            poly.coordinates = xs.map((x, i) => [x, ys[i]]);
-            poly.closed = true;
-            this.applyBezier(poly, true);
-            r.bounds = poly;
+            const ring = rectToRing(r.bounds);
+            next = edit.setBezier(makePolygon(ring.xs, ring.ys), true);
         }
-        else {
-            return; // bezier=false on a rectangle: nothing to do
-        }
-        this.syncCache();
-        this.emit();
-    }
-    /** Turn bezier on (and seed editable handles from the smooth default) or off
-     *  (and drop the handles). */
-    applyBezier(poly, bezier) {
-        poly.bezier = bezier;
-        if (bezier) {
-            const off = defaultHandleOffsets(poly.xpoints, poly.ypoints, poly.closed !== false);
-            poly.handlesIn = off.in;
-            poly.handlesOut = off.out;
-            this.seedHoleHandles(poly); // smooth the holes too (donut → bezier curves the holes)
-        }
-        else {
-            poly.handlesIn = undefined;
-            poly.handlesOut = undefined;
-            poly.holeHandlesIn = undefined;
-            poly.holeHandlesOut = undefined;
-        }
-    }
-    /** (Re)seed per-hole bezier handles from the Catmull-Rom default, parallel to `poly.holes`. */
-    seedHoleHandles(poly) {
-        if (!poly.holes || !poly.holes.length) {
-            poly.holeHandlesIn = undefined;
-            poly.holeHandlesOut = undefined;
-            return;
-        }
-        const ins = [];
-        const outs = [];
-        for (const ring of poly.holes) {
-            const off = defaultHandleOffsets(ring.map((p) => p[0]), ring.map((p) => p[1]), true);
-            ins.push(off.in);
-            outs.push(off.out);
-        }
-        poly.holeHandlesIn = ins;
-        poly.holeHandlesOut = outs;
+        if (!next)
+            return; // already in that state, or bezier=false on a rectangle
+        this.recordUndoSnapshot();
+        this.replaceRegion(replaceBounds(r, next));
     }
     /** Drag a bezier control point on a hole ring vertex (donut bezier editing). */
     moveHoleBezierHandle(id, holeIndex, index, side, x, y) {
-        const poly = this.polygonOf(id);
-        if (!poly || !poly.bezier || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length) {
-            return;
-        }
-        const ring = poly.holes[holeIndex];
-        if (index < 0 || index >= ring.length)
-            return;
-        this.recordUndoSnapshot();
-        if (!poly.holeHandlesIn || !poly.holeHandlesOut)
-            this.seedHoleHandles(poly);
-        const offset = [x - ring[index][0], y - ring[index][1]];
-        if (side === 'in')
-            poly.holeHandlesIn[holeIndex][index] = offset;
-        else
-            poly.holeHandlesOut[holeIndex][index] = offset;
-        this.syncCache();
-        this.emit();
+        this.editPolygon(id, (p) => edit.moveHoleBezierHandle(p, holeIndex, index, side, x, y));
     }
     moveBezierHandle(id, index, side, x, y) {
-        const poly = this.polygonOf(id);
-        if (!poly || !poly.bezier || index < 0 || index >= poly.xpoints.length)
+        this.editPolygon(id, (p) => edit.moveBezierHandle(p, index, side, x, y));
+    }
+    /** Apply a copy-on-write polygon edit to region `id`: record, swap in, emit. */
+    editPolygon(id, apply) {
+        const r = this.findById(id);
+        if (!r || !(r.bounds instanceof Polygon))
+            return;
+        const next = apply(r.bounds);
+        if (!next)
             return;
         this.recordUndoSnapshot();
-        if (!poly.handlesIn || !poly.handlesOut) {
-            const off = defaultHandleOffsets(poly.xpoints, poly.ypoints, poly.closed !== false);
-            poly.handlesIn = off.in;
-            poly.handlesOut = off.out;
-        }
-        const offset = [x - poly.xpoints[index], y - poly.ypoints[index]];
-        if (side === 'in')
-            poly.handlesIn[index] = offset;
-        else
-            poly.handlesOut[index] = offset;
+        this.replaceRegion(replaceBounds(r, next));
+    }
+    /** Swap `next` in for the stored region with its id (a new array), then sync and emit. */
+    replaceRegion(next) {
+        this.regions = this.regions.map((r) => (r.id === next.id ? next : r));
         this.syncCache();
         this.emit();
     }
-    beginBatch() { this.batchDepth++; }
+    /** Coalesce `regionUpdate$` until the matching {@link endBatch} (live drags);
+     *  the batch is also one undo gesture ({@link beginGesture}). */
+    beginBatch() {
+        this.batchDepth++;
+        this.beginGesture();
+    }
     endBatch() {
         if (this.batchDepth > 0)
             this.batchDepth--;
+        this.endGesture();
         if (this.batchDepth === 0 && this.pendingEmit) {
             this.pendingEmit = false;
             this.regionUpdate$.next(this.getRegions());
         }
     }
-    // ── per-image lifecycle ────────────────────────────────────────────────
     /**
-     * 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).
+     * 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.
      */
-    setActiveImage(imageInfo) {
-        const newKey = this.deriveImageKey(imageInfo);
-        if (this.currentImageKey === newKey)
+    beginGesture() {
+        this.history.beginGesture();
+    }
+    /** End the gesture opened by {@link beginGesture}; the next commit starts a new step. */
+    endGesture() {
+        this.history.endGesture();
+    }
+    // ── Region sources: large region sets, tiled by level of detail ─────────
+    /**
+     * 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, slices = { slice: this.sourceSlice }) {
+        const image = this.scope.activeImage;
+        if (!image)
+            return;
+        const open = typeof source === 'function' ? source : () => Promise.resolve(source);
+        this.sources.attach(image, open, slices);
+        this.sourcesVersion++;
+        this.refreshSourceView();
+    }
+    /** Drop the current image's region sources (closing them) and what was taken from them. */
+    detachRegionSources() {
+        const image = this.scope.activeImage;
+        if (!image)
+            return;
+        this.sources.detachImage(image);
+        this.sourcesVersion++;
+        this.refreshSourceView();
+    }
+    /**
+     * 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.
+     */
+    async dropSliceRegionSource() {
+        const image = this.scope.activeImage;
+        const slice = this.sourceSlice;
+        if (!image || !this.sources.has(image, slice))
+            return;
+        if (this.sources.hasOwnSource(image, slice)) {
+            this.sources.detachSlice(image, slice);
+            this.sourcesVersion++;
+            this.refreshSourceView();
             return;
-        // Switching images ends any per-slice stack session (jit-ui#93); the loader
-        // re-enters stack mode afterwards if the new image is itself a z-stack.
-        this.exitStackMode();
-        if (this.currentImageKey) {
-            this.regionsByImageKey.set(this.currentImageKey, this.regions.slice());
         }
-        this.currentImageKey = newKey;
-        this.regions = (newKey && this.regionsByImageKey.get(newKey))
-            ? this.regionsByImageKey.get(newKey).slice()
-            : [];
-        this.previousRegions = this.regions.slice();
-        this.selectedIds = [];
-        // Undo never crosses an image switch.
-        this.resetUndoHistory();
-        this.emitSelection();
-        this.regionUpdate$.next(this.getRegions());
+        const generation = this.sourceGeneration;
+        const binding = await this.sources.binding(image, slice);
+        if (!binding || generation !== this.sourceGeneration)
+            return;
+        const all = await binding.source.getIndex(binding.plane, {
+            offset: 0,
+            limit: binding.source.info.featureCount,
+        });
+        if (generation !== this.sourceGeneration)
+            return;
+        this.setTaken(new Set([...this.currentTaken(), ...all.rows.map((r) => r.id)]));
     }
-    /** Drop the entire per-image cache (logout / project switch). */
-    clearRegionsByImageKey() {
-        this.regionsByImageKey.clear();
-        this.currentImageKey = undefined;
-        this.regions = [];
-        this.selectedIds = [];
-        this.resetUndoHistory();
+    /** Whether the slice shown has a region source. */
+    hasRegionSource() {
+        return this.sources.has(this.scope.activeImage, this.sourceSlice);
     }
-    // ── internals ──────────────────────────────────────────────────────────
-    deriveImageKey(imageInfo) {
-        if (!imageInfo)
-            return undefined;
-        if (imageInfo.urls && imageInfo.urls.length > 0 && imageInfo.urls[0]) {
-            return imageInfo.urls[0];
+    /** The slice's region source as a source layer draws it; null without one (or until it opens). */
+    getRegionSourceView() {
+        return this.sourceView$.value;
+    }
+    /** {@link getRegionSourceView} and every change of it (slice, taken ids, class colours). */
+    getRegionSourceView$() {
+        return this.sourceView$.asObservable();
+    }
+    /**
+     * 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.
+     */
+    async takeSourceFeatures(ids) {
+        const view = this.sourceView$.value;
+        if (!view || !ids.length)
+            return [];
+        const generation = this.sourceGeneration;
+        const wanted = ids.filter((id) => !view.taken.has(id));
+        const features = wanted.length ? await view.source.getFeatures(wanted) : [];
+        if (generation !== this.sourceGeneration)
+            return [];
+        const taken = this.currentTaken();
+        const fresh = features.filter((f) => !taken.has(f.id));
+        if (fresh.length) {
+            const regions = fresh.map((f) => {
+                const region = regionFromGeoJsonFeature(f.feature, 0, f.id);
+                if (this.scope.stackMode)
+                    region.z = this.scope.displaySlice;
+                return region;
+            });
+            const admitted = this.admit(regions);
+            // Fresh instances, completed in place: named after their new id like a drawn region.
+            for (const r of admitted)
+                r.name = `shape${r.id}`;
+            this.regions = this.regions.concat(admitted);
+            this.setTaken(new Set([...taken, ...fresh.map((f) => f.id)]));
+            this.syncCache();
+            this.emitSelection();
+            this.emit();
         }
-        return imageInfo.fileName || undefined;
+        const bySource = new Map(this.regions.filter((r) => r.sourceId !== undefined).map((r) => [r.sourceId, r.id]));
+        return ids.map((id) => bySource.get(id)).filter((id) => id !== undefined);
+    }
+    /** {@link takeSourceFeatures}, then select them (added to the selection with `additive`). */
+    async selectSourceFeatures(ids, additive = false) {
+        const taken = await this.takeSourceFeatures(ids);
+        if (!taken.length)
+            return taken;
+        this.selection.replace(additive ? [...new Set([...this.selection.ids, ...taken])] : taken);
+        this.emitSelection();
+        return taken;
     }
     /**
-     * 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.
+     * 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.
      */
-    applyClassificationColors(regions) {
-        const set = this.store.getPresetSet();
-        const keyOf = (label) => set.matchMode === 'normalized' ? label.trim().toLowerCase() : label;
-        const known = new Set(set.classes.map((c) => keyOf(c.name)));
-        for (const region of regions) {
-            if (!region.label || region.colorOverridden)
-                continue;
-            const preset = findPreset(region.label, set);
-            if (preset) {
-                region.color = preset.color;
-                continue;
+    async getRegionSourceClassCounts(stack = false) {
+        const view = this.sourceView$.value;
+        const image = this.scope.activeImage;
+        if (!stack || !this.scope.stackMode) {
+            return view ? view.source.getClassCounts(view.plane, Array.from(view.taken)) : {};
+        }
+        if (this.sources.hasPlanesSource(image)) {
+            const binding = await this.sources.binding(image, this.sourceSlice);
+            if (!binding)
+                return {};
+            try {
+                return await binding.source.getClassCounts(null, this.sources.allTaken(image));
             }
-            const color = fallbackColorFor(region.label, set.fallbackPalette);
-            region.color = color;
-            if (set.autoPromote && !known.has(keyOf(region.label))) {
-                known.add(keyOf(region.label));
-                // In normalized mode, trim the promoted name so leading/trailing
-                // whitespace doesn't create invisible duplicates or odd display names.
-                const name = set.matchMode === 'normalized' ? region.label.trim() : region.label;
-                this.store.upsertClass({ name, color, source: 'auto' });
+            catch (err) {
+                // A tile server that predates counting every plane: the slice's counts.
+                console.warn('[regions] could not count the classes of every slice', err);
+                return view ? view.source.getClassCounts(view.plane, Array.from(view.taken)) : {};
             }
         }
+        const counts = {};
+        for (const slice of this.sources.slicesWithSource(image)) {
+            const binding = await this.sources.binding(image, slice);
+            if (!binding)
+                continue;
+            const own = await binding.source.getClassCounts(binding.plane, Array.from(this.sources.taken(image, slice)));
+            for (const [label, n] of Object.entries(own))
+                counts[label] = (counts[label] ?? 0) + n;
+        }
+        return counts;
     }
-    syncCache() {
-        if (this.currentImageKey) {
-            this.regionsByImageKey.set(this.currentImageKey, this.regions.slice());
+    /**
+     * 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.
+     */
+    async selectClasses(classes, additive = false) {
+        const wanted = new Set(classes);
+        const view = this.sourceView$.value;
+        if (view && classes.length) {
+            const page = await view.source.getIndex(view.plane, {
+                offset: 0,
+                limit: SELECT_CLASSES_LIMIT,
+                classes,
+                exclude: Array.from(view.taken),
+            });
+            if (page.rows.length)
+                await this.takeSourceFeatures(page.rows.map((r) => r.id));
         }
+        const ids = this.regions.filter((r) => !r.isProfile?.() && r.label && wanted.has(r.label)).map((r) => r.id);
+        this.selection.replace(additive ? [...new Set([...this.selection.ids, ...ids])] : ids);
+        this.emitSelection();
+        return ids;
     }
-    emit() {
-        // Live-edit listeners (e.g. the intensity-profile inset) react on EVERY
-        // change — including per-frame during a batched drag — so they track the
-        // region live. The main regionUpdate$ stays coalesced during a batch (fires
-        // once on endBatch) to keep heavier consumers (Regions tab) calm.
-        this.regionLiveEdit$.next(this.regions.slice());
-        if (this.batchDepth > 0) {
-            this.pendingEmit = true;
-            return;
+    /**
+     * 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.
+     */
+    async reconstructClasses(groups, pixelStep = 1) {
+        const level = Math.max(0, Math.floor(Math.log2(Math.max(1, pixelStep))));
+        const out = [];
+        for (const group of groups) {
+            const slices = await this.classOutlines(group.classes, level);
+            out.push({ key: group.key, mesh: await reconstructInWorker(slices, { pixelStep }) });
         }
-        this.regionUpdate$.next(this.getRegions());
+        return out;
     }
-    /** Project selected ids to current array indices, pruning ids that no longer
-     *  exist, and emit if the index set changed. */
-    emitSelection() {
-        const indices = [];
-        const liveIds = [];
-        for (const id of this.selectedIds) {
-            const idx = this.indexOfId(id);
-            if (idx >= 0) {
-                indices.push(idx);
-                liveIds.push(id);
+    /**
+     * 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.
+     */
+    async classVolumes(classes) {
+        const state = this.sourceStateKey();
+        const out = new Map();
+        await Promise.all([...new Set(classes)].map(async (name) => {
+            const source = await this.sourceVolume(state, name);
+            let volume = source.total;
+            for (const regions of mergeOutlines(this.regionOutlines([name]))) {
+                const under = source.slices.get(regions.z);
+                const [both] = under ? mergeOutlines([under.outlines, regions]) : [regions];
+                volume += outlinesArea(both.rings, both.ringGroups) - (under?.area ?? 0);
             }
+            out.set(name, volume);
+        }));
+        return out;
+    }
+    /** The region sources' part of a class's volume, cached by what they hold (see classVolumes). */
+    sourceVolume(state, name) {
+        const key = `${state}\n${name}`;
+        let source = this.sourceVolumeCache.get(key);
+        if (source) {
+            // Most recently used last.
+            this.sourceVolumeCache.delete(key);
+            this.sourceVolumeCache.set(key, source);
+            return source;
         }
-        this.selectedIds = liveIds;
-        if (!this.indicesEqual(this.selectedIndices$.value, indices)) {
-            this.selectedIndices$.next(indices);
+        source = this.sourceOutlines([name], 0).then((parts) => {
+            const slices = new Map();
+            let total = 0;
+            for (const outlines of mergeOutlines(parts)) {
+                const area = outlinesArea(outlines.rings, outlines.ringGroups);
+                slices.set(outlines.z, { area, outlines });
+                total += area;
+            }
+            return { total, slices };
+        });
+        this.sourceVolumeCache.set(key, source);
+        source.catch(() => this.sourceVolumeCache.delete(key));
+        while (this.sourceVolumeCache.size > SOURCE_VOLUME_CACHE_SIZE) {
+            this.sourceVolumeCache.delete(this.sourceVolumeCache.keys().next().value);
         }
+        return source;
     }
-    indicesEqual(a, b) {
-        if (a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i++)
-            if (a[i] !== b[i])
-                return false;
-        return true;
-    }
-    findById(id) {
-        return this.regions.find(r => r.id === id);
+    /**
+     * Every slice's outlines of these classes, the region sources' then the regions': closed shapes'
+     * rings, and open polylines as `lines`.
+     */
+    async classOutlines(classes, level) {
+        return mergeOutlines([...(await this.sourceOutlines(classes, level)), ...this.regionOutlines(classes)]);
     }
-    indexOfId(id) {
-        return this.regions.findIndex(r => r.id === id);
+    /**
+     * 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.
+     */
+    sourceOutlines(classes, level) {
+        const key = `${this.sourceStateKey()}\n${level}\n${classes ? classes.join('\n') : '*'}`;
+        const cached = this.sourceOutlineCache.get(key);
+        if (cached) {
+            // Most recently used last.
+            this.sourceOutlineCache.delete(key);
+            this.sourceOutlineCache.set(key, cached);
+            return cached;
+        }
+        const read = this.readSourceOutlines(classes, level);
+        this.sourceOutlineCache.set(key, read);
+        read.catch(() => this.sourceOutlineCache.delete(key));
+        while (this.sourceOutlineCache.size > SOURCE_OUTLINE_CACHE_SIZE) {
+            this.sourceOutlineCache.delete(this.sourceOutlineCache.keys().next().value);
+        }
+        return read;
     }
-    /** The region's bounds as a Polygon, or undefined if it isn't a polygon. */
-    polygonOf(id) {
-        const r = this.findById(id);
-        return r && r.bounds instanceof Polygon ? r.bounds : undefined;
-    }
-    clonePolygon(p) {
-        const poly = new Polygon();
-        poly.npoints = p.npoints;
-        poly.xpoints = p.xpoints.slice();
-        poly.ypoints = p.ypoints.slice();
-        poly.coordinates = p.coordinates.map(c => c.slice());
-        poly.closed = p.closed;
-        poly.bezier = p.bezier;
-        if (p.handlesIn)
-            poly.handlesIn = p.handlesIn.map(o => o.slice());
-        if (p.handlesOut)
-            poly.handlesOut = p.handlesOut.map(o => o.slice());
-        if (p.holes)
-            poly.holes = p.holes.map(ring => ring.map(pt => pt.slice()));
-        if (p.holeHandlesIn)
-            poly.holeHandlesIn = p.holeHandlesIn.map(r => r.map(o => o.slice()));
-        if (p.holeHandlesOut)
-            poly.holeHandlesOut = p.holeHandlesOut.map(r => r.map(o => o.slice()));
-        return poly;
-    }
-    cloneBounds(bounds) {
-        if (bounds instanceof Rectangle) {
-            const rect = new Rectangle();
-            rect.x = bounds.x;
-            rect.y = bounds.y;
-            rect.width = bounds.width;
-            rect.height = bounds.height;
-            return rect;
+    async readSourceOutlines(classes, level) {
+        const out = [];
+        const image = this.scope.activeImage;
+        if (this.sources.hasPlanesSource(image)) {
+            const binding = await this.sources.binding(image, this.sourceSlice);
+            const outlines = await binding?.source.getClassOutlines(classes, level, this.sources.allTaken(image));
+            out.push(...(outlines ?? []));
         }
-        if (bounds instanceof MultiPolygon) {
-            const mp = new MultiPolygon();
-            mp.polygons = bounds.polygons.map(p => this.clonePolygon(p));
-            return mp;
+        for (const z of this.sources.slicesWithSource(image)) {
+            const binding = await this.sources.binding(image, z);
+            if (!binding)
+                continue;
+            const outlines = await binding.source.getClassOutlines(classes, level, Array.from(this.sources.taken(image, z)));
+            for (const s of outlines)
+                if (s.z === binding.plane)
+                    out.push({ ...s, z });
         }
-        return this.clonePolygon(bounds);
+        return out;
     }
-    regionsEqual(a, b) {
-        const ba = a.bounds, bb = b.bounds;
-        if (ba instanceof Rectangle && bb instanceof Rectangle) {
-            return ba.x === bb.x && ba.y === bb.y && ba.width === bb.width && ba.height === bb.height;
+    /**
+     * 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`).
+     */
+    async outlinesByClass(level) {
+        const byClass = new Map();
+        const slot = (label, z) => {
+            let slices = byClass.get(label);
+            if (!slices)
+                byClass.set(label, (slices = new Map()));
+            let slice = slices.get(z);
+            if (!slice)
+                slices.set(z, (slice = { rings: [], ringGroups: [], lines: [] }));
+            return slice;
+        };
+        const nextPart = featureIds();
+        for (const s of await this.sourceOutlines(null, level)) {
+            const id = nextPart();
+            s.rings.forEach((r, i) => {
+                const label = s.ringLabels?.[i];
+                if (!label)
+                    return;
+                const slice = slot(label, s.z);
+                slice.rings.push(r);
+                slice.ringGroups.push(id(s.ringGroups?.[i]));
+            });
+            (s.lines ?? []).forEach((l, i) => {
+                const label = s.lineLabels?.[i];
+                if (label)
+                    slot(label, s.z).lines.push(l);
+            });
         }
-        if (ba instanceof MultiPolygon && bb instanceof MultiPolygon) {
-            if (ba.polygons.length !== bb.polygons.length)
-                return false;
-            for (let i = 0; i < ba.polygons.length; i++) {
-                if (!this.polygonsEqual(ba.polygons[i], bb.polygons[i]))
-                    return false;
+        for (const { label, outlines } of this.labelledRegionOutlines(null)) {
+            // A region is one feature.
+            const id = nextPart()(undefined);
+            const slice = slot(label, outlines.z);
+            slice.rings.push(...outlines.rings);
+            slice.ringGroups.push(...outlines.rings.map(() => id));
+            slice.lines.push(...(outlines.lines ?? []));
+        }
+        return new Map(Array.from(byClass, ([label, slices]) => [label, Array.from(slices, ([z, s]) => sliceOutlines(z, s))]));
+    }
+    /** The drawn and taken regions' outlines of these classes, by slice. */
+    regionOutlines(classes) {
+        return this.labelledRegionOutlines(new Set(classes)).map((o) => o.outlines);
+    }
+    /** Each drawn or taken region's outlines (of the `wanted` classes; null: every class) with its class. */
+    labelledRegionOutlines(wanted) {
+        const out = [];
+        for (const r of this.scope.stackMode ? this.getSliceRegions() : this.regions) {
+            if (r.isProfile?.() || !r.label || (wanted && !wanted.has(r.label)))
+                continue;
+            const rings = [];
+            for (const p of regionPolygons(r)) {
+                rings.push(Float64Array.from(p.xpoints.flatMap((x, i) => [x, p.ypoints[i]])));
+                for (const hole of p.holes ?? [])
+                    rings.push(Float64Array.from(hole.flat()));
             }
-            return true;
+            const lines = regionPolylines(r);
+            out.push({ label: r.label, outlines: { z: r.z ?? 0, rings, ...(lines.length ? { lines } : {}) } });
         }
-        if (ba instanceof Polygon && bb instanceof Polygon) {
-            return this.polygonsEqual(ba, bb);
+        return out;
+    }
+    /** 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() {
+        return this.sourceStateKey();
+    }
+    /**
+     * 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.
+     */
+    sourceStateKey() {
+        const image = this.scope.activeImage;
+        let taken = 2166136261;
+        for (const z of this.sources.slicesWithTaken(image)) {
+            for (const id of [...this.sources.taken(image, z)].sort()) {
+                const s = `${z}:${id};`;
+                for (let i = 0; i < s.length; i++)
+                    taken = Math.imul(taken ^ s.charCodeAt(i), 16777619) >>> 0;
+            }
         }
-        return false;
+        return `${image}\n${this.sourcesVersion}\n${taken}`;
     }
-    polygonsEqual(pa, pb) {
-        if ((pa.closed !== false) !== (pb.closed !== false))
+    /** Delete source features without taking them (one undo step). */
+    deleteSourceFeatures(ids) {
+        const taken = this.currentTaken();
+        const drop = ids.filter((id) => !taken.has(id));
+        if (!drop.length || !this.sourceView$.value)
+            return;
+        this.recordUndoSnapshot();
+        this.setTaken(new Set([...taken, ...drop]));
+        this.emit();
+    }
+    /**
+     * 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.
+     */
+    async getRegionSourceIndex(query) {
+        const view = this.sourceView$.value;
+        if (!view)
+            return { total: 0, rows: [] };
+        return view.source.getIndex(view.plane, { ...query, exclude: Array.from(view.taken) });
+    }
+    /**
+     * `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.
+     */
+    async getGeoJsonWithSource(regions, slice = this.sourceSlice) {
+        const image = this.scope.activeImage;
+        const planes = this.scope.stackMode && this.sources.hasPlanesSource(image);
+        const binding = await this.sources.binding(image, slice);
+        if (!binding)
+            return regionsToGeoJson(regions);
+        const features = regions
+            .filter((r) => !r.isProfile?.())
+            .map((r) => featureFromRegion(r))
+            .filter((f) => !!f);
+        const exclude = planes ? this.sources.allTaken(image) : Array.from(this.sources.taken(image, slice));
+        return binding.source.exportGeoJson(exclude, features);
+    }
+    // ── Region look ────────────────────────────────────────────────────────
+    /**
+     * 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) {
+        if (!label)
             return false;
-        if (pa.xpoints.length !== pb.xpoints.length)
+        const hierarchy = this.sourceView$.value?.source.info.hierarchy;
+        if (!hierarchy)
             return false;
-        for (let i = 0; i < pa.xpoints.length; i++) {
-            if (pa.xpoints[i] !== pb.xpoints[i] || pa.ypoints[i] !== pb.ypoints[i])
-                return false;
+        if (this.coveredFor?.regions !== this.regions || this.coveredFor.hierarchy !== hierarchy) {
+            const parent = new Map(hierarchy.filter((n) => n.parent).map((n) => [n.name, n.parent]));
+            const covered = new Set();
+            for (const r of this.regions) {
+                let p = r.label ? parent.get(r.label) : undefined;
+                while (p && !covered.has(p)) {
+                    covered.add(p);
+                    p = parent.get(p);
+                }
+            }
+            this.coveredFor = { regions: this.regions, hierarchy, covered };
         }
-        return this.holesEqual(pa.holes, pb.holes);
+        return this.coveredFor.covered.has(label);
     }
-    /** Compare two polygons' interior-ring (hole) sets for the dedupe path. */
-    holesEqual(a, b) {
-        const na = a?.length ?? 0, nb = b?.length ?? 0;
-        if (na !== nb)
-            return false;
-        for (let h = 0; h < na; h++) {
-            const ra = a[h], rb = b[h];
-            if (ra.length !== rb.length)
-                return false;
-            for (let i = 0; i < ra.length; i++) {
-                if (ra[i][0] !== rb[i][0] || ra[i][1] !== rb[i][1])
-                    return false;
+    /** The classes hidden from view (see {@link setClassesHidden}). */
+    getHiddenClasses() {
+        return this.hiddenClasses$.value;
+    }
+    /** {@link getHiddenClasses} and every change of it. */
+    getHiddenClasses$() {
+        return this.hiddenClasses$.asObservable();
+    }
+    /**
+     * 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, hidden) {
+        const cur = this.hiddenClasses$.value;
+        const next = new Set(cur);
+        for (const c of classes) {
+            if (hidden)
+                next.add(c);
+            else
+                next.delete(c);
+        }
+        if (next.size === cur.size && [...next].every((c) => cur.has(c)))
+            return;
+        const set = this.store.getPresetSet();
+        this.hiddenKeys = new Set([...next].map((c) => presetKey(set, c)));
+        this.hiddenClasses$.next(next);
+        if (hidden) {
+            const shown = this.selection.indices.filter((i) => !this.isClassHidden(this.regions[i]?.label));
+            if (shown.length !== this.selection.indices.length)
+                this.setSelectedShapeIndices(shown);
+        }
+        this.republishView();
+        this.regionUpdate$.next(this.getRegions());
+    }
+    /** Whether regions labelled `label` are hidden (an unlabelled region never is). */
+    isClassHidden(label) {
+        return !!label && this.hiddenKeys.size > 0 && this.hiddenKeys.has(presetKey(this.store.getPresetSet(), label));
+    }
+    /** The region look: outlines, or filled (an atlas's look); see `region-style`. */
+    getRegionStyle() {
+        return this.regionStyle$.value;
+    }
+    /** {@link getRegionStyle} and every change of it. */
+    getRegionStyle$() {
+        return this.regionStyle$.asObservable();
+    }
+    /**
+     * Choose the region look, field by field; it overrides a region source's hint for the session.
+     * The overlays redraw.
+     */
+    setRegionStyle(patch) {
+        this.userStyle = { ...this.userStyle, ...patch };
+        this.restyle();
+    }
+    /** The look now: the user's choice, else the source's hint, else outlines. */
+    effectiveStyle() {
+        const hint = this.hintStyle ?? {};
+        return {
+            fillOpacity: this.userStyle.fillOpacity ?? hint.fillOpacity ?? DEFAULT_REGION_STYLE.fillOpacity,
+            stroke: this.userStyle.stroke !== undefined ? this.userStyle.stroke : (hint.stroke ?? null),
+            strokeWidth: this.userStyle.strokeWidth !== undefined ? this.userStyle.strokeWidth : (hint.strokeWidth ?? null),
+            highlight: this.userStyle.highlight !== undefined ? this.userStyle.highlight : (hint.highlight ?? null),
+        };
+    }
+    /** Publish the look when it changed: the overlays redraw the regions, the source layer its features. */
+    restyle(redraw = false) {
+        const next = this.effectiveStyle();
+        const cur = this.regionStyle$.value;
+        const same = Object.keys(next).every((k) => next[k] === cur[k]);
+        if (!same)
+            this.regionStyle$.next(next);
+        const view = this.sourceView$.value;
+        if (redraw || !same || (view && view.labels !== this.showShapeLabel)) {
+            this.republishView();
+            this.regionUpdate$.next(this.getRegions());
+        }
+    }
+    /** Re-emit the source view with the current look and label setting. */
+    republishView() {
+        const view = this.sourceView$.value;
+        if (view)
+            this.sourceView$.next({ ...view, style: this.regionStyle$.value, labels: this.showShapeLabel });
+    }
+    /** The slice a region source is keyed by: the display slice in stack mode, else 0. */
+    get sourceSlice() {
+        return this.scope.stackMode ? this.scope.displaySlice : 0;
+    }
+    currentTaken() {
+        return this.sources.taken(this.scope.activeImage, this.sourceSlice);
+    }
+    /** Replace the slice's taken ids and tell the source layers. */
+    setTaken(taken) {
+        if (taken === this.currentTaken())
+            return;
+        this.sources.setTaken(this.scope.activeImage, this.sourceSlice, taken);
+        const view = this.sourceView$.value;
+        if (view)
+            this.sourceView$.next({ ...view, taken });
+    }
+    /**
+     * 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.
+     */
+    refreshSourceView() {
+        const generation = ++this.sourceGeneration;
+        const image = this.scope.activeImage;
+        const slice = this.sourceSlice;
+        if (this.sourceView$.value)
+            this.sourceView$.next(null);
+        this.sources.show(image, slice);
+        if (!this.sources.has(image, slice)) {
+            this.hintStyle = undefined;
+            this.restyle();
+            return;
+        }
+        this.sources.binding(image, slice).then((binding) => {
+            if (generation !== this.sourceGeneration)
+                return;
+            if (!binding) {
+                this.sourceView$.next(null);
+                return;
             }
+            const info = binding.source.info;
+            const classColors = Object.entries(info.classColors);
+            if (classColors.length)
+                this.store.rememberImportedClassColors(new Map(classColors));
+            // A source that asks for labels gets them when it opens (the toggle still turns them off).
+            const labelsOn = !!info.style?.labels && !this.showShapeLabel && this.shownSource !== binding.source;
+            if (labelsOn)
+                this.showShapeLabel = true;
+            this.shownSource = binding.source;
+            this.hintStyle = info.style;
+            this.sourceView$.next({
+                source: binding.source,
+                plane: binding.plane,
+                taken: this.sources.taken(image, slice),
+                colorOf: (f) => f.label ? colorForLabel(f.label, this.store.getPresetSet()) : f.color || this.shapeColor,
+                style: this.regionStyle$.value,
+                labels: this.showShapeLabel,
+                isHidden: (label) => this.isClassHidden(label),
+            });
+            this.restyle(labelsOn);
+        }, (err) => {
+            if (generation !== this.sourceGeneration)
+                return;
+            console.warn('[regions] could not open the region source', err);
+            this.sourceView$.next(null);
+        });
+    }
+    // ── per-image lifecycle ────────────────────────────────────────────────
+    /**
+     * 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) {
+        // Switching images also ends any per-slice stack session (jit-ui#93).
+        const incoming = this.scope.switchImage(RegionScopeCache.imageKey(imageInfo), this.regions);
+        if (!incoming)
+            return;
+        this.regions = incoming;
+        this.selection.replace([]);
+        // Undo never crosses an image switch.
+        this.resetUndoHistory();
+        this.emitSelection();
+        this.regionUpdate$.next(this.getRegions());
+        this.refreshSourceView();
+    }
+    // ── internals ──────────────────────────────────────────────────────────
+    /** Apply the preset set's class colours (see {@link applyPresetColors}),
+     *  promoting unknown classes into the shared store when the set asks for it. */
+    withClassificationColors(regions, inPlace) {
+        return applyPresetColors(regions, this.store.getPresetSet(), {
+            inPlace,
+            onPromote: (preset) => this.store.upsertClass(preset),
+        });
+    }
+    syncCache() {
+        this.scope.sync(this.regions);
+    }
+    emit() {
+        // Live-edit listeners (e.g. the intensity-profile inset) react on EVERY
+        // change — including per-frame during a batched drag — so they track the
+        // region live. The main regionUpdate$ stays coalesced during a batch (fires
+        // once on endBatch) to keep heavier consumers (Regions tab) calm.
+        this.regionLiveEdit$.next(this.regions.slice());
+        if (this.batchDepth > 0) {
+            this.pendingEmit = true;
+            return;
         }
-        return true;
+        this.regionUpdate$.next(this.getRegions());
+    }
+    /** Project the selected ids onto the current regions (pruning gone ones);
+     *  emits only if the index set changed. */
+    emitSelection() {
+        this.selection.sync(this.regions);
+    }
+    findById(id) {
+        return this.regions.find((r) => r.id === id);
+    }
+    indexOfId(id) {
+        return this.regions.findIndex((r) => r.id === id);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionStore, deps: [{ token: i1.VisualizerStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionStore, providedIn: 'root' }); }
@@ -1032,4 +1348,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i1.VisualizerStore }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-store.service.js","sourceRoot":"","sources":["../../../../src/lib/store/region-store.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\n\nimport { IImageInfo } from '../contracts/image.contract';\nimport { Region, Rectangle, Polygon, MultiPolygon, hydrateBounds } from '../models/region';\nimport { PlotUtilities } from '../plot.utilities';\nimport { VisualizerStore } from './visualizer-store.service';\nimport { defaultHandleOffsets } from '../models/bezier';\nimport { IRegionStore } from '../contracts/visualizer.contract';\nimport { IRegionEditApi } from '../contracts/region-store.contract';\nimport { findPreset, fallbackColorFor } from './class-color.util';\n\n/**\n * Backend-neutral region store — the single source of truth for region state.\n *\n * Holds the neutral {@link Region} model (never a backend's own shape\n * representation), keyed per image so regions persist as the user switches\n * files and survive a Plotly⇄OpenSeadragon backend switch (both backends read\n * and write *this* store, so no migration is needed). Backends own *rendering*\n * and react to {@link getRegionUpdateEvent}; this service owns *state* and the\n * editing operations.\n *\n * Implements:\n *  - {@link IRegionStore} — the cross-backend CRUD/selection/colour contract\n *    every consumer (Region Editor, segmentation, etc.) already uses.\n *  - {@link IRegionEditApi} — Region-native geometry edits (move/resize, and\n *    add/delete/move vertex) the OSD overlay drives.\n *\n * Classification colours live in {@link VisualizerStore} (shared by both\n * backends); GeoJSON import/export and the closed-polygon projection reuse the\n * neutral {@link PlotUtilities} helpers. All coordinates are image pixels.\n */\n@Injectable({ providedIn: 'root' })\nexport class RegionStore implements IRegionStore, IRegionEditApi {\n\n  private static readonly UNDO_LIMIT = 10;\n  private static readonly UNDO_COALESCE_MS = 250;\n\n  /** Per-image region cache. `regions` is always a snapshot of the entry for\n   *  `currentImageKey`. */\n  private regionsByImageKey = new Map<string, Region[]>();\n  private currentImageKey: string | undefined;\n  /** The current image's regions — the live, edited array. */\n  private regions: Region[] = [];\n  /** Last saved snapshot, restorable via plotPreviousShapes(). */\n  private previousRegions: Region[] = [];\n\n  /**\n   * Undo/redo history (jit-ui#85): up to {@link UNDO_LIMIT} snapshots of the\n   * region set, each a deep clone captured immediately *before* a\n   * region-editing action. {@link undo} pops the newest off `undoStack`, pushes\n   * the current state onto `redoStack`, and restores it — so it can be invoked\n   * up to {@link UNDO_LIMIT} times in a row. {@link redo} is the mirror. Any new\n   * region action clears `redoStack` (the redo future is no longer reachable).\n   *\n   * A continuous gesture (a wand/brush/vertex drag commits to the store many\n   * times) is coalesced into a single entry: the first commit of a burst\n   * captures the pre-burst state and every commit within\n   * {@link UNDO_COALESCE_MS} of the previous one is folded into it. History\n   * never crosses an image load/switch — {@link resetUndoHistory} clears it.\n   */\n  private undoStack: Region[][] = [];\n  private redoStack: Region[][] = [];\n  /** True while a coalescing burst is open (further commits fold into it). */\n  private undoBurstOpen = false;\n  private undoBurstTimer: ReturnType<typeof setTimeout> | null = null;\n  /** True while restoring a snapshot, so the restore records no new history. */\n  private restoringUndo = false;\n  private readonly canUndo$ = new BehaviorSubject<boolean>(false);\n  private readonly canRedo$ = new BehaviorSubject<boolean>(false);\n\n  /** Monotonic id source — ids never repeat within the service lifetime, so\n   *  selection stays correct across delete/add cycles even when names collide. */\n  private nextId = 1;\n\n  private showShapeLabel = false;\n  private shapeColor = '#00FFFF';\n  private fillColor = '#ff00ff';\n  private isRegionSavedOn = true;\n\n  /**\n   * Per-slice region support for z-stacks (jit-ui#93). While {@link stackMode}\n   * is on (a z-stack is loaded), the live `regions` array always holds ONE\n   * slice — the {@link currentSliceZ} slice — so the on-canvas overlays, the\n   * selection projection, and the Regions table keep working unchanged\n   * (they all read {@link getRegions}). The other slices live in\n   * {@link regionsBySlice}; {@link setDisplaySlice} swaps the live set on scrub\n   * and {@link getSliceRegions} flattens every slice (each tagged with its\n   * zero-based {@link Region.z}) for save/export. Off by default (stackMode\n   * false, z 0), so single-plane images are completely unaffected.\n   */\n  private regionsBySlice = new Map<number, Region[]>();\n  private stackMode = false;\n  private currentSliceZ = 0;\n  /** How a stack's regions round-trip to disk (jit-ui#93): `combined` writes one\n   *  z-indexed geojson (single-file z-stack, QuPath schema); `per-slice-file`\n   *  writes one geojson per slice-file (a folder of numbered images). */\n  private stackSaveLayout: 'combined' | 'per-slice-file' = 'combined';\n  /** Slices that were loaded with regions (jit-ui#93). A per-slice-file save\n   *  re-writes these even when now empty, so clearing a slice's regions and\n   *  saving removes its previously-saved geojson (writes an empty one). */\n  private stackInitialNonEmpty = new Set<number>();\n\n  /** Selection is tracked by region *id* internally (stable across edits) and\n   *  projected to array indices on the IRegionStore boundary. */\n  private selectedIds: number[] = [];\n  private readonly selectedIndices$ = new BehaviorSubject<number[]>([]);\n  private readonly regionUpdate$ = new Subject<Region[]>();\n  /** Non-coalesced sibling of regionUpdate$: fires on every change even during a\n   *  batched drag, so live consumers (intensity inset) update per frame. */\n  private readonly regionLiveEdit$ = new Subject<Region[]>();\n\n  /** Emit coalescing for live drags (see IRegionEditApi.beginBatch). */\n  private batchDepth = 0;\n  private pendingEmit = false;\n\n  private readonly plotUtilities = new PlotUtilities();\n\n  constructor(private store: VisualizerStore) {}\n\n  // ── IRegionStore: CRUD ─────────────────────────────────────────────────\n\n  /**\n   * Replace (or, with `append`, add to) the current image's regions. Mints ids\n   * and default names, applies stored classification colours, and emits. When\n   * `isRegionSaveOn` is false the regions are shown transiently (emitted) but\n   * not stored — mirrors the previous Plotly behaviour.\n   */\n  setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean,\n             fillColor?: string, append: boolean = false): void {\n    if (showRegionLabel === undefined) showRegionLabel = this.showShapeLabel;\n    if (isRegionSaveOn === undefined) isRegionSaveOn = this.isRegionSavedOn;\n    if (fillColor === undefined) fillColor = this.fillColor;\n\n    for (const region of regions) {\n      if (region.id == null) region.id = this.nextId++;\n      if (region.name == null) region.name = `shape${region.id}`;\n      // JSON in, class instances out — everything downstream (the overlays'\n      // rendering, geometry de-dup, moveRegion, GeoJSON export) discriminates\n      // the bounds with `instanceof` (jit-ui#124).\n      region.bounds = hydrateBounds(region.bounds);\n    }\n    this.applyClassificationColors(regions);\n\n    this.isRegionSavedOn = isRegionSaveOn;\n    if (isRegionSaveOn) {\n      this.recordUndoSnapshot();\n      this.showShapeLabel = showRegionLabel;\n      this.fillColor = fillColor;\n      if (append) {\n        // Reject by id collision (already tracked) or geometry equality (same\n        // coordinates) — the find button can push the same region repeatedly.\n        const added = regions.filter(r =>\n          !this.regions.some(existing => existing.id === r.id || this.regionsEqual(existing, r)));\n        this.regions = this.regions.concat(added);\n      } else {\n        this.regions = regions.slice();\n      }\n      this.syncCache();\n      this.emitSelection();\n      this.emit();\n    } else {\n      // Transient display only — don't touch stored state.\n      this.regionUpdate$.next(regions.slice());\n    }\n  }\n\n  /** The canonical accessor: current image's regions (live instances). */\n  getRegions(): Region[] {\n    return this.regions.slice();\n  }\n\n  // ── Per-slice regions for z-stacks (jit-ui#93) ─────────────────────────\n\n  /** True while a z-stack is loaded and the store holds regions per slice. */\n  isStackMode(): boolean { return this.stackMode; }\n\n  /** The current display slice (zero-based). */\n  getDisplaySlice(): number { return this.currentSliceZ; }\n\n  /** How the current stack persists to disk (jit-ui#93): `combined` = one\n   *  z-indexed geojson (single-file z-stack); `per-slice-file` = one geojson per\n   *  slice-file (folder stack). Meaningless outside stack mode. */\n  getStackSaveLayout(): 'combined' | 'per-slice-file' { return this.stackSaveLayout; }\n\n  /**\n   * Enter per-slice stack mode. `slices` maps each zero-based slice index to\n   * the regions imported for that slice; the store makes `initialZ`'s slice the\n   * live set, so the overlays / selection / Regions table are unchanged (they\n   * still read {@link getRegions}). Freshly-created regions are tagged with the\n   * current slice so they persist on it, and {@link getSliceRegions} returns\n   * every slice for save/export. Ids/names/classification colours are minted\n   * exactly as {@link setRegions} does.\n   */\n  enterStackMode(slices: Map<number, Region[]>, initialZ = 0,\n                 saveLayout: 'combined' | 'per-slice-file' = 'combined'): void {\n    this.stackMode = true;\n    this.stackSaveLayout = saveLayout;\n    this.currentSliceZ = initialZ || 0;\n    this.regionsBySlice = new Map<number, Region[]>();\n    this.stackInitialNonEmpty = new Set<number>();\n    for (const [z, regs] of slices) {\n      const normalized = this.normalizeSlice(regs || [], z);\n      this.regionsBySlice.set(z, normalized);\n      if (normalized.length) this.stackInitialNonEmpty.add(z);\n    }\n    this.regions = (this.regionsBySlice.get(this.currentSliceZ) ?? []).slice();\n    this.previousRegions = this.regions.slice();\n    this.selectedIds = [];\n    this.syncCache();\n    this.resetUndoHistory();\n    this.emitSelection();\n    this.emit();\n  }\n\n  /** Leave stack mode (single-plane image, or the stack was closed). */\n  exitStackMode(): void {\n    if (!this.stackMode) return;\n    this.stackMode = false;\n    this.currentSliceZ = 0;\n    this.regionsBySlice = new Map<number, Region[]>();\n    this.stackInitialNonEmpty = new Set<number>();\n  }\n\n  /**\n   * Show a different slice: capture the current slice's (possibly edited)\n   * regions back into the per-slice store, then load the target slice's regions\n   * as the live set and emit. Undo never crosses a slice. Outside stack mode\n   * this only records the requested slice index (a no-op otherwise: single-plane\n   * regions stay on the default plane — addRegion tags Region.z only in stack\n   * mode, so the recorded index is unused until a stack is entered). (jit-ui#93)\n   */\n  setDisplaySlice(z: number): void {\n    const next = z || 0;\n    if (!this.stackMode) { this.currentSliceZ = next; return; }\n    if (this.currentSliceZ === next) return;\n    this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());\n    this.currentSliceZ = next;\n    this.regions = (this.regionsBySlice.get(next) ?? []).slice();\n    this.previousRegions = this.regions.slice();\n    this.selectedIds = [];\n    this.syncCache();\n    this.resetUndoHistory();\n    this.emitSelection();\n    this.emit();\n  }\n\n  /**\n   * Every slice's regions for save/export, each tagged with its zero-based\n   * slice index in {@link Region.z}. Captures the current slice's live edits\n   * first. Returns the flat single-plane set when not in stack mode. (jit-ui#93)\n   */\n  getSliceRegions(): Region[] {\n    if (!this.stackMode) return this.regions.slice();\n    this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());\n    const out: Region[] = [];\n    const zs = Array.from(this.regionsBySlice.keys()).sort((a, b) => a - b);\n    for (const z of zs) {\n      for (const r of this.regionsBySlice.get(z) as Region[]) {\n        r.z = z;\n        out.push(r);\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Slices to write on a per-slice-file save (folder stack, jit-ui#93): every\n   * slice that currently has regions, PLUS slices that were loaded non-empty but\n   * are now empty (so their file is re-written empty, clearing a slice whose\n   * regions the user deleted). Each returned region is tagged with its z, and\n   * the current live slice is captured first. Empty outside stack mode.\n   */\n  getStackSaveSlices(): Map<number, Region[]> {\n    const out = new Map<number, Region[]>();\n    if (!this.stackMode) return out;\n    this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());\n    const zs = new Set<number>(this.stackInitialNonEmpty);\n    for (const [z, regs] of this.regionsBySlice) if (regs.length) zs.add(z);\n    for (const z of Array.from(zs).sort((a, b) => a - b)) {\n      const regs = (this.regionsBySlice.get(z) ?? []).map((r) => { r.z = z; return r; });\n      out.set(z, regs);\n    }\n    return out;\n  }\n\n  /** Mint ids/names + apply classification colours + tag the slice index, as\n   *  {@link setRegions} does, for regions entering the per-slice store. */\n  private normalizeSlice(regions: Region[], z: number): Region[] {\n    for (const region of regions) {\n      if (region.id == null) region.id = this.nextId++;\n      if (region.name == null) region.name = `shape${region.id}`;\n      region.z = z;\n      region.bounds = hydrateBounds(region.bounds);   // jit-ui#124\n    }\n    this.applyClassificationColors(regions);\n    return regions.slice();\n  }\n\n  /**\n   * Closed polygons projected for image-processing consumers (segmentation,\n   * trace builders). Open polylines are annotation-only and excluded. Reuses\n   * the neutral PlotUtilities projection so output matches the previous path.\n   */\n  getRegionPolygons(): any[] {\n    const ret: any[] = [];\n    for (const region of this.regions) {\n      const poly: any = this.plotUtilities.getPolygon({ ...region.getShape(this.showShapeLabel) });\n      if (poly == null || poly.closed === false) continue;\n      ret.push(poly);\n    }\n    return ret;\n  }\n\n  getRegionUpdateEvent(): Observable<any[]> {\n    return this.regionUpdate$.asObservable();\n  }\n\n  /** Live (non-coalesced) region-change stream — fires per frame during a drag.\n   *  Used by the intensity-profile inset so it tracks line ROIs live. */\n  getRegionLiveEdit$(): Observable<Region[]> {\n    return this.regionLiveEdit$.asObservable();\n  }\n\n  // ── IRegionStore: selection ────────────────────────────────────────────\n\n  /** Select regions by array index (or [] to clear). Stored internally by id\n   *  so the selection survives subsequent edits/reorders. */\n  setSelectedShapeIndices(indices: number[]): void {\n    const ids: number[] = [];\n    const seen = new Set<number>();\n    for (const i of indices || []) {\n      if (!Number.isFinite(i) || i < 0 || i >= this.regions.length) continue;\n      const id = this.regions[i].id;\n      if (!seen.has(id)) { seen.add(id); ids.push(id); }\n    }\n    this.selectedIds = ids;\n    this.emitSelection();\n  }\n\n  /** Select a single region by identity (id). Backends call this from their\n   *  `selectRegion()`; the OSD overlay + region editor highlight off the\n   *  resulting selection emit. No-op if the region isn't in the store. */\n  selectRegion(region: Region): void {\n    if (region?.id == null || this.indexOfId(region.id) < 0) return;\n    this.selectedIds = [region.id];\n    this.emitSelection();\n  }\n\n  getSelectedShapeIndices$(): Observable<number[]> {\n    return this.selectedIndices$.asObservable();\n  }\n\n  /** Synchronous current selection (array indices) — for callers that need to\n   *  read the selection without subscribing. */\n  getSelectedShapeIndices(): number[] {\n    return this.selectedIndices$.value;\n  }\n\n  /** Delete the currently selected regions and clear the selection. */\n  deleteActiveShape(): void {\n    if (this.selectedIds.length === 0) return;\n    this.recordUndoSnapshot();\n    const ids = new Set(this.selectedIds);\n    this.regions = this.regions.filter(r => !ids.has(r.id));\n    this.selectedIds = [];\n    this.syncCache();\n    this.emitSelection();\n    this.emit();\n  }\n\n  // ── IRegionStore: colours / labels ─────────────────────────────────────\n\n  getShowShapeLabel(): boolean { return this.showShapeLabel; }\n  getShapeColor(): string { return this.shapeColor; }\n  getFillColor(): string { return this.fillColor; }\n\n  /** Convenience setters (not on the contract) for toolbar wiring. */\n  setShowShapeLabel(show: boolean): void { this.showShapeLabel = show; }\n  setShapeColor(color: string): void { this.shapeColor = color; }\n  setFillColor(color: string): void { this.fillColor = color; }\n\n  getClassificationColors(): Map<string, string> { return this.store.getClassificationColors(); }\n  setClassificationColor(label: string, color: string): void { this.store.setClassificationColor(label, color); }\n\n  // ── IRegionStore: previous-shapes buffer ───────────────────────────────\n\n  /** Re-show the last saved snapshot (transient — does not alter stored state). */\n  plotPreviousShapes(): void {\n    this.regionUpdate$.next(this.previousRegions.slice());\n  }\n  setPreviousShapes(shapes: any[]): void { this.previousRegions = (shapes as Region[]).slice(); }\n  getPreviousShapes(): any[] { return this.previousRegions.slice(); }\n\n  // ── IRegionStore: undo / redo (jit-ui#85) ──────────────────────────────\n\n  /** Emits whether an undo step is currently available — drives the toolbar\n   *  Undo button's enabled state (greyed out when false). */\n  getCanUndo$(): Observable<boolean> {\n    return this.canUndo$.asObservable();\n  }\n\n  /** Emits whether a redo step is currently available — drives the toolbar\n   *  Redo button's enabled state. */\n  getCanRedo$(): Observable<boolean> {\n    return this.canRedo$.asObservable();\n  }\n\n  /** Synchronous read of {@link getCanUndo$} — true when at least one region\n   *  action can be undone. */\n  canUndo(): boolean {\n    return this.undoStack.length > 0;\n  }\n\n  /** Synchronous read of {@link getCanRedo$} — true when an undone action can\n   *  be re-applied. */\n  canRedo(): boolean {\n    return this.redoStack.length > 0;\n  }\n\n  /**\n   * Undo the most recent region action, restoring the region set to its state\n   * just before that action and pushing the current state onto the redo stack.\n   * Up to {@link UNDO_LIMIT} steps are retained, so this can be called up to\n   * {@link UNDO_LIMIT} times in a row before the history empties. No-op when\n   * nothing is left to undo.\n   */\n  undo(): void {\n    if (this.undoStack.length === 0) return;\n    const snapshot = this.undoStack.pop() as Region[];\n    // Stash the current (post-action) state so redo can re-apply it.\n    this.redoStack.push(this.cloneRegions(this.regions));\n    if (this.redoStack.length > RegionStore.UNDO_LIMIT) this.redoStack.shift();\n    this.restoreSnapshot(snapshot);\n  }\n\n  /**\n   * Redo the action most recently undone, restoring the region set to the state\n   * it had before that undo and pushing the current state back onto the undo\n   * stack. No-op when there's nothing to redo (the redo stack is cleared by any\n   * fresh region action).\n   */\n  redo(): void {\n    if (this.redoStack.length === 0) return;\n    const snapshot = this.redoStack.pop() as Region[];\n    this.undoStack.push(this.cloneRegions(this.regions));\n    if (this.undoStack.length > RegionStore.UNDO_LIMIT) this.undoStack.shift();\n    this.restoreSnapshot(snapshot);\n  }\n\n  /** Discard the undo/redo history (e.g. on image load/switch — history never\n   *  crosses images). */\n  resetUndoHistory(): void {\n    this.undoStack = [];\n    this.redoStack = [];\n    this.closeUndoBurst();\n    if (this.canUndo$.value) this.canUndo$.next(false);\n    if (this.canRedo$.value) this.canRedo$.next(false);\n  }\n\n  /** Make `snapshot` the live region set and notify both backends. Shared by\n   *  {@link undo} and {@link redo}; the snapshot is already a detached deep\n   *  clone, so it becomes the live array directly. */\n  private restoreSnapshot(snapshot: Region[]): void {\n    // Close any open coalescing burst so the next edit starts a fresh entry,\n    // and flag the restore so it doesn't record itself back into the history.\n    this.closeUndoBurst();\n    this.restoringUndo = true;\n    this.regions = snapshot;\n    // Drop any selected ids the restored set no longer contains.\n    this.selectedIds = this.selectedIds.filter(id => this.indexOfId(id) >= 0);\n    this.syncCache();\n    this.emitSelection();\n    this.restoringUndo = false;\n    this.emitUndoState();\n    // Notify the live + coalesced streams so whichever backend is on screen\n    // re-renders from the restored store state.\n    this.regionLiveEdit$.next(this.regions.slice());\n    this.regionUpdate$.next(this.getRegions());\n  }\n\n  /**\n   * Capture the pre-action region set into the bounded undo history. Called at\n   * the top of every mutating operation, *before* it changes `regions`, so the\n   * snapshot is the state to return to. Rapid commits from one gesture coalesce\n   * into a single entry (see {@link undoStack}). A fresh action also abandons\n   * any redo future.\n   */\n  private recordUndoSnapshot(): void {\n    if (this.restoringUndo) return;\n    const startsBurst = !this.undoBurstOpen;\n    this.armUndoBurst();\n    if (!startsBurst) return;                      // mid-burst — keep first snapshot\n    this.undoStack.push(this.cloneRegions(this.regions));\n    if (this.undoStack.length > RegionStore.UNDO_LIMIT) this.undoStack.shift();\n    this.redoStack = [];                           // a new edit invalidates redo\n    this.emitUndoState();\n  }\n\n  /** Push the current can-undo / can-redo availability to subscribers. */\n  private emitUndoState(): void {\n    const canUndo = this.undoStack.length > 0;\n    const canRedo = this.redoStack.length > 0;\n    if (this.canUndo$.value !== canUndo) this.canUndo$.next(canUndo);\n    if (this.canRedo$.value !== canRedo) this.canRedo$.next(canRedo);\n  }\n\n  /** (Re)arm the idle timer that closes the current coalescing burst. */\n  private armUndoBurst(): void {\n    this.undoBurstOpen = true;\n    if (this.undoBurstTimer) clearTimeout(this.undoBurstTimer);\n    this.undoBurstTimer = setTimeout(() => {\n      this.undoBurstOpen = false;\n      this.undoBurstTimer = null;\n    }, RegionStore.UNDO_COALESCE_MS);\n  }\n\n  private closeUndoBurst(): void {\n    this.undoBurstOpen = false;\n    if (this.undoBurstTimer) { clearTimeout(this.undoBurstTimer); this.undoBurstTimer = null; }\n  }\n\n  private cloneRegions(regions: Region[]): Region[] {\n    return regions.map(r => this.cloneRegion(r));\n  }\n\n  /** Deep clone a region so an in-place geometry edit can't mutate a stored\n   *  history snapshot (bounds are cloned via {@link cloneBounds}). */\n  private cloneRegion(r: Region): Region {\n    const c = new Region();\n    Object.assign(c, r);\n    c.bounds = r.bounds ? this.cloneBounds(r.bounds) : r.bounds;\n    if (Array.isArray(r.tileCoordinates)) c.tileCoordinates = r.tileCoordinates.slice();\n    return c;\n  }\n\n  // ── IRegionStore: GeoJSON I/O (neutral helpers) ────────────────────────\n\n  importRegions(geoJsonStr: string): Region[] {\n    return this.plotUtilities.importROIsFromGeoJson(geoJsonStr);\n  }\n  exportRegions(regions: Region[]): void {\n    this.plotUtilities.saveToFile(this.plotUtilities.exportROIsToGeoJson(regions));\n  }\n  getGeoJsonString(regions: Region[]): string {\n    return this.plotUtilities.exportROIsToGeoJson(regions);\n  }\n\n  // ── IRegionEditApi: structural edits ───────────────────────────────────\n\n  addRegion(region: Region): number {\n    this.recordUndoSnapshot();\n    if (region.id == null) region.id = this.nextId++;\n    if (region.name == null) region.name = `shape${region.id}`;\n    region.bounds = hydrateBounds(region.bounds);   // jit-ui#124\n    // A region drawn on a stack belongs to the slice currently displayed, so\n    // it saves/reloads on that slice (jit-ui#93). No-op for single-plane images\n    // (currentSliceZ stays 0).\n    if (this.stackMode) region.z = this.currentSliceZ;\n    this.applyClassificationColors([region]);\n    this.regions.push(region);\n    this.selectedIds = [region.id];\n    this.syncCache();\n    this.emitSelection();\n    this.emit();\n    return region.id;\n  }\n\n  removeRegion(id: number): void {\n    const idx = this.indexOfId(id);\n    if (idx < 0) return;\n    this.recordUndoSnapshot();\n    this.regions.splice(idx, 1);\n    this.selectedIds = this.selectedIds.filter(s => s !== id);\n    this.syncCache();\n    this.emitSelection();\n    this.emit();\n  }\n\n  updateBounds(id: number, bounds: Rectangle | Polygon | MultiPolygon): void {\n    const r = this.findById(id);\n    if (!r) return;\n    this.recordUndoSnapshot();\n    r.bounds = this.cloneBounds(bounds);\n    this.syncCache();\n    this.emit();\n  }\n\n  moveRegion(id: number, dx: number, dy: number): void {\n    const r = this.findById(id);\n    if (!r || !r.bounds) return;\n    this.recordUndoSnapshot();\n    const b = r.bounds;\n    if (b instanceof Rectangle) {\n      b.x += dx;\n      b.y += dy;\n    } else if (b instanceof Polygon) {\n      this.translatePolygon(b, dx, dy);\n    } else if (b instanceof MultiPolygon) {\n      // Translate every part (and its holes) together (jit-ui#85).\n      for (const part of b.polygons) this.translatePolygon(part, dx, dy);\n    }\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Translate a polygon's vertices and any holes in place by (dx, dy). */\n  private translatePolygon(p: Polygon, dx: number, dy: number): void {\n    p.xpoints = p.xpoints.map(x => x + dx);\n    p.ypoints = p.ypoints.map(y => y + dy);\n    p.coordinates = p.xpoints.map((x, i) => [x, p.ypoints[i]]);\n    if (p.holes) p.holes = p.holes.map(ring => ring.map(([x, y]) => [x + dx, y + dy]));\n  }\n\n  // ── IRegionEditApi: vertex edits (polygons only) ───────────────────────\n\n  moveVertex(id: number, index: number, x: number, y: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || index < 0 || index >= poly.xpoints.length) return;\n    this.recordUndoSnapshot();\n    poly.xpoints[index] = x;\n    poly.ypoints[index] = y;\n    poly.coordinates[index] = [x, y];\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Move a vertex on a polygon's interior ring (hole) — jit-ui#85. */\n  moveHoleVertex(id: number, holeIndex: number, index: number, x: number, y: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length) return;\n    const ring = poly.holes[holeIndex];\n    if (index < 0 || index >= ring.length) return;\n    this.recordUndoSnapshot();\n    ring[index] = [x, y];\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Insert a vertex on a polygon's interior ring (hole), after `segIndex`\n   *  (the edge's start vertex). No-op for an out-of-range hole — jit-ui#85. */\n  addHoleVertex(id: number, holeIndex: number, segIndex: number, x: number, y: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length) return;\n    const ring = poly.holes[holeIndex];\n    this.recordUndoSnapshot();\n    const at = Math.max(0, Math.min(segIndex + 1, ring.length));\n    ring.splice(at, 0, [x, y]);\n    if (poly.bezier) this.seedHoleHandles(poly); // keep hole handles aligned to the ring\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Delete the vertex at `index` on a polygon's interior ring (hole). Removing\n   *  it below 3 vertices drops the whole hole (a ring with < 3 points bounds no\n   *  area) — jit-ui#85. */\n  deleteHoleVertex(id: number, holeIndex: number, index: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length) return;\n    const ring = poly.holes[holeIndex];\n    if (index < 0 || index >= ring.length) return;\n    this.recordUndoSnapshot();\n    if (ring.length <= 3) {\n      poly.holes.splice(holeIndex, 1);\n      if (poly.holes.length === 0) poly.holes = undefined;\n    } else {\n      ring.splice(index, 1);\n    }\n    if (poly.bezier) this.seedHoleHandles(poly); // keep hole handles aligned to the ring(s)\n    this.syncCache();\n    this.emit();\n  }\n\n  addVertex(id: number, segIndex: number, x: number, y: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly) return;\n    this.recordUndoSnapshot();\n    // Insert after segIndex (the start vertex of the edge). Clamp to range.\n    const at = Math.max(0, Math.min(segIndex + 1, poly.xpoints.length));\n    poly.xpoints.splice(at, 0, x);\n    poly.ypoints.splice(at, 0, y);\n    poly.coordinates = poly.xpoints.map((xx, i) => [xx, poly.ypoints[i]]);\n    poly.npoints = poly.xpoints.length;\n    // Give the new vertex smooth handles from its neighbours; keep the others'\n    // (possibly hand-edited) handles intact.\n    if (poly.bezier && poly.handlesIn && poly.handlesOut) {\n      const n = poly.xpoints.length;\n      const closed = poly.closed !== false;\n      const prev = closed ? (at - 1 + n) % n : Math.max(0, at - 1);\n      const next = closed ? (at + 1) % n : Math.min(n - 1, at + 1);\n      const tx = (poly.xpoints[next] - poly.xpoints[prev]) / 6;\n      const ty = (poly.ypoints[next] - poly.ypoints[prev]) / 6;\n      poly.handlesIn.splice(at, 0, [-tx, -ty]);\n      poly.handlesOut.splice(at, 0, [tx, ty]);\n    }\n    this.syncCache();\n    this.emit();\n  }\n\n  deleteVertex(id: number, index: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || index < 0 || index >= poly.xpoints.length) return;\n    const min = poly.closed === false ? 2 : 3;\n    if (poly.xpoints.length <= min) return; // refuse to degenerate the polygon\n    this.recordUndoSnapshot();\n    poly.xpoints.splice(index, 1);\n    poly.ypoints.splice(index, 1);\n    poly.coordinates = poly.xpoints.map((xx, i) => [xx, poly.ypoints[i]]);\n    poly.npoints = poly.xpoints.length;\n    if (poly.bezier && poly.handlesIn && poly.handlesOut) {\n      poly.handlesIn.splice(index, 1);\n      poly.handlesOut.splice(index, 1);\n    }\n    this.syncCache();\n    this.emit();\n  }\n\n  setBezier(id: number, bezier: boolean): void {\n    const r = this.findById(id);\n    if (!r || !r.bounds) return;\n    if (r.bounds instanceof Polygon) {\n      if (r.bounds.bezier === bezier) return;\n      this.recordUndoSnapshot();\n      this.applyBezier(r.bounds, bezier);\n    } else if (r.bounds instanceof Rectangle && bezier) {\n      this.recordUndoSnapshot();\n      // Smoothing a rectangle: convert it to a 4-anchor closed polygon first.\n      const b = r.bounds;\n      const xs = [b.x, b.x + b.width, b.x + b.width, b.x];\n      const ys = [b.y, b.y, b.y + b.height, b.y + b.height];\n      const poly = new Polygon();\n      poly.npoints = 4;\n      poly.xpoints = xs;\n      poly.ypoints = ys;\n      poly.coordinates = xs.map((x, i) => [x, ys[i]]);\n      poly.closed = true;\n      this.applyBezier(poly, true);\n      r.bounds = poly;\n    } else {\n      return; // bezier=false on a rectangle: nothing to do\n    }\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Turn bezier on (and seed editable handles from the smooth default) or off\n   *  (and drop the handles). */\n  private applyBezier(poly: Polygon, bezier: boolean): void {\n    poly.bezier = bezier;\n    if (bezier) {\n      const off = defaultHandleOffsets(poly.xpoints, poly.ypoints, poly.closed !== false);\n      poly.handlesIn = off.in;\n      poly.handlesOut = off.out;\n      this.seedHoleHandles(poly); // smooth the holes too (donut → bezier curves the holes)\n    } else {\n      poly.handlesIn = undefined;\n      poly.handlesOut = undefined;\n      poly.holeHandlesIn = undefined;\n      poly.holeHandlesOut = undefined;\n    }\n  }\n\n  /** (Re)seed per-hole bezier handles from the Catmull-Rom default, parallel to `poly.holes`. */\n  private seedHoleHandles(poly: Polygon): void {\n    if (!poly.holes || !poly.holes.length) {\n      poly.holeHandlesIn = undefined;\n      poly.holeHandlesOut = undefined;\n      return;\n    }\n    const ins: number[][][] = [];\n    const outs: number[][][] = [];\n    for (const ring of poly.holes) {\n      const off = defaultHandleOffsets(\n        ring.map((p) => p[0]),\n        ring.map((p) => p[1]),\n        true,\n      );\n      ins.push(off.in);\n      outs.push(off.out);\n    }\n    poly.holeHandlesIn = ins;\n    poly.holeHandlesOut = outs;\n  }\n\n  /** Drag a bezier control point on a hole ring vertex (donut bezier editing). */\n  moveHoleBezierHandle(\n    id: number,\n    holeIndex: number,\n    index: number,\n    side: 'in' | 'out',\n    x: number,\n    y: number,\n  ): void {\n    const poly = this.polygonOf(id);\n    if (!poly || !poly.bezier || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length) {\n      return;\n    }\n    const ring = poly.holes[holeIndex];\n    if (index < 0 || index >= ring.length) return;\n    this.recordUndoSnapshot();\n    if (!poly.holeHandlesIn || !poly.holeHandlesOut) this.seedHoleHandles(poly);\n    const offset = [x - ring[index][0], y - ring[index][1]];\n    if (side === 'in') poly.holeHandlesIn![holeIndex][index] = offset;\n    else poly.holeHandlesOut![holeIndex][index] = offset;\n    this.syncCache();\n    this.emit();\n  }\n\n  moveBezierHandle(id: number, index: number, side: 'in' | 'out', x: number, y: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || !poly.bezier || index < 0 || index >= poly.xpoints.length) return;\n    this.recordUndoSnapshot();\n    if (!poly.handlesIn || !poly.handlesOut) {\n      const off = defaultHandleOffsets(poly.xpoints, poly.ypoints, poly.closed !== false);\n      poly.handlesIn = off.in;\n      poly.handlesOut = off.out;\n    }\n    const offset = [x - poly.xpoints[index], y - poly.ypoints[index]];\n    if (side === 'in') poly.handlesIn[index] = offset;\n    else poly.handlesOut[index] = offset;\n    this.syncCache();\n    this.emit();\n  }\n\n  beginBatch(): void { this.batchDepth++; }\n  endBatch(): void {\n    if (this.batchDepth > 0) this.batchDepth--;\n    if (this.batchDepth === 0 && this.pendingEmit) {\n      this.pendingEmit = false;\n      this.regionUpdate$.next(this.getRegions());\n    }\n  }\n\n  // ── per-image lifecycle ────────────────────────────────────────────────\n\n  /**\n   * Switch the active image: snapshot the outgoing regions, restore the\n   * incoming image's (or [] if none), clear selection, and notify. Idempotent\n   * for the same image (so repeated replots of one image keep its regions).\n   */\n  setActiveImage(imageInfo: IImageInfo): void {\n    const newKey = this.deriveImageKey(imageInfo);\n    if (this.currentImageKey === newKey) return;\n    // Switching images ends any per-slice stack session (jit-ui#93); the loader\n    // re-enters stack mode afterwards if the new image is itself a z-stack.\n    this.exitStackMode();\n    if (this.currentImageKey) {\n      this.regionsByImageKey.set(this.currentImageKey, this.regions.slice());\n    }\n    this.currentImageKey = newKey;\n    this.regions = (newKey && this.regionsByImageKey.get(newKey))\n      ? (this.regionsByImageKey.get(newKey) as Region[]).slice()\n      : [];\n    this.previousRegions = this.regions.slice();\n    this.selectedIds = [];\n    // Undo never crosses an image switch.\n    this.resetUndoHistory();\n    this.emitSelection();\n    this.regionUpdate$.next(this.getRegions());\n  }\n\n  /** Drop the entire per-image cache (logout / project switch). */\n  clearRegionsByImageKey(): void {\n    this.regionsByImageKey.clear();\n    this.currentImageKey = undefined;\n    this.regions = [];\n    this.selectedIds = [];\n    this.resetUndoHistory();\n  }\n\n  // ── internals ──────────────────────────────────────────────────────────\n\n  private deriveImageKey(imageInfo: IImageInfo | undefined): string | undefined {\n    if (!imageInfo) return undefined;\n    if (imageInfo.urls && imageInfo.urls.length > 0 && imageInfo.urls[0]) {\n      return imageInfo.urls[0];\n    }\n    return imageInfo.fileName || undefined;\n  }\n\n  /**\n   * Resolve each region's colour from the annotation-class preset set (jit-ui#70).\n   * The presets are the source of truth for colour — this **overrides any colour\n   * embedded in the GeoJSON** (which the YOLO worker writes today). A matching\n   * preset gives the class colour; an unknown class gets a deterministic fallback\n   * colour (and, only when `autoPromote` is on, is added to the editable list).\n   * Regions the user explicitly recoloured (`colorOverridden`) are left untouched.\n   */\n  private applyClassificationColors(regions: Region[]): void {\n    const set = this.store.getPresetSet();\n    const keyOf = (label: string) =>\n      set.matchMode === 'normalized' ? label.trim().toLowerCase() : label;\n    const known = new Set(set.classes.map((c) => keyOf(c.name)));\n    for (const region of regions) {\n      if (!region.label || region.colorOverridden) continue;\n      const preset = findPreset(region.label, set);\n      if (preset) {\n        region.color = preset.color;\n        continue;\n      }\n      const color = fallbackColorFor(region.label, set.fallbackPalette);\n      region.color = color;\n      if (set.autoPromote && !known.has(keyOf(region.label))) {\n        known.add(keyOf(region.label));\n        // In normalized mode, trim the promoted name so leading/trailing\n        // whitespace doesn't create invisible duplicates or odd display names.\n        const name = set.matchMode === 'normalized' ? region.label.trim() : region.label;\n        this.store.upsertClass({ name, color, source: 'auto' });\n      }\n    }\n  }\n\n  private syncCache(): void {\n    if (this.currentImageKey) {\n      this.regionsByImageKey.set(this.currentImageKey, this.regions.slice());\n    }\n  }\n\n  private emit(): void {\n    // Live-edit listeners (e.g. the intensity-profile inset) react on EVERY\n    // change — including per-frame during a batched drag — so they track the\n    // region live. The main regionUpdate$ stays coalesced during a batch (fires\n    // once on endBatch) to keep heavier consumers (Regions tab) calm.\n    this.regionLiveEdit$.next(this.regions.slice());\n    if (this.batchDepth > 0) { this.pendingEmit = true; return; }\n    this.regionUpdate$.next(this.getRegions());\n  }\n\n  /** Project selected ids to current array indices, pruning ids that no longer\n   *  exist, and emit if the index set changed. */\n  private emitSelection(): void {\n    const indices: number[] = [];\n    const liveIds: number[] = [];\n    for (const id of this.selectedIds) {\n      const idx = this.indexOfId(id);\n      if (idx >= 0) { indices.push(idx); liveIds.push(id); }\n    }\n    this.selectedIds = liveIds;\n    if (!this.indicesEqual(this.selectedIndices$.value, indices)) {\n      this.selectedIndices$.next(indices);\n    }\n  }\n\n  private indicesEqual(a: number[], b: number[]): boolean {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n    return true;\n  }\n\n  private findById(id: number): Region | undefined {\n    return this.regions.find(r => r.id === id);\n  }\n\n  private indexOfId(id: number): number {\n    return this.regions.findIndex(r => r.id === id);\n  }\n\n  /** The region's bounds as a Polygon, or undefined if it isn't a polygon. */\n  private polygonOf(id: number): Polygon | undefined {\n    const r = this.findById(id);\n    return r && r.bounds instanceof Polygon ? r.bounds : undefined;\n  }\n\n  private clonePolygon(p: Polygon): Polygon {\n    const poly = new Polygon();\n    poly.npoints = p.npoints;\n    poly.xpoints = p.xpoints.slice();\n    poly.ypoints = p.ypoints.slice();\n    poly.coordinates = p.coordinates.map(c => c.slice());\n    poly.closed = p.closed;\n    poly.bezier = p.bezier;\n    if (p.handlesIn) poly.handlesIn = p.handlesIn.map(o => o.slice());\n    if (p.handlesOut) poly.handlesOut = p.handlesOut.map(o => o.slice());\n    if (p.holes) poly.holes = p.holes.map(ring => ring.map(pt => pt.slice()));\n    if (p.holeHandlesIn) poly.holeHandlesIn = p.holeHandlesIn.map(r => r.map(o => o.slice()));\n    if (p.holeHandlesOut) poly.holeHandlesOut = p.holeHandlesOut.map(r => r.map(o => o.slice()));\n    return poly;\n  }\n\n  private cloneBounds(bounds: Rectangle | Polygon | MultiPolygon): Rectangle | Polygon | MultiPolygon {\n    if (bounds instanceof Rectangle) {\n      const rect = new Rectangle();\n      rect.x = bounds.x; rect.y = bounds.y; rect.width = bounds.width; rect.height = bounds.height;\n      return rect;\n    }\n    if (bounds instanceof MultiPolygon) {\n      const mp = new MultiPolygon();\n      mp.polygons = bounds.polygons.map(p => this.clonePolygon(p));\n      return mp;\n    }\n    return this.clonePolygon(bounds);\n  }\n\n  private regionsEqual(a: Region, b: Region): boolean {\n    const ba = a.bounds, bb = b.bounds;\n    if (ba instanceof Rectangle && bb instanceof Rectangle) {\n      return ba.x === bb.x && ba.y === bb.y && ba.width === bb.width && ba.height === bb.height;\n    }\n    if (ba instanceof MultiPolygon && bb instanceof MultiPolygon) {\n      if (ba.polygons.length !== bb.polygons.length) return false;\n      for (let i = 0; i < ba.polygons.length; i++) {\n        if (!this.polygonsEqual(ba.polygons[i], bb.polygons[i])) return false;\n      }\n      return true;\n    }\n    if (ba instanceof Polygon && bb instanceof Polygon) {\n      return this.polygonsEqual(ba, bb);\n    }\n    return false;\n  }\n\n  private polygonsEqual(pa: Polygon, pb: Polygon): boolean {\n    if ((pa.closed !== false) !== (pb.closed !== false)) return false;\n    if (pa.xpoints.length !== pb.xpoints.length) return false;\n    for (let i = 0; i < pa.xpoints.length; i++) {\n      if (pa.xpoints[i] !== pb.xpoints[i] || pa.ypoints[i] !== pb.ypoints[i]) return false;\n    }\n    return this.holesEqual(pa.holes, pb.holes);\n  }\n\n  /** Compare two polygons' interior-ring (hole) sets for the dedupe path. */\n  private holesEqual(a: number[][][] | undefined, b: number[][][] | undefined): boolean {\n    const na = a?.length ?? 0, nb = b?.length ?? 0;\n    if (na !== nb) return false;\n    for (let h = 0; h < na; h++) {\n      const ra = (a as number[][][])[h], rb = (b as number[][][])[h];\n      if (ra.length !== rb.length) return false;\n      for (let i = 0; i < ra.length; i++) {\n        if (ra[i][0] !== rb[i][0] || ra[i][1] !== rb[i][1]) return false;\n      }\n    }\n    return true;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-store.service.js","sourceRoot":"","sources":["../../../../src/lib/store/region-store.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\n\nimport { IImageInfo } from '../contracts/image.contract';\nimport { Region, Rectangle, Polygon, MultiPolygon, hydrateBounds } from '../models/region';\nimport {\n  GeoJsonFeature,\n  downloadGeoJson,\n  featureFromRegion,\n  regionFromGeoJsonFeature,\n  regionsFromGeoJson,\n  regionsToGeoJson,\n} from '../models/region-geojson';\nimport { VisualizerStore } from './visualizer-store.service';\nimport { IRegionStore } from '../contracts/visualizer.contract';\nimport { IRegionEditApi, IRegionSourceApi } from '../contracts/region-store.contract';\nimport { applyPresetColors, colorForLabel, presetKey } from './class-color.util';\nimport {\n  cloneBounds,\n  makePolygon,\n  rectToRing,\n  regionPolygons,\n  regionPolylines,\n  replaceBounds,\n} from '../models/polygon-factory';\nimport type { Mesh } from 'napari-js/geometry';\nimport { SliceOutlines, outlinesArea } from '../geometry/reconstruct';\nimport { reconstructInWorker } from '../region-source/worker-region-source';\nimport * as edit from '../models/polygon-edit';\nimport { regionsEqual, withRegionPatch, withRegionZ } from '../models/region-clone';\nimport { RegionHistory } from './region-history';\nimport { RegionSelection } from './region-selection';\nimport { RegionScopeCache, StackSaveLayout } from './region-scope-cache';\nimport { RegionSourceOpener, RegionSourceScope, RegionSourceSlices } from './region-source-scope';\nimport type { RegionSource, RegionSourceView } from '../region-source/region-source';\nimport type { RegionIndexPage, RegionIndexQuery, RegionSourceStyle } from '../region-source/region-tiles';\nimport { DEFAULT_REGION_STYLE, RegionStyle } from '../region-overlay/region-style';\n\n/** Selecting classes takes at most this many region-source features into the regions. */\nexport const SELECT_CLASSES_LIMIT = 5000;\n/** A region source's outlines on a slice, each ring's and line's class with it when read for all. */\ntype LabelledOutlines = SliceOutlines & { ringLabels?: string[]; lineLabels?: string[] };\n\n/** Class sets whose region-source outlines are kept for rebuilding their surfaces. */\nconst SOURCE_OUTLINE_CACHE_SIZE = 8;\n/** Classes whose region-source part of the volume is kept (see RegionStore.classVolumes). */\nconst SOURCE_VOLUME_CACHE_SIZE = 64;\n\n/** A slice's rings, each with its feature (see SliceOutlines.ringGroups), and its lines. */\ninterface SliceParts {\n  rings: ArrayLike<number>[];\n  ringGroups: number[];\n  lines: ArrayLike<number>[];\n}\n\n/**\n * Feature ids unique across outlines read from several places: each call gives one part's\n * renumbering of its own ids (a part without them is one feature).\n */\nfunction featureIds(): () => (own: number | undefined) => number {\n  let next = 0;\n  return () => {\n    const ids = new Map<number | undefined, number>();\n    return (own) => {\n      let id = ids.get(own);\n      if (id === undefined) ids.set(own, (id = next++));\n      return id;\n    };\n  };\n}\n\n/** A slice's parts as outlines. */\nfunction sliceOutlines(z: number, s: SliceParts): SliceOutlines {\n  return {\n    z,\n    rings: s.rings,\n    ...(s.rings.length ? { ringGroups: s.ringGroups } : {}),\n    ...(s.lines.length ? { lines: s.lines } : {}),\n  };\n}\n\n/**\n * Outlines by slice merged into one entry per slice (rings, then lines), in slice order, each\n * part's features apart from the others' (they fill as their union).\n */\nfunction mergeOutlines(parts: readonly SliceOutlines[]): SliceOutlines[] {\n  const byZ = new Map<number, SliceParts>();\n  const nextPart = featureIds();\n  for (const part of parts) {\n    if (!part.rings.length && !part.lines?.length) continue;\n    let slice = byZ.get(part.z);\n    if (!slice) byZ.set(part.z, (slice = { rings: [], ringGroups: [], lines: [] }));\n    const id = nextPart();\n    part.rings.forEach((r, i) => {\n      slice.rings.push(r);\n      slice.ringGroups.push(id(part.ringGroups?.[i]));\n    });\n    slice.lines.push(...(part.lines ?? []));\n  }\n  return Array.from(byZ, ([z, s]) => sliceOutlines(z, s)).sort((a, b) => a.z - b.z);\n}\n\n/** The region sources' part of a class's volume: its area on each slice, with the outlines. */\ninterface SourceVolume {\n  total: number;\n  slices: ReadonlyMap<number, { area: number; outlines: SliceOutlines }>;\n}\n\n/** One undo step: the region set and, for a slice with a region source, what was taken from it. */\ninterface RegionSnapshot {\n  regions: Region[];\n  taken: ReadonlySet<string>;\n}\n\n/**\n * Backend-neutral region store — the single source of truth for region state.\n *\n * Holds the neutral {@link Region} model (never a backend's own shape\n * representation), keyed per image so regions persist as the user switches\n * files and survive a Plotly⇄OpenSeadragon backend switch (both backends read\n * and write *this* store, so no migration is needed). Backends own *rendering*\n * and react to {@link getRegionUpdateEvent}; this service owns *state* and the\n * editing operations.\n *\n * Implements:\n *  - {@link IRegionStore} — the cross-backend CRUD/selection/colour contract\n *    every consumer (Region Editor, segmentation, etc.) already uses.\n *  - {@link IRegionEditApi} — Region-native geometry edits (move/resize, and\n *    add/delete/move vertex) the OSD overlay drives.\n *\n * Copy-on-write (review RT-13): no operation changes a stored {@link Region}\n * (or the regions array) in place. An edit builds a replacement — the geometry\n * through the pure `models/polygon-edit` functions — and swaps it in, so the\n * undo history ({@link RegionHistory}) can keep shallow snapshots that share\n * every untouched region instead of deep-cloning the whole set per step.\n * Callers must follow the same rule with the instances {@link getRegions}\n * returns: treat them as read-only, and commit a changed copy.\n *\n * Classification colours live in {@link VisualizerStore} (shared by both\n * backends); GeoJSON import/export is `models/region-geojson`. All coordinates\n * are image pixels.\n */\n@Injectable({ providedIn: 'root' })\nexport class RegionStore implements IRegionStore, IRegionEditApi, IRegionSourceApi {\n  private static readonly UNDO_LIMIT = 10;\n  private static readonly UNDO_COALESCE_MS = 250;\n\n  /** The current image's regions — the live, edited array. */\n  private regions: Region[] = [];\n\n  /**\n   * Undo/redo history (jit-ui#85): up to {@link UNDO_LIMIT} snapshots of the\n   * region set, each taken just *before* a region-editing action; continuous\n   * gestures and rapid commits coalesce (see {@link RegionHistory}). Snapshots\n   * are shallow — the regions array as it was — which is safe because nothing\n   * here mutates a region or an array in place (RT-13). History never crosses an\n   * image load/switch — {@link resetUndoHistory} clears it.\n   */\n  private readonly history = new RegionHistory<RegionSnapshot>(\n    RegionStore.UNDO_LIMIT,\n    RegionStore.UNDO_COALESCE_MS,\n  );\n\n  /** Monotonic id source — ids never repeat within the service lifetime, so\n   *  selection stays correct across delete/add cycles even when names collide. */\n  private nextId = 1;\n\n  private showShapeLabel = false;\n  private shapeColor = '#00FFFF';\n  private fillColor = '#ff00ff';\n  private isRegionSavedOn = true;\n\n  /**\n   * Per-image cache and, for z-stacks, per-slice regions (jit-ui#93). In stack\n   * mode the live `regions` array holds ONE slice — the display slice — so the\n   * overlays, the selection projection and the Regions table work unchanged\n   * (they all read {@link getRegions}); {@link setDisplaySlice} swaps the live\n   * set on scrub and {@link getSliceRegions} flattens every slice (each tagged\n   * with its zero-based {@link Region.z}) for save/export. Off by default, so\n   * single-plane images are unaffected.\n   */\n  private readonly scope = new RegionScopeCache();\n\n  /** Selection by region *id* (stable across edits), projected to array\n   *  indices on the IRegionStore boundary. */\n  private readonly selection = new RegionSelection();\n  private readonly regionUpdate$ = new Subject<Region[]>();\n  /** Non-coalesced sibling of regionUpdate$: fires on every change even during a\n   *  batched drag, so live consumers (intensity inset) update per frame. */\n  private readonly regionLiveEdit$ = new Subject<Region[]>();\n  /** See {@link getRegionSetReplaced$}. */\n  private readonly regionSetReplaced$ = new Subject<void>();\n\n  /** Emit coalescing for live drags (see IRegionEditApi.beginBatch). */\n  private batchDepth = 0;\n  private pendingEmit = false;\n\n  /**\n   * Large region sets held as tiled region sources rather than as regions (see\n   * {@link attachRegionSource}): per image and slice, with the ids taken out of each.\n   */\n  private readonly sources = new RegionSourceScope();\n  private readonly sourceView$ = new BehaviorSubject<RegionSourceView | null>(null);\n  /** The region look the user chose (overrides the source's hint), field by field. */\n  private userStyle: Partial<RegionStyle> = {};\n  /** The current source's style hint. */\n  private hintStyle: RegionSourceStyle | undefined;\n  private readonly regionStyle$ = new BehaviorSubject<RegionStyle>(DEFAULT_REGION_STYLE);\n  /** Bumped on every change of the slice's source, so a late open is dropped. */\n  private sourceGeneration = 0;\n  /** The source last published as the view: a source shown again does not turn the labels back on. */\n  private shownSource: RegionSource | null = null;\n  /** Bumped when a region source is attached or dropped: what is read from the sources is stale. */\n  private sourcesVersion = 0;\n\n  /**\n   * The region sources' part of {@link classVolumes}, by class and what the sources hold (see\n   * {@link sourceStateKey}): an edit of the regions leaves it, so the volumes of a slice being drawn\n   * on cost no source reads.\n   */\n  private readonly sourceVolumeCache = new Map<string, Promise<SourceVolume>>();\n  /** The region sources' outlines of the class sets reconstructed last (see {@link sourceOutlines}). */\n  private readonly sourceOutlineCache = new Map<string, Promise<LabelledOutlines[]>>();\n\n  /** The classes hidden from view (names as given); every class is shown at first. */\n  private readonly hiddenClasses$ = new BehaviorSubject<ReadonlySet<string>>(new Set());\n  /** {@link hiddenClasses$} by {@link presetKey}, as a region's label is matched. */\n  private hiddenKeys: ReadonlySet<string> = new Set();\n\n  constructor(private store: VisualizerStore) {\n    // A class colour change recolours the source's features as it recolours regions.\n    this.store.getPresetSet$().subscribe(() => {\n      const view = this.sourceView$.value;\n      if (view) this.sourceView$.next({ ...view });\n    });\n  }\n\n  // ── IRegionStore: CRUD ─────────────────────────────────────────────────\n\n  /**\n   * Replace (or, with `append`, add to) the current image's regions. Mints ids\n   * and default names, applies stored classification colours, and emits. When\n   * `isRegionSaveOn` is false the regions are shown transiently (emitted) but\n   * not stored — mirrors the previous Plotly behaviour.\n   */\n  setRegions(\n    regions: Region[],\n    showRegionLabel?: boolean,\n    isRegionSaveOn?: boolean,\n    fillColor?: string,\n    append: boolean = false,\n  ): void {\n    if (showRegionLabel === undefined) showRegionLabel = this.showShapeLabel;\n    if (isRegionSaveOn === undefined) isRegionSaveOn = this.isRegionSavedOn;\n    if (fillColor === undefined) fillColor = this.fillColor;\n\n    regions = this.admit(regions);\n\n    this.isRegionSavedOn = isRegionSaveOn;\n    if (isRegionSaveOn) {\n      this.recordUndoSnapshot();\n      if (this.showShapeLabel !== showRegionLabel) {\n        this.showShapeLabel = showRegionLabel;\n        this.republishView();\n      }\n      this.fillColor = fillColor;\n      if (append) {\n        // Reject by id collision (already tracked) or geometry equality (same\n        // coordinates) — the find button can push the same region repeatedly.\n        const added = regions.filter(\n          (r) => !this.regions.some((existing) => existing.id === r.id || regionsEqual(existing, r)),\n        );\n        this.regions = this.regions.concat(added);\n      } else {\n        this.regions = regions.slice();\n      }\n      this.syncCache();\n      this.emitSelection();\n      this.emit();\n    } else {\n      // Transient display only — don't touch stored state.\n      this.regionUpdate$.next(regions.slice());\n    }\n  }\n\n  /**\n   * The canonical accessor: the current image's regions. A fresh array, but the\n   * instances are the stored ones, shared with the undo history: treat them as\n   * read-only and change a region through the store's operations (or by\n   * committing a copy). Typed `Region[]` rather than\n   * `ReadonlyArray<Readonly<Region>>` because the IRegionStore contract and the\n   * backends still take a mutable array.\n   */\n  getRegions(): Region[] {\n    return this.regions.slice();\n  }\n\n  // ── Per-slice regions for z-stacks (jit-ui#93) ─────────────────────────\n\n  /** True while a z-stack is loaded and the store holds regions per slice. */\n  isStackMode(): boolean {\n    return this.scope.stackMode;\n  }\n\n  /** The current display slice (zero-based). */\n  getDisplaySlice(): number {\n    return this.scope.displaySlice;\n  }\n\n  /** How the current stack persists to disk (jit-ui#93): `combined` = one\n   *  z-indexed geojson (single-file z-stack); `per-slice-file` = one geojson per\n   *  slice-file (folder stack). Meaningless outside stack mode. */\n  getStackSaveLayout(): StackSaveLayout {\n    return this.scope.saveLayout;\n  }\n\n  /**\n   * Enter per-slice stack mode. `slices` maps each zero-based slice index to\n   * the regions imported for that slice; the store makes `initialZ`'s slice the\n   * live set, so the overlays / selection / Regions table are unchanged (they\n   * still read {@link getRegions}). Freshly-created regions are tagged with the\n   * current slice so they persist on it, and {@link getSliceRegions} returns\n   * every slice for save/export. Ids/names/classification colours are minted\n   * exactly as {@link setRegions} does.\n   */\n  enterStackMode(slices: Map<number, Region[]>, initialZ = 0, saveLayout: StackSaveLayout = 'combined'): void {\n    const admitted = new Map<number, Region[]>();\n    for (const [z, regs] of slices) admitted.set(z, this.normalizeSlice(regs || [], z));\n    this.regions = this.scope.enterStack(admitted, initialZ, saveLayout);\n    this.selection.replace([]);\n    this.syncCache();\n    this.resetUndoHistory();\n    this.emitSelection();\n    this.emit();\n    this.refreshSourceView();\n  }\n\n  /** Leave stack mode (single-plane image, or the stack was closed). */\n  exitStackMode(): void {\n    this.scope.exitStack();\n    this.refreshSourceView();\n  }\n\n  /** The live-set swap of {@link setDisplaySlice}. */\n  private showSlice(z: number): void {\n    const next = this.scope.showSlice(z, this.regions);\n    if (!next) return;\n    this.regions = next;\n    this.selection.replace([]);\n    this.syncCache();\n    this.resetUndoHistory();\n    this.emitSelection();\n    this.emit();\n    this.refreshSourceView();\n  }\n\n  /**\n   * Show a different slice: capture the current slice's (possibly edited)\n   * regions back into the per-slice store, then load the target slice's regions\n   * as the live set and emit. Undo never crosses a slice. Outside stack mode\n   * this only records the requested slice index (a no-op otherwise: single-plane\n   * regions stay on the default plane — addRegion tags Region.z only in stack\n   * mode, so the recorded index is unused until a stack is entered). (jit-ui#93)\n   * Either way {@link getRegionSetReplaced$} emits: the slice on screen changed\n   * under any in-progress tool work.\n   */\n  setDisplaySlice(z: number): void {\n    this.showSlice(z);\n    this.regionSetReplaced$.next();\n  }\n\n  /**\n   * Every slice's regions for save/export, each tagged with its zero-based\n   * slice index in {@link Region.z}. Captures the current slice's live edits\n   * first. Returns the flat single-plane set when not in stack mode. (jit-ui#93)\n   */\n  getSliceRegions(): Region[] {\n    return this.scope.sliceRegions(this.regions);\n  }\n\n  /**\n   * Slices to write on a per-slice-file save (folder stack, jit-ui#93): every\n   * slice that currently has regions, PLUS slices that were loaded non-empty but\n   * are now empty (so their file is re-written empty, clearing a slice whose\n   * regions the user deleted). Each returned region is tagged with its z, and\n   * the current live slice is captured first. Empty outside stack mode.\n   */\n  getStackSaveSlices(): Map<number, Region[]> {\n    const slices = this.scope.stackSaveSlices(this.regions);\n    // A slice whose region source lost features (taken, deleted) is re-written too.\n    const changed = this.sources.slicesWithTaken(this.scope.activeImage).filter((z) => !slices.has(z));\n    if (!changed.length) return slices;\n    for (const z of changed) slices.set(z, []);\n    return new Map(Array.from(slices).sort((a, b) => a[0] - b[0]));\n  }\n\n  /** Mint ids/names + apply classification colours + tag the slice index, as\n   *  {@link setRegions} does, for regions entering the per-slice store. */\n  private normalizeSlice(regions: Region[], z: number): Region[] {\n    // A fresh (imported) region is tagged in place; a stored one is copied.\n    return this.admit(regions.map((r) => (r.id == null ? Object.assign(r, { z }) : withRegionZ(r, z))));\n  }\n\n  /**\n   * Regions entering the store: mint ids and default names, hydrate JSON bounds\n   * into class instances — everything downstream (rendering, geometry de-dup,\n   * moveRegion, GeoJSON export) discriminates them with `instanceof`\n   * (jit-ui#124) — and apply classification colours. A region that is new to\n   * the store (no id yet) is completed in place; one that already has an id may\n   * be a stored instance shared with the undo history, so it is copied if it\n   * changes.\n   */\n  private admit(regions: Region[]): Region[] {\n    const fresh = new Set<Region>();\n    const admitted = regions.map((region) => {\n      if (region.id == null) {\n        region.id = this.nextId++;\n        if (region.name == null) region.name = `shape${region.id}`;\n        region.bounds = hydrateBounds(region.bounds);\n        fresh.add(region);\n        return region;\n      }\n      const bounds = hydrateBounds(region.bounds);\n      return region.name == null || bounds !== region.bounds\n        ? withRegionPatch(region, { name: region.name ?? `shape${region.id}`, bounds })\n        : region;\n    });\n    return this.withClassificationColors(admitted, (r) => fresh.has(r));\n  }\n\n  /**\n   * Closed polygons projected for image-processing consumers (segmentation,\n   * crop requests, trace builders), straight from each region's bounds: a\n   * rectangle's corners, a polygon with its holes (a bézier as its curve), one\n   * polygon per part of a multi-polygon. Open polylines are annotation-only and\n   * excluded. Coordinates are rounded to whole pixels.\n   */\n  getRegionPolygons(): Polygon[] {\n    return this.regions.flatMap((region) => regionPolygons(region));\n  }\n\n  getRegionUpdateEvent(): Observable<any[]> {\n    return this.regionUpdate$.asObservable();\n  }\n\n  /** Live (non-coalesced) region-change stream — fires per frame during a drag.\n   *  Used by the intensity-profile inset so it tracks line ROIs live. */\n  getRegionLiveEdit$(): Observable<Region[]> {\n    return this.regionLiveEdit$.asObservable();\n  }\n\n  /**\n   * Emits after every {@link undo}, {@link redo} and {@link setDisplaySlice} call\n   * (even one that changed nothing): the region set was replaced under whatever\n   * a canvas tool was building on (a brush stroke, a SAM point prompt), so the\n   * backends reset their canvas tools on it. Not emitted for ordinary edits —\n   * a tool's own commit must not reset it.\n   */\n  getRegionSetReplaced$(): Observable<void> {\n    return this.regionSetReplaced$.asObservable();\n  }\n\n  // ── IRegionStore: selection ────────────────────────────────────────────\n\n  /** Select regions by array index (or [] to clear). Stored internally by id\n   *  so the selection survives subsequent edits/reorders. */\n  setSelectedShapeIndices(indices: number[]): void {\n    this.selection.selectIndices(indices, this.regions);\n  }\n\n  /** Select a single region by identity (id). Backends call this from their\n   *  `selectRegion()`; the OSD overlay + region editor highlight off the\n   *  resulting selection emit. No-op if the region isn't in the store. */\n  selectRegion(region: Region): void {\n    if (region?.id == null || this.indexOfId(region.id) < 0) return;\n    this.selection.replace([region.id]);\n    this.emitSelection();\n  }\n\n  getSelectedShapeIndices$(): Observable<number[]> {\n    return this.selection.indices$;\n  }\n\n  /** Synchronous current selection (array indices) — for callers that need to\n   *  read the selection without subscribing. */\n  getSelectedShapeIndices(): number[] {\n    return this.selection.indices;\n  }\n\n  /** Delete the currently selected regions and clear the selection. */\n  deleteActiveShape(): void {\n    if (this.selection.ids.length === 0) return;\n    this.recordUndoSnapshot();\n    const ids = new Set(this.selection.ids);\n    this.regions = this.regions.filter((r) => !ids.has(r.id));\n    this.selection.replace([]);\n    this.syncCache();\n    this.emitSelection();\n    this.emit();\n  }\n\n  // ── IRegionStore: colours / labels ─────────────────────────────────────\n\n  getShowShapeLabel(): boolean {\n    return this.showShapeLabel;\n  }\n  getShapeColor(): string {\n    return this.shapeColor;\n  }\n  getFillColor(): string {\n    return this.fillColor;\n  }\n\n  /** Show or hide region labels (not on the contract; specs drive it directly).\n   *  @deprecated Nothing in the library calls it; will be removed next minor. */\n  setShowShapeLabel(show: boolean): void {\n    this.showShapeLabel = show;\n    this.republishView();\n  }\n\n  getClassificationColors(): Map<string, string> {\n    return this.store.getClassificationColors();\n  }\n  setClassificationColor(label: string, color: string): void {\n    this.store.setClassificationColor(label, color);\n  }\n\n  // ── IRegionStore: undo / redo (jit-ui#85) ──────────────────────────────\n\n  /** Emits whether an undo step is currently available — drives the toolbar\n   *  Undo button's enabled state (greyed out when false). */\n  getCanUndo$(): Observable<boolean> {\n    return this.history.canUndo$;\n  }\n\n  /** Emits whether a redo step is currently available — drives the toolbar\n   *  Redo button's enabled state. */\n  getCanRedo$(): Observable<boolean> {\n    return this.history.canRedo$;\n  }\n\n  /** Synchronous read of {@link getCanUndo$} — true when at least one region\n   *  action can be undone. */\n  canUndo(): boolean {\n    return this.history.canUndo();\n  }\n\n  /** Synchronous read of {@link getCanRedo$} — true when an undone action can\n   *  be re-applied. */\n  canRedo(): boolean {\n    return this.history.canRedo();\n  }\n\n  /**\n   * Undo the most recent region action, restoring the region set to its state\n   * just before that action and pushing the current state onto the redo stack.\n   * Up to {@link UNDO_LIMIT} steps are retained, so this can be called up to\n   * {@link UNDO_LIMIT} times in a row before the history empties. No-op when\n   * nothing is left to undo.\n   */\n  undo(): void {\n    const snapshot = this.history.undo(this.snapshot());\n    if (snapshot) this.restoreSnapshot(snapshot);\n    this.regionSetReplaced$.next();\n  }\n\n  /**\n   * Redo the action most recently undone, restoring the region set to the state\n   * it had before that undo and pushing the current state back onto the undo\n   * stack. No-op when there's nothing to redo (the redo stack is cleared by any\n   * fresh region action).\n   */\n  redo(): void {\n    const snapshot = this.history.redo(this.snapshot());\n    if (snapshot) this.restoreSnapshot(snapshot);\n    this.regionSetReplaced$.next();\n  }\n\n  /** Discard the undo/redo history (e.g. on image load/switch — history never\n   *  crosses images). */\n  resetUndoHistory(): void {\n    this.history.reset();\n  }\n\n  /** Make `snapshot` the live region set and notify both backends. Shared by\n   *  {@link undo} and {@link redo}; nothing records history while it runs. */\n  private restoreSnapshot(snapshot: RegionSnapshot): void {\n    this.history.restore(() => {\n      this.regions = snapshot.regions.slice();\n      this.setTaken(snapshot.taken);\n      this.syncCache();\n      // Drops any selected ids the restored set no longer contains.\n      this.emitSelection();\n    });\n    // Notify the live + coalesced streams so whichever backend is on screen\n    // re-renders from the restored store state.\n    this.regionLiveEdit$.next(this.regions.slice());\n    this.regionUpdate$.next(this.getRegions());\n  }\n\n  /**\n   * Capture the pre-action region set into the bounded undo history. Called at\n   * the top of every mutating operation, *before* it changes `regions`. The\n   * snapshot is the array itself: every operation replaces `regions` (and any\n   * region it edits) rather than changing them, so it never changes after this.\n   */\n  private recordUndoSnapshot(): void {\n    this.history.record(this.snapshot());\n  }\n\n  /** The state an undo step restores. */\n  private snapshot(): RegionSnapshot {\n    return { regions: this.regions, taken: this.currentTaken() };\n  }\n\n  // ── IRegionStore: GeoJSON I/O (models/region-geojson) ──────────────────\n\n  /** Parse GeoJSON into regions, remembering the class colours the file carries so they are\n   *  kept for classes with no preset (see VisualizerStore.rememberImportedClassColors). */\n  importRegions(geoJsonStr: string): Region[] {\n    const regions = regionsFromGeoJson(geoJsonStr);\n    const colors = new Map<string, string>();\n    for (const r of regions) {\n      if (r.label && r.color && !colors.has(r.label)) colors.set(r.label, r.color);\n    }\n    if (colors.size) this.store.rememberImportedClassColors(colors);\n    return regions;\n  }\n  /** Download `regions` as GeoJSON, named after `fileName` (extension\n   *  replaced by `.geojson`) or `rois.geojson` without one. */\n  exportRegions(regions: Region[], fileName?: string): void {\n    downloadGeoJson(regionsToGeoJson(regions), fileName);\n  }\n  getGeoJsonString(regions: Region[]): string {\n    return regionsToGeoJson(regions);\n  }\n\n  // ── IRegionEditApi: structural edits ───────────────────────────────────\n\n  addRegion(region: Region): number {\n    this.recordUndoSnapshot();\n    if (region.id == null) region.id = this.nextId++;\n    if (region.name == null) region.name = `shape${region.id}`;\n    region.bounds = hydrateBounds(region.bounds); // jit-ui#124\n    // A region drawn on a stack belongs to the slice currently displayed, so\n    // it saves/reloads on that slice (jit-ui#93). No-op for single-plane images\n    // (the display slice stays 0).\n    if (this.scope.stackMode) region.z = this.scope.displaySlice;\n    // The caller's instance becomes the stored one (completed in place).\n    const [stored] = this.withClassificationColors([region], () => true);\n    this.regions = [...this.regions, stored];\n    this.selection.replace([stored.id]);\n    this.syncCache();\n    this.emitSelection();\n    this.emit();\n    return stored.id;\n  }\n\n  removeRegion(id: number): void {\n    this.removeRegions([id]);\n  }\n\n  /**\n   * Remove the regions with these ids, if present. With `{ recordUndo: false }`\n   * no undo step is taken — for clearing transient shapes that were never the\n   * user's work (the 3D view's screen-space lassos on an orbit, NAPARI-SVC-11).\n   */\n  removeRegions(ids: Iterable<number>, opts: { recordUndo?: boolean } = {}): void {\n    const drop = new Set(ids);\n    if (!this.regions.some((r) => drop.has(r.id))) return;\n    if (opts.recordUndo !== false) this.recordUndoSnapshot();\n    this.regions = this.regions.filter((r) => !drop.has(r.id));\n    this.selection.retain((s) => !drop.has(s));\n    this.syncCache();\n    this.emitSelection();\n    this.emit();\n  }\n\n  updateBounds(id: number, bounds: Rectangle | Polygon | MultiPolygon): void {\n    const r = this.findById(id);\n    if (!r) return;\n    this.recordUndoSnapshot();\n    // A copy, so the caller can keep using (and changing) the bounds it passed.\n    this.replaceRegion(replaceBounds(r, cloneBounds(bounds)));\n  }\n\n  moveRegion(id: number, dx: number, dy: number): void {\n    const r = this.findById(id);\n    if (!r || !r.bounds) return;\n    this.recordUndoSnapshot();\n    // Every part (and its holes) moves together (jit-ui#85).\n    this.replaceRegion(replaceBounds(r, edit.translateBounds(r.bounds, dx, dy)));\n  }\n\n  // ── IRegionEditApi: vertex edits (polygons only) ───────────────────────\n  // Each one is a pure copy-on-write edit from models/polygon-edit; a null\n  // result (out of range, would degenerate) records nothing and emits nothing.\n\n  moveVertex(id: number, index: number, x: number, y: number): void {\n    this.editPolygon(id, (p) => edit.moveVertex(p, index, x, y));\n  }\n\n  /** Move a vertex on a polygon's interior ring (hole) — jit-ui#85. */\n  moveHoleVertex(id: number, holeIndex: number, index: number, x: number, y: number): void {\n    this.editPolygon(id, (p) => edit.moveHoleVertex(p, holeIndex, index, x, y));\n  }\n\n  /** Insert a vertex on a polygon's interior ring (hole), after `segIndex`\n   *  (the edge's start vertex). No-op for an out-of-range hole — jit-ui#85. */\n  addHoleVertex(id: number, holeIndex: number, segIndex: number, x: number, y: number): void {\n    this.editPolygon(id, (p) => edit.addHoleVertex(p, holeIndex, segIndex, x, y));\n  }\n\n  /** Delete the vertex at `index` on a polygon's interior ring (hole). Removing\n   *  it below 3 vertices drops the whole hole (a ring with < 3 points bounds no\n   *  area) — jit-ui#85. */\n  deleteHoleVertex(id: number, holeIndex: number, index: number): void {\n    this.editPolygon(id, (p) => edit.deleteHoleVertex(p, holeIndex, index));\n  }\n\n  addVertex(id: number, segIndex: number, x: number, y: number): void {\n    this.editPolygon(id, (p) => edit.addVertex(p, segIndex, x, y));\n  }\n\n  deleteVertex(id: number, index: number): void {\n    this.editPolygon(id, (p) => edit.deleteVertex(p, index));\n  }\n\n  setBezier(id: number, bezier: boolean): void {\n    const r = this.findById(id);\n    if (!r || !r.bounds) return;\n    let next: Polygon | null = null;\n    if (r.bounds instanceof Polygon) {\n      next = edit.setBezier(r.bounds, bezier);\n    } else if (r.bounds instanceof Rectangle && bezier) {\n      // Smoothing a rectangle: convert it to a 4-anchor closed polygon first.\n      const ring = rectToRing(r.bounds);\n      next = edit.setBezier(makePolygon(ring.xs, ring.ys), true);\n    }\n    if (!next) return; // already in that state, or bezier=false on a rectangle\n    this.recordUndoSnapshot();\n    this.replaceRegion(replaceBounds(r, next));\n  }\n\n  /** Drag a bezier control point on a hole ring vertex (donut bezier editing). */\n  moveHoleBezierHandle(\n    id: number,\n    holeIndex: number,\n    index: number,\n    side: 'in' | 'out',\n    x: number,\n    y: number,\n  ): void {\n    this.editPolygon(id, (p) => edit.moveHoleBezierHandle(p, holeIndex, index, side, x, y));\n  }\n\n  moveBezierHandle(id: number, index: number, side: 'in' | 'out', x: number, y: number): void {\n    this.editPolygon(id, (p) => edit.moveBezierHandle(p, index, side, x, y));\n  }\n\n  /** Apply a copy-on-write polygon edit to region `id`: record, swap in, emit. */\n  private editPolygon(id: number, apply: (p: Polygon) => Polygon | null): void {\n    const r = this.findById(id);\n    if (!r || !(r.bounds instanceof Polygon)) return;\n    const next = apply(r.bounds);\n    if (!next) return;\n    this.recordUndoSnapshot();\n    this.replaceRegion(replaceBounds(r, next));\n  }\n\n  /** Swap `next` in for the stored region with its id (a new array), then sync and emit. */\n  private replaceRegion(next: Region): void {\n    this.regions = this.regions.map((r) => (r.id === next.id ? next : r));\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Coalesce `regionUpdate$` until the matching {@link endBatch} (live drags);\n   *  the batch is also one undo gesture ({@link beginGesture}). */\n  beginBatch(): void {\n    this.batchDepth++;\n    this.beginGesture();\n  }\n  endBatch(): void {\n    if (this.batchDepth > 0) this.batchDepth--;\n    this.endGesture();\n    if (this.batchDepth === 0 && this.pendingEmit) {\n      this.pendingEmit = false;\n      this.regionUpdate$.next(this.getRegions());\n    }\n  }\n\n  /**\n   * Mark the start of one user gesture (e.g. a wand/brush mousedown): every\n   * commit until the matching {@link endGesture} becomes a single undo step,\n   * without delaying `regionUpdate$` (tools render through it while dragging).\n   * Calls nest. A gesture never folds into an earlier timed burst.\n   */\n  beginGesture(): void {\n    this.history.beginGesture();\n  }\n\n  /** End the gesture opened by {@link beginGesture}; the next commit starts a new step. */\n  endGesture(): void {\n    this.history.endGesture();\n  }\n\n  // ── Region sources: large region sets, tiled by level of detail ─────────\n\n  /**\n   * Hold a large region set as a tiled region source instead of as regions: the backends that\n   * draw sources (OpenSeadragon, napari) draw its features at the detail the zoom shows, from\n   * the tiles in view, and a feature joins the regions — exactly, as an ordinary editable\n   * {@link Region} with its {@link Region.sourceId} — only when it is selected or edited\n   * ({@link takeSourceFeatures}). Until then {@link getRegions} does not include it.\n   *\n   * `source` may be an opener, called the first time its slice is shown (and again if the\n   * source was closed to save memory). `slices` says which slice of the current image it\n   * serves: one (default: the slice shown; plane 0 of the source), or `'planes'`, every slice z\n   * from plane z of a z-indexed source. Replaces the source those slices had.\n   */\n  attachRegionSource(\n    source: RegionSource | RegionSourceOpener,\n    slices: RegionSourceSlices = { slice: this.sourceSlice },\n  ): void {\n    const image = this.scope.activeImage;\n    if (!image) return;\n    const open: RegionSourceOpener = typeof source === 'function' ? source : () => Promise.resolve(source);\n    this.sources.attach(image, open, slices);\n    this.sourcesVersion++;\n    this.refreshSourceView();\n  }\n\n  /** Drop the current image's region sources (closing them) and what was taken from them. */\n  detachRegionSources(): void {\n    const image = this.scope.activeImage;\n    if (!image) return;\n    this.sources.detachImage(image);\n    this.sourcesVersion++;\n    this.refreshSourceView();\n  }\n\n  /**\n   * Drop the slice's region source, for regions imported in place of the slice's (a small file\n   * replacing a large one): a source of the slice's own is detached; a z-indexed source over every\n   * slice has this slice's features taken out (as deleted). The other slices keep theirs.\n   */\n  async dropSliceRegionSource(): Promise<void> {\n    const image = this.scope.activeImage;\n    const slice = this.sourceSlice;\n    if (!image || !this.sources.has(image, slice)) return;\n    if (this.sources.hasOwnSource(image, slice)) {\n      this.sources.detachSlice(image, slice);\n      this.sourcesVersion++;\n      this.refreshSourceView();\n      return;\n    }\n    const generation = this.sourceGeneration;\n    const binding = await this.sources.binding(image, slice);\n    if (!binding || generation !== this.sourceGeneration) return;\n    const all = await binding.source.getIndex(binding.plane, {\n      offset: 0,\n      limit: binding.source.info.featureCount,\n    });\n    if (generation !== this.sourceGeneration) return;\n    this.setTaken(new Set([...this.currentTaken(), ...all.rows.map((r) => r.id)]));\n  }\n\n  /** Whether the slice shown has a region source. */\n  hasRegionSource(): boolean {\n    return this.sources.has(this.scope.activeImage, this.sourceSlice);\n  }\n\n  /** The slice's region source as a source layer draws it; null without one (or until it opens). */\n  getRegionSourceView(): RegionSourceView | null {\n    return this.sourceView$.value;\n  }\n\n  /** {@link getRegionSourceView} and every change of it (slice, taken ids, class colours). */\n  getRegionSourceView$(): Observable<RegionSourceView | null> {\n    return this.sourceView$.asObservable();\n  }\n\n  /**\n   * Take source features into the working set for editing: their exact geometry becomes\n   * ordinary regions (minted, coloured and slice-tagged as any region entering the store) and\n   * the source stops drawing them. Not an undo step of its own — undoing past it puts the\n   * features back in the source. Resolves the region ids, in the order asked (a feature already\n   * taken resolves to its region); [] when the slice changed meanwhile.\n   */\n  async takeSourceFeatures(ids: readonly string[]): Promise<number[]> {\n    const view = this.sourceView$.value;\n    if (!view || !ids.length) return [];\n    const generation = this.sourceGeneration;\n    const wanted = ids.filter((id) => !view.taken.has(id));\n    const features = wanted.length ? await view.source.getFeatures(wanted) : [];\n    if (generation !== this.sourceGeneration) return [];\n    const taken = this.currentTaken();\n    const fresh = features.filter((f) => !taken.has(f.id));\n    if (fresh.length) {\n      const regions = fresh.map((f) => {\n        const region = regionFromGeoJsonFeature(f.feature as GeoJsonFeature, 0, f.id);\n        if (this.scope.stackMode) region.z = this.scope.displaySlice;\n        return region;\n      });\n      const admitted = this.admit(regions);\n      // Fresh instances, completed in place: named after their new id like a drawn region.\n      for (const r of admitted) r.name = `shape${r.id}`;\n      this.regions = this.regions.concat(admitted);\n      this.setTaken(new Set([...taken, ...fresh.map((f) => f.id)]));\n      this.syncCache();\n      this.emitSelection();\n      this.emit();\n    }\n    const bySource = new Map(this.regions.filter((r) => r.sourceId !== undefined).map((r) => [r.sourceId, r.id]));\n    return ids.map((id) => bySource.get(id)).filter((id): id is number => id !== undefined);\n  }\n\n  /** {@link takeSourceFeatures}, then select them (added to the selection with `additive`). */\n  async selectSourceFeatures(ids: readonly string[], additive = false): Promise<number[]> {\n    const taken = await this.takeSourceFeatures(ids);\n    if (!taken.length) return taken;\n    this.selection.replace(additive ? [...new Set([...this.selection.ids, ...taken])] : taken);\n    this.emitSelection();\n    return taken;\n  }\n\n  /**\n   * Features per class still in the slice's region source (not taken); {} without one. With\n   * `stack`, a z-stack's over every slice: its source's planes, or each slice's source added up.\n   */\n  async getRegionSourceClassCounts(stack = false): Promise<Record<string, number>> {\n    const view = this.sourceView$.value;\n    const image = this.scope.activeImage;\n    if (!stack || !this.scope.stackMode) {\n      return view ? view.source.getClassCounts(view.plane, Array.from(view.taken)) : {};\n    }\n    if (this.sources.hasPlanesSource(image)) {\n      const binding = await this.sources.binding(image, this.sourceSlice);\n      if (!binding) return {};\n      try {\n        return await binding.source.getClassCounts(null, this.sources.allTaken(image));\n      } catch (err) {\n        // A tile server that predates counting every plane: the slice's counts.\n        console.warn('[regions] could not count the classes of every slice', err);\n        return view ? view.source.getClassCounts(view.plane, Array.from(view.taken)) : {};\n      }\n    }\n    const counts: Record<string, number> = {};\n    for (const slice of this.sources.slicesWithSource(image)) {\n      const binding = await this.sources.binding(image, slice);\n      if (!binding) continue;\n      const own = await binding.source.getClassCounts(binding.plane, Array.from(this.sources.taken(image, slice)));\n      for (const [label, n] of Object.entries(own)) counts[label] = (counts[label] ?? 0) + n;\n    }\n    return counts;\n  }\n\n  /**\n   * Select every region of these classes on the slice — the regions', and the region source's,\n   * which are taken into the regions (at most {@link SELECT_CLASSES_LIMIT} of them). Added to the\n   * selection with `additive`. Resolves the selected region ids.\n   */\n  async selectClasses(classes: readonly string[], additive = false): Promise<number[]> {\n    const wanted = new Set(classes);\n    const view = this.sourceView$.value;\n    if (view && classes.length) {\n      const page = await view.source.getIndex(view.plane, {\n        offset: 0,\n        limit: SELECT_CLASSES_LIMIT,\n        classes,\n        exclude: Array.from(view.taken),\n      });\n      if (page.rows.length) await this.takeSourceFeatures(page.rows.map((r) => r.id));\n    }\n    const ids = this.regions.filter((r) => !r.isProfile?.() && r.label && wanted.has(r.label)).map((r) => r.id);\n    this.selection.replace(additive ? [...new Set([...this.selection.ids, ...ids])] : ids);\n    this.emitSelection();\n    return ids;\n  }\n\n  /**\n   * The 3D reconstruction of each group of classes over every slice of the stack (an atlas\n   * structure with its substructures, say): the outlines of the regions of those classes on every\n   * slice — the region sources' and those drawn or taken — stacked and meshed in a worker. Meshes\n   * are in image px (x, y) and slice indices (z). `pixelStep` is the in-plane voxel size (image\n   * px); the outlines are read at the matching level of detail. A group with no outline gets an\n   * empty mesh.\n   */\n  async reconstructClasses(\n    groups: ReadonlyArray<{ key: string; classes: readonly string[] }>,\n    pixelStep = 1,\n  ): Promise<Array<{ key: string; mesh: Mesh }>> {\n    const level = Math.max(0, Math.floor(Math.log2(Math.max(1, pixelStep))));\n    const out: Array<{ key: string; mesh: Mesh }> = [];\n    for (const group of groups) {\n      const slices = await this.classOutlines(group.classes, level);\n      out.push({ key: group.key, mesh: await reconstructInWorker(slices, { pixelStep }) });\n    }\n    return out;\n  }\n\n  /**\n   * Each class's volume over the whole stack, in px² × slices: its outlines' area on every slice\n   * (its features' union, see `outlinesArea`), one slice thick (Cavalieri's estimator), from the\n   * exact outlines. Where a feature is, a region source's or a drawn or taken region, does not\n   * change it: taking one leaves the volume as it was. The region sources' part is cached until\n   * what they hold changes (a feature taken or deleted, another source); only the slices with\n   * drawn or taken regions of the class are measured again.\n   */\n  async classVolumes(classes: readonly string[]): Promise<Map<string, number>> {\n    const state = this.sourceStateKey();\n    const out = new Map<string, number>();\n    await Promise.all(\n      [...new Set(classes)].map(async (name) => {\n        const source = await this.sourceVolume(state, name);\n        let volume = source.total;\n        for (const regions of mergeOutlines(this.regionOutlines([name]))) {\n          const under = source.slices.get(regions.z);\n          const [both] = under ? mergeOutlines([under.outlines, regions]) : [regions];\n          volume += outlinesArea(both.rings, both.ringGroups) - (under?.area ?? 0);\n        }\n        out.set(name, volume);\n      }),\n    );\n    return out;\n  }\n\n  /** The region sources' part of a class's volume, cached by what they hold (see classVolumes). */\n  private sourceVolume(state: string, name: string): Promise<SourceVolume> {\n    const key = `${state}\\n${name}`;\n    let source = this.sourceVolumeCache.get(key);\n    if (source) {\n      // Most recently used last.\n      this.sourceVolumeCache.delete(key);\n      this.sourceVolumeCache.set(key, source);\n      return source;\n    }\n    source = this.sourceOutlines([name], 0).then((parts) => {\n      const slices = new Map<number, { area: number; outlines: SliceOutlines }>();\n      let total = 0;\n      for (const outlines of mergeOutlines(parts)) {\n        const area = outlinesArea(outlines.rings, outlines.ringGroups);\n        slices.set(outlines.z, { area, outlines });\n        total += area;\n      }\n      return { total, slices };\n    });\n    this.sourceVolumeCache.set(key, source);\n    source.catch(() => this.sourceVolumeCache.delete(key));\n    while (this.sourceVolumeCache.size > SOURCE_VOLUME_CACHE_SIZE) {\n      this.sourceVolumeCache.delete(this.sourceVolumeCache.keys().next().value as string);\n    }\n    return source;\n  }\n\n  /**\n   * Every slice's outlines of these classes, the region sources' then the regions': closed shapes'\n   * rings, and open polylines as `lines`.\n   */\n  private async classOutlines(classes: readonly string[], level: number): Promise<SliceOutlines[]> {\n    return mergeOutlines([...(await this.sourceOutlines(classes, level)), ...this.regionOutlines(classes)]);\n  }\n\n  /**\n   * The region sources' outlines of these classes on every slice, without the features taken or\n   * deleted. The last few class sets are kept until what the sources hold changes: rebuilding a\n   * surface after an edit reads nothing again.\n   */\n  private sourceOutlines(classes: readonly string[] | null, level: number): Promise<LabelledOutlines[]> {\n    const key = `${this.sourceStateKey()}\\n${level}\\n${classes ? classes.join('\\n') : '*'}`;\n    const cached = this.sourceOutlineCache.get(key);\n    if (cached) {\n      // Most recently used last.\n      this.sourceOutlineCache.delete(key);\n      this.sourceOutlineCache.set(key, cached);\n      return cached;\n    }\n    const read = this.readSourceOutlines(classes, level);\n    this.sourceOutlineCache.set(key, read);\n    read.catch(() => this.sourceOutlineCache.delete(key));\n    while (this.sourceOutlineCache.size > SOURCE_OUTLINE_CACHE_SIZE) {\n      this.sourceOutlineCache.delete(this.sourceOutlineCache.keys().next().value as string);\n    }\n    return read;\n  }\n\n  private async readSourceOutlines(classes: readonly string[] | null, level: number): Promise<LabelledOutlines[]> {\n    const out: LabelledOutlines[] = [];\n    const image = this.scope.activeImage;\n    if (this.sources.hasPlanesSource(image)) {\n      const binding = await this.sources.binding(image, this.sourceSlice);\n      const outlines = await binding?.source.getClassOutlines(classes, level, this.sources.allTaken(image));\n      out.push(...(outlines ?? []));\n    }\n    for (const z of this.sources.slicesWithSource(image)) {\n      const binding = await this.sources.binding(image, z);\n      if (!binding) continue;\n      const outlines = await binding.source.getClassOutlines(\n        classes,\n        level,\n        Array.from(this.sources.taken(image, z)),\n      );\n      for (const s of outlines) if (s.z === binding.plane) out.push({ ...s, z });\n    }\n    return out;\n  }\n\n  /**\n   * Every class's outlines on every slice, by class: the region sources' (one read for all, kept\n   * like {@link sourceOutlines}) and the drawn and taken regions'. What a section through the\n   * stack cuts (see `geometry/section`).\n   */\n  async outlinesByClass(level: number): Promise<Map<string, SliceOutlines[]>> {\n    const byClass = new Map<string, Map<number, SliceParts>>();\n    const slot = (label: string, z: number) => {\n      let slices = byClass.get(label);\n      if (!slices) byClass.set(label, (slices = new Map()));\n      let slice = slices.get(z);\n      if (!slice) slices.set(z, (slice = { rings: [], ringGroups: [], lines: [] }));\n      return slice;\n    };\n    const nextPart = featureIds();\n    for (const s of await this.sourceOutlines(null, level)) {\n      const id = nextPart();\n      s.rings.forEach((r, i) => {\n        const label = s.ringLabels?.[i];\n        if (!label) return;\n        const slice = slot(label, s.z);\n        slice.rings.push(r);\n        slice.ringGroups.push(id(s.ringGroups?.[i]));\n      });\n      (s.lines ?? []).forEach((l, i) => {\n        const label = s.lineLabels?.[i];\n        if (label) slot(label, s.z).lines.push(l);\n      });\n    }\n    for (const { label, outlines } of this.labelledRegionOutlines(null)) {\n      // A region is one feature.\n      const id = nextPart()(undefined);\n      const slice = slot(label, outlines.z);\n      slice.rings.push(...outlines.rings);\n      slice.ringGroups.push(...outlines.rings.map(() => id));\n      slice.lines.push(...(outlines.lines ?? []));\n    }\n    return new Map(\n      Array.from(byClass, ([label, slices]) => [label, Array.from(slices, ([z, s]) => sliceOutlines(z, s))]),\n    );\n  }\n\n  /** The drawn and taken regions' outlines of these classes, by slice. */\n  private regionOutlines(classes: readonly string[]): SliceOutlines[] {\n    return this.labelledRegionOutlines(new Set(classes)).map((o) => o.outlines);\n  }\n\n  /** Each drawn or taken region's outlines (of the `wanted` classes; null: every class) with its class. */\n  private labelledRegionOutlines(\n    wanted: ReadonlySet<string> | null,\n  ): Array<{ label: string; outlines: SliceOutlines }> {\n    const out: Array<{ label: string; outlines: SliceOutlines }> = [];\n    for (const r of this.scope.stackMode ? this.getSliceRegions() : this.regions) {\n      if (r.isProfile?.() || !r.label || (wanted && !wanted.has(r.label))) continue;\n      const rings: Float64Array[] = [];\n      for (const p of regionPolygons(r)) {\n        rings.push(Float64Array.from(p.xpoints.flatMap((x, i) => [x, p.ypoints[i]])));\n        for (const hole of p.holes ?? []) rings.push(Float64Array.from(hole.flat()));\n      }\n      const lines = regionPolylines(r);\n      out.push({ label: r.label, outlines: { z: r.z ?? 0, rings, ...(lines.length ? { lines } : {}) } });\n    }\n    return out;\n  }\n\n  /** What the region sources of the image hold (see {@link sourceStateKey}): it changes when a\n   *  feature is taken or deleted, or that is undone. */\n  getSourceStateKey(): string {\n    return this.sourceStateKey();\n  }\n\n  /**\n   * What the region sources of the image hold: the image, its sources (one attached or dropped\n   * bumps the version) and the features taken from them. A key for what is read from them.\n   */\n  private sourceStateKey(): string {\n    const image = this.scope.activeImage;\n    let taken = 2166136261;\n    for (const z of this.sources.slicesWithTaken(image)) {\n      for (const id of [...this.sources.taken(image, z)].sort()) {\n        const s = `${z}:${id};`;\n        for (let i = 0; i < s.length; i++) taken = Math.imul(taken ^ s.charCodeAt(i), 16777619) >>> 0;\n      }\n    }\n    return `${image}\\n${this.sourcesVersion}\\n${taken}`;\n  }\n\n  /** Delete source features without taking them (one undo step). */\n  deleteSourceFeatures(ids: readonly string[]): void {\n    const taken = this.currentTaken();\n    const drop = ids.filter((id) => !taken.has(id));\n    if (!drop.length || !this.sourceView$.value) return;\n    this.recordUndoSnapshot();\n    this.setTaken(new Set([...taken, ...drop]));\n    this.emit();\n  }\n\n  /**\n   * A page of the slice source's features not taken from it (file order), e.g. for the Region\n   * Editor's list; an empty page without a source.\n   */\n  async getRegionSourceIndex(query: Omit<RegionIndexQuery, 'exclude'>): Promise<RegionIndexPage> {\n    const view = this.sourceView$.value;\n    if (!view) return { total: 0, rows: [] };\n    return view.source.getIndex(view.plane, { ...query, exclude: Array.from(view.taken) });\n  }\n\n  /**\n   * `regions` as a GeoJSON FeatureCollection string merged with the region source behind them:\n   * the source's features that were not taken (or deleted), then `regions`. Without a source,\n   * {@link getGeoJsonString}. `slice` names a folder stack's slice (default the one shown);\n   * on a z-indexed stack's source (`'planes'`) the export spans every slice.\n   */\n  async getGeoJsonWithSource(regions: Region[], slice = this.sourceSlice): Promise<string> {\n    const image = this.scope.activeImage;\n    const planes = this.scope.stackMode && this.sources.hasPlanesSource(image);\n    const binding = await this.sources.binding(image, slice);\n    if (!binding) return regionsToGeoJson(regions);\n    const features = regions\n      .filter((r) => !r.isProfile?.())\n      .map((r) => featureFromRegion(r))\n      .filter((f): f is object => !!f);\n    const exclude = planes ? this.sources.allTaken(image) : Array.from(this.sources.taken(image, slice));\n    return binding.source.exportGeoJson(exclude, features);\n  }\n\n  // ── Region look ────────────────────────────────────────────────────────\n\n  /**\n   * Whether a region of class `label` goes unlabelled because a subclass of it (by the region\n   * source's class hierarchy) is among the regions too — an atlas's \"Isocortex\" under its areas.\n   * False without a hierarchy.\n   */\n  isLabelCovered(label: string | undefined): boolean {\n    if (!label) return false;\n    const hierarchy = this.sourceView$.value?.source.info.hierarchy;\n    if (!hierarchy) return false;\n    if (this.coveredFor?.regions !== this.regions || this.coveredFor.hierarchy !== hierarchy) {\n      const parent = new Map(hierarchy.filter((n) => n.parent).map((n) => [n.name, n.parent as string]));\n      const covered = new Set<string>();\n      for (const r of this.regions) {\n        let p = r.label ? parent.get(r.label) : undefined;\n        while (p && !covered.has(p)) {\n          covered.add(p);\n          p = parent.get(p);\n        }\n      }\n      this.coveredFor = { regions: this.regions, hierarchy, covered };\n    }\n    return this.coveredFor.covered.has(label);\n  }\n  private coveredFor: { regions: Region[]; hierarchy: readonly object[]; covered: Set<string> } | null = null;\n\n  /** The classes hidden from view (see {@link setClassesHidden}). */\n  getHiddenClasses(): ReadonlySet<string> {\n    return this.hiddenClasses$.value;\n  }\n\n  /** {@link getHiddenClasses} and every change of it. */\n  getHiddenClasses$(): Observable<ReadonlySet<string>> {\n    return this.hiddenClasses$.asObservable();\n  }\n\n  /**\n   * Hide (or show again) these classes' regions: the overlays and the region source's layer stop\n   * drawing them, and a hidden region can be neither picked nor kept selected. The regions stay in\n   * the set (the table lists them; a save keeps them).\n   */\n  setClassesHidden(classes: readonly string[], hidden: boolean): void {\n    const cur = this.hiddenClasses$.value;\n    const next = new Set(cur);\n    for (const c of classes) {\n      if (hidden) next.add(c);\n      else next.delete(c);\n    }\n    if (next.size === cur.size && [...next].every((c) => cur.has(c))) return;\n    const set = this.store.getPresetSet();\n    this.hiddenKeys = new Set([...next].map((c) => presetKey(set, c)));\n    this.hiddenClasses$.next(next);\n    if (hidden) {\n      const shown = this.selection.indices.filter((i) => !this.isClassHidden(this.regions[i]?.label));\n      if (shown.length !== this.selection.indices.length) this.setSelectedShapeIndices(shown);\n    }\n    this.republishView();\n    this.regionUpdate$.next(this.getRegions());\n  }\n\n  /** Whether regions labelled `label` are hidden (an unlabelled region never is). */\n  isClassHidden(label: string | null | undefined): boolean {\n    return !!label && this.hiddenKeys.size > 0 && this.hiddenKeys.has(presetKey(this.store.getPresetSet(), label));\n  }\n\n  /** The region look: outlines, or filled (an atlas's look); see `region-style`. */\n  getRegionStyle(): RegionStyle {\n    return this.regionStyle$.value;\n  }\n\n  /** {@link getRegionStyle} and every change of it. */\n  getRegionStyle$(): Observable<RegionStyle> {\n    return this.regionStyle$.asObservable();\n  }\n\n  /**\n   * Choose the region look, field by field; it overrides a region source's hint for the session.\n   * The overlays redraw.\n   */\n  setRegionStyle(patch: Partial<RegionStyle>): void {\n    this.userStyle = { ...this.userStyle, ...patch };\n    this.restyle();\n  }\n\n  /** The look now: the user's choice, else the source's hint, else outlines. */\n  private effectiveStyle(): RegionStyle {\n    const hint = this.hintStyle ?? {};\n    return {\n      fillOpacity: this.userStyle.fillOpacity ?? hint.fillOpacity ?? DEFAULT_REGION_STYLE.fillOpacity,\n      stroke: this.userStyle.stroke !== undefined ? this.userStyle.stroke : (hint.stroke ?? null),\n      strokeWidth:\n        this.userStyle.strokeWidth !== undefined ? this.userStyle.strokeWidth : (hint.strokeWidth ?? null),\n      highlight: this.userStyle.highlight !== undefined ? this.userStyle.highlight : (hint.highlight ?? null),\n    };\n  }\n\n  /** Publish the look when it changed: the overlays redraw the regions, the source layer its features. */\n  private restyle(redraw = false): void {\n    const next = this.effectiveStyle();\n    const cur = this.regionStyle$.value;\n    const same = (Object.keys(next) as Array<keyof RegionStyle>).every((k) => next[k] === cur[k]);\n    if (!same) this.regionStyle$.next(next);\n    const view = this.sourceView$.value;\n    if (redraw || !same || (view && view.labels !== this.showShapeLabel)) {\n      this.republishView();\n      this.regionUpdate$.next(this.getRegions());\n    }\n  }\n\n  /** Re-emit the source view with the current look and label setting. */\n  private republishView(): void {\n    const view = this.sourceView$.value;\n    if (view) this.sourceView$.next({ ...view, style: this.regionStyle$.value, labels: this.showShapeLabel });\n  }\n\n  /** The slice a region source is keyed by: the display slice in stack mode, else 0. */\n  private get sourceSlice(): number {\n    return this.scope.stackMode ? this.scope.displaySlice : 0;\n  }\n\n  private currentTaken(): ReadonlySet<string> {\n    return this.sources.taken(this.scope.activeImage, this.sourceSlice);\n  }\n\n  /** Replace the slice's taken ids and tell the source layers. */\n  private setTaken(taken: ReadonlySet<string>): void {\n    if (taken === this.currentTaken()) return;\n    this.sources.setTaken(this.scope.activeImage, this.sourceSlice, taken);\n    const view = this.sourceView$.value;\n    if (view) this.sourceView$.next({ ...view, taken });\n  }\n\n  /**\n   * Look up (opening it if needed) the slice's source and publish it as the source view. The view\n   * is withdrawn at once: until the incoming source opens, nothing reads, takes or deletes from the\n   * outgoing one into the slice now shown.\n   */\n  private refreshSourceView(): void {\n    const generation = ++this.sourceGeneration;\n    const image = this.scope.activeImage;\n    const slice = this.sourceSlice;\n    if (this.sourceView$.value) this.sourceView$.next(null);\n    this.sources.show(image, slice);\n    if (!this.sources.has(image, slice)) {\n      this.hintStyle = undefined;\n      this.restyle();\n      return;\n    }\n    this.sources.binding(image, slice).then(\n      (binding) => {\n        if (generation !== this.sourceGeneration) return;\n        if (!binding) {\n          this.sourceView$.next(null);\n          return;\n        }\n        const info = binding.source.info;\n        const classColors = Object.entries(info.classColors);\n        if (classColors.length) this.store.rememberImportedClassColors(new Map(classColors));\n        // A source that asks for labels gets them when it opens (the toggle still turns them off).\n        const labelsOn = !!info.style?.labels && !this.showShapeLabel && this.shownSource !== binding.source;\n        if (labelsOn) this.showShapeLabel = true;\n        this.shownSource = binding.source;\n        this.hintStyle = info.style;\n        this.sourceView$.next({\n          source: binding.source,\n          plane: binding.plane,\n          taken: this.sources.taken(image, slice),\n          colorOf: (f) =>\n            f.label ? colorForLabel(f.label, this.store.getPresetSet()) : f.color || this.shapeColor,\n          style: this.regionStyle$.value,\n          labels: this.showShapeLabel,\n          isHidden: (label) => this.isClassHidden(label),\n        });\n        this.restyle(labelsOn);\n      },\n      (err) => {\n        if (generation !== this.sourceGeneration) return;\n        console.warn('[regions] could not open the region source', err);\n        this.sourceView$.next(null);\n      },\n    );\n  }\n\n  // ── per-image lifecycle ────────────────────────────────────────────────\n\n  /**\n   * Switch the active image: snapshot the outgoing regions, restore the\n   * incoming image's (or [] if none), clear selection, and notify. Idempotent\n   * for the same image (so repeated replots of one image keep its regions).\n   */\n  setActiveImage(imageInfo: IImageInfo): void {\n    // Switching images also ends any per-slice stack session (jit-ui#93).\n    const incoming = this.scope.switchImage(RegionScopeCache.imageKey(imageInfo), this.regions);\n    if (!incoming) return;\n    this.regions = incoming;\n    this.selection.replace([]);\n    // Undo never crosses an image switch.\n    this.resetUndoHistory();\n    this.emitSelection();\n    this.regionUpdate$.next(this.getRegions());\n    this.refreshSourceView();\n  }\n\n  // ── internals ──────────────────────────────────────────────────────────\n\n  /** Apply the preset set's class colours (see {@link applyPresetColors}),\n   *  promoting unknown classes into the shared store when the set asks for it. */\n  private withClassificationColors(regions: Region[], inPlace: (r: Region) => boolean): Region[] {\n    return applyPresetColors(regions, this.store.getPresetSet(), {\n      inPlace,\n      onPromote: (preset) => this.store.upsertClass(preset),\n    });\n  }\n\n  private syncCache(): void {\n    this.scope.sync(this.regions);\n  }\n\n  private emit(): void {\n    // Live-edit listeners (e.g. the intensity-profile inset) react on EVERY\n    // change — including per-frame during a batched drag — so they track the\n    // region live. The main regionUpdate$ stays coalesced during a batch (fires\n    // once on endBatch) to keep heavier consumers (Regions tab) calm.\n    this.regionLiveEdit$.next(this.regions.slice());\n    if (this.batchDepth > 0) {\n      this.pendingEmit = true;\n      return;\n    }\n    this.regionUpdate$.next(this.getRegions());\n  }\n\n  /** Project the selected ids onto the current regions (pruning gone ones);\n   *  emits only if the index set changed. */\n  private emitSelection(): void {\n    this.selection.sync(this.regions);\n  }\n\n  private findById(id: number): Region | undefined {\n    return this.regions.find((r) => r.id === id);\n  }\n\n  private indexOfId(id: number): number {\n    return this.regions.findIndex((r) => r.id === id);\n  }\n}\n"]}