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

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

@@ -1,17 +1,74 @@
 import { Injectable } from '@angular/core';
-import { Subject } from 'rxjs';
+import { BehaviorSubject, Subject } from 'rxjs';
 import { Rectangle, Polygon, hydrateBounds } from '../models/region';
-import { downloadGeoJson, regionsFromGeoJson, regionsToGeoJson } from '../models/region-geojson';
+import { downloadGeoJson, featureFromRegion, regionFromGeoJsonFeature, regionsFromGeoJson, regionsToGeoJson, } from '../models/region-geojson';
 import { VisualizerStore } from './visualizer-store.service';
-import { applyPresetColors } from './class-color.util';
-import { cloneBounds, makePolygon, rectToRing, regionPolygons, replaceBounds } from '../models/polygon-factory';
+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.
  *
@@ -85,6 +142,40 @@ export class RegionStore {
         /** Emit coalescing for live drags (see IRegionEditApi.beginBatch). */
         this.batchDepth = 0;
         this.pendingEmit = false;
+        /**
+         * 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 ─────────────────────────────────────────────────
     /**
@@ -104,7 +195,10 @@ export class RegionStore {
         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
@@ -169,10 +263,12 @@ export class RegionStore {
         this.resetUndoHistory();
         this.emitSelection();
         this.emit();
+        this.refreshSourceView();
     }
     /** Leave stack mode (single-plane image, or the stack was closed). */
     exitStackMode() {
         this.scope.exitStack();
+        this.refreshSourceView();
     }
     /** The live-set swap of {@link setDisplaySlice}. */
     showSlice(z) {
@@ -185,6 +281,7 @@ export class RegionStore {
         this.resetUndoHistory();
         this.emitSelection();
         this.emit();
+        this.refreshSourceView();
     }
     /**
      * Show a different slice: capture the current slice's (possibly edited)
@@ -216,7 +313,14 @@ export class RegionStore {
      * the current live slice is captured first. Empty outside stack mode.
      */
     getStackSaveSlices() {
-        return this.scope.stackSaveSlices(this.regions);
+        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. */
@@ -328,6 +432,7 @@ export class RegionStore {
      *  @deprecated Nothing in the library calls it; will be removed next minor. */
     setShowShapeLabel(show) {
         this.showShapeLabel = show;
+        this.republishView();
     }
     getClassificationColors() {
         return this.store.getClassificationColors();
@@ -364,7 +469,7 @@ export class RegionStore {
      * nothing is left to undo.
      */
     undo() {
-        const snapshot = this.history.undo(this.regions);
+        const snapshot = this.history.undo(this.snapshot());
         if (snapshot)
             this.restoreSnapshot(snapshot);
         this.regionSetReplaced$.next();
@@ -376,7 +481,7 @@ export class RegionStore {
      * fresh region action).
      */
     redo() {
-        const snapshot = this.history.redo(this.regions);
+        const snapshot = this.history.redo(this.snapshot());
         if (snapshot)
             this.restoreSnapshot(snapshot);
         this.regionSetReplaced$.next();
@@ -390,7 +495,8 @@ export class RegionStore {
      *  {@link undo} and {@link redo}; nothing records history while it runs. */
     restoreSnapshot(snapshot) {
         this.history.restore(() => {
-            this.regions = snapshot.slice();
+            this.regions = snapshot.regions.slice();
+            this.setTaken(snapshot.taken);
             this.syncCache();
             // Drops any selected ids the restored set no longer contains.
             this.emitSelection();
@@ -407,11 +513,25 @@ export class RegionStore {
      * region it edits) rather than changing them, so it never changes after this.
      */
     recordUndoSnapshot() {
-        this.history.record(this.regions);
+        this.history.record(this.snapshot());
+    }
+    /** The state an undo step restores. */
+    snapshot() {
+        return { regions: this.regions, taken: this.currentTaken() };
     }
     // ── 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 regionsFromGeoJson(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;
     }
     /** Download `regions` as GeoJSON, named after `fileName` (extension
      *  replaced by `.geojson`) or `rois.geojson` without one. */
@@ -576,6 +696,597 @@ export class RegionStore {
     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;
+        }
+        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)]));
+    }
+    /** Whether the slice shown has a region source. */
+    hasRegionSource() {
+        return this.sources.has(this.scope.activeImage, this.sourceSlice);
+    }
+    /** 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();
+        }
+        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;
+    }
+    /**
+     * 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.
+     */
+    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));
+            }
+            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;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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 }) });
+        }
+        return out;
+    }
+    /**
+     * 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;
+        }
+        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;
+    }
+    /**
+     * 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)]);
+    }
+    /**
+     * 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;
+    }
+    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 ?? []));
+        }
+        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 out;
+    }
+    /**
+     * 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);
+            });
+        }
+        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()));
+            }
+            const lines = regionPolylines(r);
+            out.push({ label: r.label, outlines: { z: r.z ?? 0, rings, ...(lines.length ? { lines } : {}) } });
+        }
+        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 `${image}\n${this.sourcesVersion}\n${taken}`;
+    }
+    /** 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;
+        const hierarchy = this.sourceView$.value?.source.info.hierarchy;
+        if (!hierarchy)
+            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.coveredFor.covered.has(label);
+    }
+    /** 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
@@ -593,6 +1304,7 @@ export class RegionStore {
         this.resetUndoHistory();
         this.emitSelection();
         this.regionUpdate$.next(this.getRegions());
+        this.refreshSourceView();
     }
     // ── internals ──────────────────────────────────────────────────────────
     /** Apply the preset set's class colours (see {@link applyPresetColors}),
@@ -636,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 { Observable, Subject } from 'rxjs';\n\nimport { IImageInfo } from '../contracts/image.contract';\nimport { Region, Rectangle, Polygon, MultiPolygon, hydrateBounds } from '../models/region';\nimport { downloadGeoJson, regionsFromGeoJson, regionsToGeoJson } from '../models/region-geojson';\nimport { VisualizerStore } from './visualizer-store.service';\nimport { IRegionStore } from '../contracts/visualizer.contract';\nimport { IRegionEditApi } from '../contracts/region-store.contract';\nimport { applyPresetColors } from './class-color.util';\nimport { cloneBounds, makePolygon, rectToRing, regionPolygons, replaceBounds } from '../models/polygon-factory';\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';\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 {\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<Region[]>(RegionStore.UNDO_LIMIT, RegionStore.UNDO_COALESCE_MS);\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  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(\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      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(\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  }\n\n  /** Leave stack mode (single-plane image, or the stack was closed). */\n  exitStackMode(): void {\n    this.scope.exitStack();\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  }\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    return this.scope.stackSaveSlices(this.regions);\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  }\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.regions);\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.regions);\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: Region[]): void {\n    this.history.restore(() => {\n      this.regions = snapshot.slice();\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.regions);\n  }\n\n  // ── IRegionStore: GeoJSON I/O (models/region-geojson) ──────────────────\n\n  importRegions(geoJsonStr: string): Region[] {\n    return regionsFromGeoJson(geoJsonStr);\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  // ── 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  }\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"]}
+//# 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"]}