@jax-data-science/sci-image-visualizer 0.1.0

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

@@ -0,0 +1,1029 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { Region, Rectangle, Polygon, MultiPolygon } from '../models/region';
+import { PlotUtilities } from '../plot.utilities';
+import { VisualizerStore } from './visualizer-store.service';
+import { defaultHandleOffsets } from '../models/bezier';
+import { findPreset, fallbackColorFor } from './class-color.util';
+import * as i0 from "@angular/core";
+import * as i1 from "./visualizer-store.service";
+/**
+ * Backend-neutral region store — the single source of truth for region state.
+ *
+ * Holds the neutral {@link Region} model (never a backend's own shape
+ * representation), keyed per image so regions persist as the user switches
+ * files and survive a Plotly⇄OpenSeadragon backend switch (both backends read
+ * and write *this* store, so no migration is needed). Backends own *rendering*
+ * and react to {@link getRegionUpdateEvent}; this service owns *state* and the
+ * editing operations.
+ *
+ * Implements:
+ *  - {@link IRegionStore} — the cross-backend CRUD/selection/colour contract
+ *    every consumer (Region Editor, segmentation, etc.) already uses.
+ *  - {@link IRegionEditApi} — Region-native geometry edits (move/resize, and
+ *    add/delete/move vertex) the OSD overlay drives.
+ *
+ * Classification colours live in {@link VisualizerStore} (shared by both
+ * backends); GeoJSON import/export and the closed-polygon projection reuse the
+ * neutral {@link PlotUtilities} helpers. All coordinates are image pixels.
+ */
+export class RegionStore {
+    static { this.UNDO_LIMIT = 10; }
+    static { this.UNDO_COALESCE_MS = 250; }
+    constructor(store) {
+        this.store = store;
+        /** Per-image region cache. `regions` is always a snapshot of the entry for
+         *  `currentImageKey`. */
+        this.regionsByImageKey = new Map();
+        /** The current image's regions — the live, edited array. */
+        this.regions = [];
+        /** Last saved snapshot, restorable via plotPreviousShapes(). */
+        this.previousRegions = [];
+        /**
+         * Undo/redo history (jit-ui#85): up to {@link UNDO_LIMIT} snapshots of the
+         * region set, each a deep clone captured immediately *before* a
+         * region-editing action. {@link undo} pops the newest off `undoStack`, pushes
+         * the current state onto `redoStack`, and restores it — so it can be invoked
+         * up to {@link UNDO_LIMIT} times in a row. {@link redo} is the mirror. Any new
+         * region action clears `redoStack` (the redo future is no longer reachable).
+         *
+         * A continuous gesture (a wand/brush/vertex drag commits to the store many
+         * times) is coalesced into a single entry: the first commit of a burst
+         * captures the pre-burst state and every commit within
+         * {@link UNDO_COALESCE_MS} of the previous one is folded into it. History
+         * never crosses an image load/switch — {@link resetUndoHistory} clears it.
+         */
+        this.undoStack = [];
+        this.redoStack = [];
+        /** True while a coalescing burst is open (further commits fold into it). */
+        this.undoBurstOpen = false;
+        this.undoBurstTimer = null;
+        /** True while restoring a snapshot, so the restore records no new history. */
+        this.restoringUndo = false;
+        this.canUndo$ = new BehaviorSubject(false);
+        this.canRedo$ = new BehaviorSubject(false);
+        /** Monotonic id source — ids never repeat within the service lifetime, so
+         *  selection stays correct across delete/add cycles even when names collide. */
+        this.nextId = 1;
+        this.showShapeLabel = false;
+        this.shapeColor = '#00FFFF';
+        this.fillColor = '#ff00ff';
+        this.isRegionSavedOn = true;
+        /**
+         * Per-slice region support for z-stacks (jit-ui#93). While {@link stackMode}
+         * is on (a z-stack is loaded), the live `regions` array always holds ONE
+         * slice — the {@link currentSliceZ} slice — so the on-canvas overlays, the
+         * selection projection, and the Regions table keep working unchanged
+         * (they all read {@link getRegions}). The other slices live in
+         * {@link regionsBySlice}; {@link setDisplaySlice} swaps the live set on scrub
+         * and {@link getSliceRegions} flattens every slice (each tagged with its
+         * zero-based {@link Region.z}) for save/export. Off by default (stackMode
+         * false, z 0), so single-plane images are completely unaffected.
+         */
+        this.regionsBySlice = new Map();
+        this.stackMode = false;
+        this.currentSliceZ = 0;
+        /** How a stack's regions round-trip to disk (jit-ui#93): `combined` writes one
+         *  z-indexed geojson (single-file z-stack, QuPath schema); `per-slice-file`
+         *  writes one geojson per slice-file (a folder of numbered images). */
+        this.stackSaveLayout = 'combined';
+        /** Slices that were loaded with regions (jit-ui#93). A per-slice-file save
+         *  re-writes these even when now empty, so clearing a slice's regions and
+         *  saving removes its previously-saved geojson (writes an empty one). */
+        this.stackInitialNonEmpty = new Set();
+        /** Selection is tracked by region *id* internally (stable across edits) and
+         *  projected to array indices on the IRegionStore boundary. */
+        this.selectedIds = [];
+        this.selectedIndices$ = new BehaviorSubject([]);
+        this.regionUpdate$ = new Subject();
+        /** Non-coalesced sibling of regionUpdate$: fires on every change even during a
+         *  batched drag, so live consumers (intensity inset) update per frame. */
+        this.regionLiveEdit$ = new Subject();
+        /** Emit coalescing for live drags (see IRegionEditApi.beginBatch). */
+        this.batchDepth = 0;
+        this.pendingEmit = false;
+        this.plotUtilities = new PlotUtilities();
+    }
+    // ── IRegionStore: CRUD ─────────────────────────────────────────────────
+    /**
+     * Replace (or, with `append`, add to) the current image's regions. Mints ids
+     * and default names, applies stored classification colours, and emits. When
+     * `isRegionSaveOn` is false the regions are shown transiently (emitted) but
+     * not stored — mirrors the previous Plotly behaviour.
+     */
+    setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append = false) {
+        if (showRegionLabel === undefined)
+            showRegionLabel = this.showShapeLabel;
+        if (isRegionSaveOn === undefined)
+            isRegionSaveOn = this.isRegionSavedOn;
+        if (fillColor === undefined)
+            fillColor = this.fillColor;
+        for (const region of regions) {
+            if (region.id == null)
+                region.id = this.nextId++;
+            if (region.name == null)
+                region.name = `shape${region.id}`;
+        }
+        this.applyClassificationColors(regions);
+        this.isRegionSavedOn = isRegionSaveOn;
+        if (isRegionSaveOn) {
+            this.recordUndoSnapshot();
+            this.showShapeLabel = showRegionLabel;
+            this.fillColor = fillColor;
+            if (append) {
+                // Reject by id collision (already tracked) or geometry equality (same
+                // coordinates) — the find button can push the same region repeatedly.
+                const added = regions.filter(r => !this.regions.some(existing => existing.id === r.id || this.regionsEqual(existing, r)));
+                this.regions = this.regions.concat(added);
+            }
+            else {
+                this.regions = regions.slice();
+            }
+            this.syncCache();
+            this.emitSelection();
+            this.emit();
+        }
+        else {
+            // Transient display only — don't touch stored state.
+            this.regionUpdate$.next(regions.slice());
+        }
+    }
+    /** The canonical accessor: current image's regions (live instances). */
+    getRegions() {
+        return this.regions.slice();
+    }
+    // ── Per-slice regions for z-stacks (jit-ui#93) ─────────────────────────
+    /** True while a z-stack is loaded and the store holds regions per slice. */
+    isStackMode() { return this.stackMode; }
+    /** The current display slice (zero-based). */
+    getDisplaySlice() { return this.currentSliceZ; }
+    /** How the current stack persists to disk (jit-ui#93): `combined` = one
+     *  z-indexed geojson (single-file z-stack); `per-slice-file` = one geojson per
+     *  slice-file (folder stack). Meaningless outside stack mode. */
+    getStackSaveLayout() { return this.stackSaveLayout; }
+    /**
+     * Enter per-slice stack mode. `slices` maps each zero-based slice index to
+     * the regions imported for that slice; the store makes `initialZ`'s slice the
+     * live set, so the overlays / selection / Regions table are unchanged (they
+     * still read {@link getRegions}). Freshly-created regions are tagged with the
+     * current slice so they persist on it, and {@link getSliceRegions} returns
+     * every slice for save/export. Ids/names/classification colours are minted
+     * exactly as {@link setRegions} does.
+     */
+    enterStackMode(slices, initialZ = 0, saveLayout = 'combined') {
+        this.stackMode = true;
+        this.stackSaveLayout = saveLayout;
+        this.currentSliceZ = initialZ || 0;
+        this.regionsBySlice = new Map();
+        this.stackInitialNonEmpty = new Set();
+        for (const [z, regs] of slices) {
+            const normalized = this.normalizeSlice(regs || [], z);
+            this.regionsBySlice.set(z, normalized);
+            if (normalized.length)
+                this.stackInitialNonEmpty.add(z);
+        }
+        this.regions = (this.regionsBySlice.get(this.currentSliceZ) ?? []).slice();
+        this.previousRegions = this.regions.slice();
+        this.selectedIds = [];
+        this.syncCache();
+        this.resetUndoHistory();
+        this.emitSelection();
+        this.emit();
+    }
+    /** Leave stack mode (single-plane image, or the stack was closed). */
+    exitStackMode() {
+        if (!this.stackMode)
+            return;
+        this.stackMode = false;
+        this.currentSliceZ = 0;
+        this.regionsBySlice = new Map();
+        this.stackInitialNonEmpty = new Set();
+    }
+    /**
+     * Show a different slice: capture the current slice's (possibly edited)
+     * regions back into the per-slice store, then load the target slice's regions
+     * as the live set and emit. Undo never crosses a slice. Outside stack mode
+     * this only records the requested slice index (a no-op otherwise: single-plane
+     * regions stay on the default plane — addRegion tags Region.z only in stack
+     * mode, so the recorded index is unused until a stack is entered). (jit-ui#93)
+     */
+    setDisplaySlice(z) {
+        const next = z || 0;
+        if (!this.stackMode) {
+            this.currentSliceZ = next;
+            return;
+        }
+        if (this.currentSliceZ === next)
+            return;
+        this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());
+        this.currentSliceZ = next;
+        this.regions = (this.regionsBySlice.get(next) ?? []).slice();
+        this.previousRegions = this.regions.slice();
+        this.selectedIds = [];
+        this.syncCache();
+        this.resetUndoHistory();
+        this.emitSelection();
+        this.emit();
+    }
+    /**
+     * Every slice's regions for save/export, each tagged with its zero-based
+     * slice index in {@link Region.z}. Captures the current slice's live edits
+     * first. Returns the flat single-plane set when not in stack mode. (jit-ui#93)
+     */
+    getSliceRegions() {
+        if (!this.stackMode)
+            return this.regions.slice();
+        this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());
+        const out = [];
+        const zs = Array.from(this.regionsBySlice.keys()).sort((a, b) => a - b);
+        for (const z of zs) {
+            for (const r of this.regionsBySlice.get(z)) {
+                r.z = z;
+                out.push(r);
+            }
+        }
+        return out;
+    }
+    /**
+     * Slices to write on a per-slice-file save (folder stack, jit-ui#93): every
+     * slice that currently has regions, PLUS slices that were loaded non-empty but
+     * are now empty (so their file is re-written empty, clearing a slice whose
+     * regions the user deleted). Each returned region is tagged with its z, and
+     * the current live slice is captured first. Empty outside stack mode.
+     */
+    getStackSaveSlices() {
+        const out = new Map();
+        if (!this.stackMode)
+            return out;
+        this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());
+        const zs = new Set(this.stackInitialNonEmpty);
+        for (const [z, regs] of this.regionsBySlice)
+            if (regs.length)
+                zs.add(z);
+        for (const z of Array.from(zs).sort((a, b) => a - b)) {
+            const regs = (this.regionsBySlice.get(z) ?? []).map((r) => { r.z = z; return r; });
+            out.set(z, regs);
+        }
+        return out;
+    }
+    /** Mint ids/names + apply classification colours + tag the slice index, as
+     *  {@link setRegions} does, for regions entering the per-slice store. */
+    normalizeSlice(regions, z) {
+        for (const region of regions) {
+            if (region.id == null)
+                region.id = this.nextId++;
+            if (region.name == null)
+                region.name = `shape${region.id}`;
+            region.z = z;
+        }
+        this.applyClassificationColors(regions);
+        return regions.slice();
+    }
+    /**
+     * Closed polygons projected for image-processing consumers (segmentation,
+     * trace builders). Open polylines are annotation-only and excluded. Reuses
+     * the neutral PlotUtilities projection so output matches the previous path.
+     */
+    getRegionPolygons() {
+        const ret = [];
+        for (const region of this.regions) {
+            const poly = this.plotUtilities.getPolygon({ ...region.getShape(this.showShapeLabel) });
+            if (poly == null || poly.closed === false)
+                continue;
+            ret.push(poly);
+        }
+        return ret;
+    }
+    getRegionUpdateEvent() {
+        return this.regionUpdate$.asObservable();
+    }
+    /** Live (non-coalesced) region-change stream — fires per frame during a drag.
+     *  Used by the intensity-profile inset so it tracks line ROIs live. */
+    getRegionLiveEdit$() {
+        return this.regionLiveEdit$.asObservable();
+    }
+    // ── IRegionStore: selection ────────────────────────────────────────────
+    /** Select regions by array index (or [] to clear). Stored internally by id
+     *  so the selection survives subsequent edits/reorders. */
+    setSelectedShapeIndices(indices) {
+        const ids = [];
+        const seen = new Set();
+        for (const i of indices || []) {
+            if (!Number.isFinite(i) || i < 0 || i >= this.regions.length)
+                continue;
+            const id = this.regions[i].id;
+            if (!seen.has(id)) {
+                seen.add(id);
+                ids.push(id);
+            }
+        }
+        this.selectedIds = ids;
+        this.emitSelection();
+    }
+    /** Select a single region by identity (id). Backends call this from their
+     *  `selectRegion()`; the OSD overlay + region editor highlight off the
+     *  resulting selection emit. No-op if the region isn't in the store. */
+    selectRegion(region) {
+        if (region?.id == null || this.indexOfId(region.id) < 0)
+            return;
+        this.selectedIds = [region.id];
+        this.emitSelection();
+    }
+    getSelectedShapeIndices$() {
+        return this.selectedIndices$.asObservable();
+    }
+    /** Synchronous current selection (array indices) — for callers that need to
+     *  read the selection without subscribing. */
+    getSelectedShapeIndices() {
+        return this.selectedIndices$.value;
+    }
+    /** Delete the currently selected regions and clear the selection. */
+    deleteActiveShape() {
+        if (this.selectedIds.length === 0)
+            return;
+        this.recordUndoSnapshot();
+        const ids = new Set(this.selectedIds);
+        this.regions = this.regions.filter(r => !ids.has(r.id));
+        this.selectedIds = [];
+        this.syncCache();
+        this.emitSelection();
+        this.emit();
+    }
+    // ── IRegionStore: colours / labels ─────────────────────────────────────
+    getShowShapeLabel() { return this.showShapeLabel; }
+    getShapeColor() { return this.shapeColor; }
+    getFillColor() { return this.fillColor; }
+    /** Convenience setters (not on the contract) for toolbar wiring. */
+    setShowShapeLabel(show) { this.showShapeLabel = show; }
+    setShapeColor(color) { this.shapeColor = color; }
+    setFillColor(color) { this.fillColor = color; }
+    getClassificationColors() { return this.store.getClassificationColors(); }
+    setClassificationColor(label, color) { this.store.setClassificationColor(label, color); }
+    // ── IRegionStore: previous-shapes buffer ───────────────────────────────
+    /** Re-show the last saved snapshot (transient — does not alter stored state). */
+    plotPreviousShapes() {
+        this.regionUpdate$.next(this.previousRegions.slice());
+    }
+    setPreviousShapes(shapes) { this.previousRegions = shapes.slice(); }
+    getPreviousShapes() { return this.previousRegions.slice(); }
+    // ── IRegionStore: undo / redo (jit-ui#85) ──────────────────────────────
+    /** Emits whether an undo step is currently available — drives the toolbar
+     *  Undo button's enabled state (greyed out when false). */
+    getCanUndo$() {
+        return this.canUndo$.asObservable();
+    }
+    /** Emits whether a redo step is currently available — drives the toolbar
+     *  Redo button's enabled state. */
+    getCanRedo$() {
+        return this.canRedo$.asObservable();
+    }
+    /** Synchronous read of {@link getCanUndo$} — true when at least one region
+     *  action can be undone. */
+    canUndo() {
+        return this.undoStack.length > 0;
+    }
+    /** Synchronous read of {@link getCanRedo$} — true when an undone action can
+     *  be re-applied. */
+    canRedo() {
+        return this.redoStack.length > 0;
+    }
+    /**
+     * Undo the most recent region action, restoring the region set to its state
+     * just before that action and pushing the current state onto the redo stack.
+     * Up to {@link UNDO_LIMIT} steps are retained, so this can be called up to
+     * {@link UNDO_LIMIT} times in a row before the history empties. No-op when
+     * nothing is left to undo.
+     */
+    undo() {
+        if (this.undoStack.length === 0)
+            return;
+        const snapshot = this.undoStack.pop();
+        // Stash the current (post-action) state so redo can re-apply it.
+        this.redoStack.push(this.cloneRegions(this.regions));
+        if (this.redoStack.length > RegionStore.UNDO_LIMIT)
+            this.redoStack.shift();
+        this.restoreSnapshot(snapshot);
+    }
+    /**
+     * Redo the action most recently undone, restoring the region set to the state
+     * it had before that undo and pushing the current state back onto the undo
+     * stack. No-op when there's nothing to redo (the redo stack is cleared by any
+     * fresh region action).
+     */
+    redo() {
+        if (this.redoStack.length === 0)
+            return;
+        const snapshot = this.redoStack.pop();
+        this.undoStack.push(this.cloneRegions(this.regions));
+        if (this.undoStack.length > RegionStore.UNDO_LIMIT)
+            this.undoStack.shift();
+        this.restoreSnapshot(snapshot);
+    }
+    /** Discard the undo/redo history (e.g. on image load/switch — history never
+     *  crosses images). */
+    resetUndoHistory() {
+        this.undoStack = [];
+        this.redoStack = [];
+        this.closeUndoBurst();
+        if (this.canUndo$.value)
+            this.canUndo$.next(false);
+        if (this.canRedo$.value)
+            this.canRedo$.next(false);
+    }
+    /** Make `snapshot` the live region set and notify both backends. Shared by
+     *  {@link undo} and {@link redo}; the snapshot is already a detached deep
+     *  clone, so it becomes the live array directly. */
+    restoreSnapshot(snapshot) {
+        // Close any open coalescing burst so the next edit starts a fresh entry,
+        // and flag the restore so it doesn't record itself back into the history.
+        this.closeUndoBurst();
+        this.restoringUndo = true;
+        this.regions = snapshot;
+        // Drop any selected ids the restored set no longer contains.
+        this.selectedIds = this.selectedIds.filter(id => this.indexOfId(id) >= 0);
+        this.syncCache();
+        this.emitSelection();
+        this.restoringUndo = false;
+        this.emitUndoState();
+        // Notify the live + coalesced streams so whichever backend is on screen
+        // re-renders from the restored store state.
+        this.regionLiveEdit$.next(this.regions.slice());
+        this.regionUpdate$.next(this.getRegions());
+    }
+    /**
+     * Capture the pre-action region set into the bounded undo history. Called at
+     * the top of every mutating operation, *before* it changes `regions`, so the
+     * snapshot is the state to return to. Rapid commits from one gesture coalesce
+     * into a single entry (see {@link undoStack}). A fresh action also abandons
+     * any redo future.
+     */
+    recordUndoSnapshot() {
+        if (this.restoringUndo)
+            return;
+        const startsBurst = !this.undoBurstOpen;
+        this.armUndoBurst();
+        if (!startsBurst)
+            return; // mid-burst — keep first snapshot
+        this.undoStack.push(this.cloneRegions(this.regions));
+        if (this.undoStack.length > RegionStore.UNDO_LIMIT)
+            this.undoStack.shift();
+        this.redoStack = []; // a new edit invalidates redo
+        this.emitUndoState();
+    }
+    /** Push the current can-undo / can-redo availability to subscribers. */
+    emitUndoState() {
+        const canUndo = this.undoStack.length > 0;
+        const canRedo = this.redoStack.length > 0;
+        if (this.canUndo$.value !== canUndo)
+            this.canUndo$.next(canUndo);
+        if (this.canRedo$.value !== canRedo)
+            this.canRedo$.next(canRedo);
+    }
+    /** (Re)arm the idle timer that closes the current coalescing burst. */
+    armUndoBurst() {
+        this.undoBurstOpen = true;
+        if (this.undoBurstTimer)
+            clearTimeout(this.undoBurstTimer);
+        this.undoBurstTimer = setTimeout(() => {
+            this.undoBurstOpen = false;
+            this.undoBurstTimer = null;
+        }, RegionStore.UNDO_COALESCE_MS);
+    }
+    closeUndoBurst() {
+        this.undoBurstOpen = false;
+        if (this.undoBurstTimer) {
+            clearTimeout(this.undoBurstTimer);
+            this.undoBurstTimer = null;
+        }
+    }
+    cloneRegions(regions) {
+        return regions.map(r => this.cloneRegion(r));
+    }
+    /** Deep clone a region so an in-place geometry edit can't mutate a stored
+     *  history snapshot (bounds are cloned via {@link cloneBounds}). */
+    cloneRegion(r) {
+        const c = new Region();
+        Object.assign(c, r);
+        c.bounds = r.bounds ? this.cloneBounds(r.bounds) : r.bounds;
+        if (Array.isArray(r.tileCoordinates))
+            c.tileCoordinates = r.tileCoordinates.slice();
+        return c;
+    }
+    // ── IRegionStore: GeoJSON I/O (neutral helpers) ────────────────────────
+    importRegions(geoJsonStr) {
+        return this.plotUtilities.importROIsFromGeoJson(geoJsonStr);
+    }
+    exportRegions(regions) {
+        this.plotUtilities.saveToFile(this.plotUtilities.exportROIsToGeoJson(regions));
+    }
+    getGeoJsonString(regions) {
+        return this.plotUtilities.exportROIsToGeoJson(regions);
+    }
+    // ── IRegionEditApi: structural edits ───────────────────────────────────
+    addRegion(region) {
+        this.recordUndoSnapshot();
+        if (region.id == null)
+            region.id = this.nextId++;
+        if (region.name == null)
+            region.name = `shape${region.id}`;
+        // A region drawn on a stack belongs to the slice currently displayed, so
+        // it saves/reloads on that slice (jit-ui#93). No-op for single-plane images
+        // (currentSliceZ stays 0).
+        if (this.stackMode)
+            region.z = this.currentSliceZ;
+        this.applyClassificationColors([region]);
+        this.regions.push(region);
+        this.selectedIds = [region.id];
+        this.syncCache();
+        this.emitSelection();
+        this.emit();
+        return region.id;
+    }
+    removeRegion(id) {
+        const idx = this.indexOfId(id);
+        if (idx < 0)
+            return;
+        this.recordUndoSnapshot();
+        this.regions.splice(idx, 1);
+        this.selectedIds = this.selectedIds.filter(s => s !== id);
+        this.syncCache();
+        this.emitSelection();
+        this.emit();
+    }
+    updateBounds(id, bounds) {
+        const r = this.findById(id);
+        if (!r)
+            return;
+        this.recordUndoSnapshot();
+        r.bounds = this.cloneBounds(bounds);
+        this.syncCache();
+        this.emit();
+    }
+    moveRegion(id, dx, dy) {
+        const r = this.findById(id);
+        if (!r || !r.bounds)
+            return;
+        this.recordUndoSnapshot();
+        const b = r.bounds;
+        if (b instanceof Rectangle) {
+            b.x += dx;
+            b.y += dy;
+        }
+        else if (b instanceof Polygon) {
+            this.translatePolygon(b, dx, dy);
+        }
+        else if (b instanceof MultiPolygon) {
+            // Translate every part (and its holes) together (jit-ui#85).
+            for (const part of b.polygons)
+                this.translatePolygon(part, dx, dy);
+        }
+        this.syncCache();
+        this.emit();
+    }
+    /** Translate a polygon's vertices and any holes in place by (dx, dy). */
+    translatePolygon(p, dx, dy) {
+        p.xpoints = p.xpoints.map(x => x + dx);
+        p.ypoints = p.ypoints.map(y => y + dy);
+        p.coordinates = p.xpoints.map((x, i) => [x, p.ypoints[i]]);
+        if (p.holes)
+            p.holes = p.holes.map(ring => ring.map(([x, y]) => [x + dx, y + dy]));
+    }
+    // ── IRegionEditApi: vertex edits (polygons only) ───────────────────────
+    moveVertex(id, index, x, y) {
+        const poly = this.polygonOf(id);
+        if (!poly || index < 0 || index >= poly.xpoints.length)
+            return;
+        this.recordUndoSnapshot();
+        poly.xpoints[index] = x;
+        poly.ypoints[index] = y;
+        poly.coordinates[index] = [x, y];
+        this.syncCache();
+        this.emit();
+    }
+    /** Move a vertex on a polygon's interior ring (hole) — jit-ui#85. */
+    moveHoleVertex(id, holeIndex, index, x, y) {
+        const poly = this.polygonOf(id);
+        if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length)
+            return;
+        const ring = poly.holes[holeIndex];
+        if (index < 0 || index >= ring.length)
+            return;
+        this.recordUndoSnapshot();
+        ring[index] = [x, y];
+        this.syncCache();
+        this.emit();
+    }
+    /** Insert a vertex on a polygon's interior ring (hole), after `segIndex`
+     *  (the edge's start vertex). No-op for an out-of-range hole — jit-ui#85. */
+    addHoleVertex(id, holeIndex, segIndex, x, y) {
+        const poly = this.polygonOf(id);
+        if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length)
+            return;
+        const ring = poly.holes[holeIndex];
+        this.recordUndoSnapshot();
+        const at = Math.max(0, Math.min(segIndex + 1, ring.length));
+        ring.splice(at, 0, [x, y]);
+        if (poly.bezier)
+            this.seedHoleHandles(poly); // keep hole handles aligned to the ring
+        this.syncCache();
+        this.emit();
+    }
+    /** Delete the vertex at `index` on a polygon's interior ring (hole). Removing
+     *  it below 3 vertices drops the whole hole (a ring with < 3 points bounds no
+     *  area) — jit-ui#85. */
+    deleteHoleVertex(id, holeIndex, index) {
+        const poly = this.polygonOf(id);
+        if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length)
+            return;
+        const ring = poly.holes[holeIndex];
+        if (index < 0 || index >= ring.length)
+            return;
+        this.recordUndoSnapshot();
+        if (ring.length <= 3) {
+            poly.holes.splice(holeIndex, 1);
+            if (poly.holes.length === 0)
+                poly.holes = undefined;
+        }
+        else {
+            ring.splice(index, 1);
+        }
+        if (poly.bezier)
+            this.seedHoleHandles(poly); // keep hole handles aligned to the ring(s)
+        this.syncCache();
+        this.emit();
+    }
+    addVertex(id, segIndex, x, y) {
+        const poly = this.polygonOf(id);
+        if (!poly)
+            return;
+        this.recordUndoSnapshot();
+        // Insert after segIndex (the start vertex of the edge). Clamp to range.
+        const at = Math.max(0, Math.min(segIndex + 1, poly.xpoints.length));
+        poly.xpoints.splice(at, 0, x);
+        poly.ypoints.splice(at, 0, y);
+        poly.coordinates = poly.xpoints.map((xx, i) => [xx, poly.ypoints[i]]);
+        poly.npoints = poly.xpoints.length;
+        // Give the new vertex smooth handles from its neighbours; keep the others'
+        // (possibly hand-edited) handles intact.
+        if (poly.bezier && poly.handlesIn && poly.handlesOut) {
+            const n = poly.xpoints.length;
+            const closed = poly.closed !== false;
+            const prev = closed ? (at - 1 + n) % n : Math.max(0, at - 1);
+            const next = closed ? (at + 1) % n : Math.min(n - 1, at + 1);
+            const tx = (poly.xpoints[next] - poly.xpoints[prev]) / 6;
+            const ty = (poly.ypoints[next] - poly.ypoints[prev]) / 6;
+            poly.handlesIn.splice(at, 0, [-tx, -ty]);
+            poly.handlesOut.splice(at, 0, [tx, ty]);
+        }
+        this.syncCache();
+        this.emit();
+    }
+    deleteVertex(id, index) {
+        const poly = this.polygonOf(id);
+        if (!poly || index < 0 || index >= poly.xpoints.length)
+            return;
+        const min = poly.closed === false ? 2 : 3;
+        if (poly.xpoints.length <= min)
+            return; // refuse to degenerate the polygon
+        this.recordUndoSnapshot();
+        poly.xpoints.splice(index, 1);
+        poly.ypoints.splice(index, 1);
+        poly.coordinates = poly.xpoints.map((xx, i) => [xx, poly.ypoints[i]]);
+        poly.npoints = poly.xpoints.length;
+        if (poly.bezier && poly.handlesIn && poly.handlesOut) {
+            poly.handlesIn.splice(index, 1);
+            poly.handlesOut.splice(index, 1);
+        }
+        this.syncCache();
+        this.emit();
+    }
+    setBezier(id, bezier) {
+        const r = this.findById(id);
+        if (!r || !r.bounds)
+            return;
+        if (r.bounds instanceof Polygon) {
+            if (r.bounds.bezier === bezier)
+                return;
+            this.recordUndoSnapshot();
+            this.applyBezier(r.bounds, bezier);
+        }
+        else if (r.bounds instanceof Rectangle && bezier) {
+            this.recordUndoSnapshot();
+            // Smoothing a rectangle: convert it to a 4-anchor closed polygon first.
+            const b = r.bounds;
+            const xs = [b.x, b.x + b.width, b.x + b.width, b.x];
+            const ys = [b.y, b.y, b.y + b.height, b.y + b.height];
+            const poly = new Polygon();
+            poly.npoints = 4;
+            poly.xpoints = xs;
+            poly.ypoints = ys;
+            poly.coordinates = xs.map((x, i) => [x, ys[i]]);
+            poly.closed = true;
+            this.applyBezier(poly, true);
+            r.bounds = poly;
+        }
+        else {
+            return; // bezier=false on a rectangle: nothing to do
+        }
+        this.syncCache();
+        this.emit();
+    }
+    /** Turn bezier on (and seed editable handles from the smooth default) or off
+     *  (and drop the handles). */
+    applyBezier(poly, bezier) {
+        poly.bezier = bezier;
+        if (bezier) {
+            const off = defaultHandleOffsets(poly.xpoints, poly.ypoints, poly.closed !== false);
+            poly.handlesIn = off.in;
+            poly.handlesOut = off.out;
+            this.seedHoleHandles(poly); // smooth the holes too (donut → bezier curves the holes)
+        }
+        else {
+            poly.handlesIn = undefined;
+            poly.handlesOut = undefined;
+            poly.holeHandlesIn = undefined;
+            poly.holeHandlesOut = undefined;
+        }
+    }
+    /** (Re)seed per-hole bezier handles from the Catmull-Rom default, parallel to `poly.holes`. */
+    seedHoleHandles(poly) {
+        if (!poly.holes || !poly.holes.length) {
+            poly.holeHandlesIn = undefined;
+            poly.holeHandlesOut = undefined;
+            return;
+        }
+        const ins = [];
+        const outs = [];
+        for (const ring of poly.holes) {
+            const off = defaultHandleOffsets(ring.map((p) => p[0]), ring.map((p) => p[1]), true);
+            ins.push(off.in);
+            outs.push(off.out);
+        }
+        poly.holeHandlesIn = ins;
+        poly.holeHandlesOut = outs;
+    }
+    /** Drag a bezier control point on a hole ring vertex (donut bezier editing). */
+    moveHoleBezierHandle(id, holeIndex, index, side, x, y) {
+        const poly = this.polygonOf(id);
+        if (!poly || !poly.bezier || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length) {
+            return;
+        }
+        const ring = poly.holes[holeIndex];
+        if (index < 0 || index >= ring.length)
+            return;
+        this.recordUndoSnapshot();
+        if (!poly.holeHandlesIn || !poly.holeHandlesOut)
+            this.seedHoleHandles(poly);
+        const offset = [x - ring[index][0], y - ring[index][1]];
+        if (side === 'in')
+            poly.holeHandlesIn[holeIndex][index] = offset;
+        else
+            poly.holeHandlesOut[holeIndex][index] = offset;
+        this.syncCache();
+        this.emit();
+    }
+    moveBezierHandle(id, index, side, x, y) {
+        const poly = this.polygonOf(id);
+        if (!poly || !poly.bezier || index < 0 || index >= poly.xpoints.length)
+            return;
+        this.recordUndoSnapshot();
+        if (!poly.handlesIn || !poly.handlesOut) {
+            const off = defaultHandleOffsets(poly.xpoints, poly.ypoints, poly.closed !== false);
+            poly.handlesIn = off.in;
+            poly.handlesOut = off.out;
+        }
+        const offset = [x - poly.xpoints[index], y - poly.ypoints[index]];
+        if (side === 'in')
+            poly.handlesIn[index] = offset;
+        else
+            poly.handlesOut[index] = offset;
+        this.syncCache();
+        this.emit();
+    }
+    beginBatch() { this.batchDepth++; }
+    endBatch() {
+        if (this.batchDepth > 0)
+            this.batchDepth--;
+        if (this.batchDepth === 0 && this.pendingEmit) {
+            this.pendingEmit = false;
+            this.regionUpdate$.next(this.getRegions());
+        }
+    }
+    // ── per-image lifecycle ────────────────────────────────────────────────
+    /**
+     * Switch the active image: snapshot the outgoing regions, restore the
+     * incoming image's (or [] if none), clear selection, and notify. Idempotent
+     * for the same image (so repeated replots of one image keep its regions).
+     */
+    setActiveImage(imageInfo) {
+        const newKey = this.deriveImageKey(imageInfo);
+        if (this.currentImageKey === newKey)
+            return;
+        // Switching images ends any per-slice stack session (jit-ui#93); the loader
+        // re-enters stack mode afterwards if the new image is itself a z-stack.
+        this.exitStackMode();
+        if (this.currentImageKey) {
+            this.regionsByImageKey.set(this.currentImageKey, this.regions.slice());
+        }
+        this.currentImageKey = newKey;
+        this.regions = (newKey && this.regionsByImageKey.get(newKey))
+            ? this.regionsByImageKey.get(newKey).slice()
+            : [];
+        this.previousRegions = this.regions.slice();
+        this.selectedIds = [];
+        // Undo never crosses an image switch.
+        this.resetUndoHistory();
+        this.emitSelection();
+        this.regionUpdate$.next(this.getRegions());
+    }
+    /** Drop the entire per-image cache (logout / project switch). */
+    clearRegionsByImageKey() {
+        this.regionsByImageKey.clear();
+        this.currentImageKey = undefined;
+        this.regions = [];
+        this.selectedIds = [];
+        this.resetUndoHistory();
+    }
+    // ── internals ──────────────────────────────────────────────────────────
+    deriveImageKey(imageInfo) {
+        if (!imageInfo)
+            return undefined;
+        if (imageInfo.urls && imageInfo.urls.length > 0 && imageInfo.urls[0]) {
+            return imageInfo.urls[0];
+        }
+        return imageInfo.fileName || undefined;
+    }
+    /**
+     * Resolve each region's colour from the annotation-class preset set (jit-ui#70).
+     * The presets are the source of truth for colour — this **overrides any colour
+     * embedded in the GeoJSON** (which the YOLO worker writes today). A matching
+     * preset gives the class colour; an unknown class gets a deterministic fallback
+     * colour (and, only when `autoPromote` is on, is added to the editable list).
+     * Regions the user explicitly recoloured (`colorOverridden`) are left untouched.
+     */
+    applyClassificationColors(regions) {
+        const set = this.store.getPresetSet();
+        const keyOf = (label) => set.matchMode === 'normalized' ? label.trim().toLowerCase() : label;
+        const known = new Set(set.classes.map((c) => keyOf(c.name)));
+        for (const region of regions) {
+            if (!region.label || region.colorOverridden)
+                continue;
+            const preset = findPreset(region.label, set);
+            if (preset) {
+                region.color = preset.color;
+                continue;
+            }
+            const color = fallbackColorFor(region.label, set.fallbackPalette);
+            region.color = color;
+            if (set.autoPromote && !known.has(keyOf(region.label))) {
+                known.add(keyOf(region.label));
+                // In normalized mode, trim the promoted name so leading/trailing
+                // whitespace doesn't create invisible duplicates or odd display names.
+                const name = set.matchMode === 'normalized' ? region.label.trim() : region.label;
+                this.store.upsertClass({ name, color, source: 'auto' });
+            }
+        }
+    }
+    syncCache() {
+        if (this.currentImageKey) {
+            this.regionsByImageKey.set(this.currentImageKey, this.regions.slice());
+        }
+    }
+    emit() {
+        // Live-edit listeners (e.g. the intensity-profile inset) react on EVERY
+        // change — including per-frame during a batched drag — so they track the
+        // region live. The main regionUpdate$ stays coalesced during a batch (fires
+        // once on endBatch) to keep heavier consumers (Regions tab) calm.
+        this.regionLiveEdit$.next(this.regions.slice());
+        if (this.batchDepth > 0) {
+            this.pendingEmit = true;
+            return;
+        }
+        this.regionUpdate$.next(this.getRegions());
+    }
+    /** Project selected ids to current array indices, pruning ids that no longer
+     *  exist, and emit if the index set changed. */
+    emitSelection() {
+        const indices = [];
+        const liveIds = [];
+        for (const id of this.selectedIds) {
+            const idx = this.indexOfId(id);
+            if (idx >= 0) {
+                indices.push(idx);
+                liveIds.push(id);
+            }
+        }
+        this.selectedIds = liveIds;
+        if (!this.indicesEqual(this.selectedIndices$.value, indices)) {
+            this.selectedIndices$.next(indices);
+        }
+    }
+    indicesEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++)
+            if (a[i] !== b[i])
+                return false;
+        return true;
+    }
+    findById(id) {
+        return this.regions.find(r => r.id === id);
+    }
+    indexOfId(id) {
+        return this.regions.findIndex(r => r.id === id);
+    }
+    /** The region's bounds as a Polygon, or undefined if it isn't a polygon. */
+    polygonOf(id) {
+        const r = this.findById(id);
+        return r && r.bounds instanceof Polygon ? r.bounds : undefined;
+    }
+    clonePolygon(p) {
+        const poly = new Polygon();
+        poly.npoints = p.npoints;
+        poly.xpoints = p.xpoints.slice();
+        poly.ypoints = p.ypoints.slice();
+        poly.coordinates = p.coordinates.map(c => c.slice());
+        poly.closed = p.closed;
+        poly.bezier = p.bezier;
+        if (p.handlesIn)
+            poly.handlesIn = p.handlesIn.map(o => o.slice());
+        if (p.handlesOut)
+            poly.handlesOut = p.handlesOut.map(o => o.slice());
+        if (p.holes)
+            poly.holes = p.holes.map(ring => ring.map(pt => pt.slice()));
+        if (p.holeHandlesIn)
+            poly.holeHandlesIn = p.holeHandlesIn.map(r => r.map(o => o.slice()));
+        if (p.holeHandlesOut)
+            poly.holeHandlesOut = p.holeHandlesOut.map(r => r.map(o => o.slice()));
+        return poly;
+    }
+    cloneBounds(bounds) {
+        if (bounds instanceof Rectangle) {
+            const rect = new Rectangle();
+            rect.x = bounds.x;
+            rect.y = bounds.y;
+            rect.width = bounds.width;
+            rect.height = bounds.height;
+            return rect;
+        }
+        if (bounds instanceof MultiPolygon) {
+            const mp = new MultiPolygon();
+            mp.polygons = bounds.polygons.map(p => this.clonePolygon(p));
+            return mp;
+        }
+        return this.clonePolygon(bounds);
+    }
+    regionsEqual(a, b) {
+        const ba = a.bounds, bb = b.bounds;
+        if (ba instanceof Rectangle && bb instanceof Rectangle) {
+            return ba.x === bb.x && ba.y === bb.y && ba.width === bb.width && ba.height === bb.height;
+        }
+        if (ba instanceof MultiPolygon && bb instanceof MultiPolygon) {
+            if (ba.polygons.length !== bb.polygons.length)
+                return false;
+            for (let i = 0; i < ba.polygons.length; i++) {
+                if (!this.polygonsEqual(ba.polygons[i], bb.polygons[i]))
+                    return false;
+            }
+            return true;
+        }
+        if (ba instanceof Polygon && bb instanceof Polygon) {
+            return this.polygonsEqual(ba, bb);
+        }
+        return false;
+    }
+    polygonsEqual(pa, pb) {
+        if ((pa.closed !== false) !== (pb.closed !== false))
+            return false;
+        if (pa.xpoints.length !== pb.xpoints.length)
+            return false;
+        for (let i = 0; i < pa.xpoints.length; i++) {
+            if (pa.xpoints[i] !== pb.xpoints[i] || pa.ypoints[i] !== pb.ypoints[i])
+                return false;
+        }
+        return this.holesEqual(pa.holes, pb.holes);
+    }
+    /** Compare two polygons' interior-ring (hole) sets for the dedupe path. */
+    holesEqual(a, b) {
+        const na = a?.length ?? 0, nb = b?.length ?? 0;
+        if (na !== nb)
+            return false;
+        for (let h = 0; h < na; h++) {
+            const ra = a[h], rb = b[h];
+            if (ra.length !== rb.length)
+                return false;
+            for (let i = 0; i < ra.length; i++) {
+                if (ra[i][0] !== rb[i][0] || ra[i][1] !== rb[i][1])
+                    return false;
+            }
+        }
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionStore, deps: [{ token: i1.VisualizerStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionStore, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionStore, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.VisualizerStore }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-store.service.js","sourceRoot":"","sources":["../../../../src/lib/store/region-store.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\n\nimport { IImageInfo } from '../contracts/image.contract';\nimport { Region, Rectangle, Polygon, MultiPolygon } from '../models/region';\nimport { PlotUtilities } from '../plot.utilities';\nimport { VisualizerStore } from './visualizer-store.service';\nimport { defaultHandleOffsets } from '../models/bezier';\nimport { IRegionStore } from '../contracts/visualizer.contract';\nimport { IRegionEditApi } from '../contracts/region-store.contract';\nimport { findPreset, fallbackColorFor } from './class-color.util';\n\n/**\n * Backend-neutral region store — the single source of truth for region state.\n *\n * Holds the neutral {@link Region} model (never a backend's own shape\n * representation), keyed per image so regions persist as the user switches\n * files and survive a Plotly⇄OpenSeadragon backend switch (both backends read\n * and write *this* store, so no migration is needed). Backends own *rendering*\n * and react to {@link getRegionUpdateEvent}; this service owns *state* and the\n * editing operations.\n *\n * Implements:\n *  - {@link IRegionStore} — the cross-backend CRUD/selection/colour contract\n *    every consumer (Region Editor, segmentation, etc.) already uses.\n *  - {@link IRegionEditApi} — Region-native geometry edits (move/resize, and\n *    add/delete/move vertex) the OSD overlay drives.\n *\n * Classification colours live in {@link VisualizerStore} (shared by both\n * backends); GeoJSON import/export and the closed-polygon projection reuse the\n * neutral {@link PlotUtilities} helpers. All coordinates are image pixels.\n */\n@Injectable({ providedIn: 'root' })\nexport class RegionStore implements IRegionStore, IRegionEditApi {\n\n  private static readonly UNDO_LIMIT = 10;\n  private static readonly UNDO_COALESCE_MS = 250;\n\n  /** Per-image region cache. `regions` is always a snapshot of the entry for\n   *  `currentImageKey`. */\n  private regionsByImageKey = new Map<string, Region[]>();\n  private currentImageKey: string | undefined;\n  /** The current image's regions — the live, edited array. */\n  private regions: Region[] = [];\n  /** Last saved snapshot, restorable via plotPreviousShapes(). */\n  private previousRegions: Region[] = [];\n\n  /**\n   * Undo/redo history (jit-ui#85): up to {@link UNDO_LIMIT} snapshots of the\n   * region set, each a deep clone captured immediately *before* a\n   * region-editing action. {@link undo} pops the newest off `undoStack`, pushes\n   * the current state onto `redoStack`, and restores it — so it can be invoked\n   * up to {@link UNDO_LIMIT} times in a row. {@link redo} is the mirror. Any new\n   * region action clears `redoStack` (the redo future is no longer reachable).\n   *\n   * A continuous gesture (a wand/brush/vertex drag commits to the store many\n   * times) is coalesced into a single entry: the first commit of a burst\n   * captures the pre-burst state and every commit within\n   * {@link UNDO_COALESCE_MS} of the previous one is folded into it. History\n   * never crosses an image load/switch — {@link resetUndoHistory} clears it.\n   */\n  private undoStack: Region[][] = [];\n  private redoStack: Region[][] = [];\n  /** True while a coalescing burst is open (further commits fold into it). */\n  private undoBurstOpen = false;\n  private undoBurstTimer: ReturnType<typeof setTimeout> | null = null;\n  /** True while restoring a snapshot, so the restore records no new history. */\n  private restoringUndo = false;\n  private readonly canUndo$ = new BehaviorSubject<boolean>(false);\n  private readonly canRedo$ = new BehaviorSubject<boolean>(false);\n\n  /** Monotonic id source — ids never repeat within the service lifetime, so\n   *  selection stays correct across delete/add cycles even when names collide. */\n  private nextId = 1;\n\n  private showShapeLabel = false;\n  private shapeColor = '#00FFFF';\n  private fillColor = '#ff00ff';\n  private isRegionSavedOn = true;\n\n  /**\n   * Per-slice region support for z-stacks (jit-ui#93). While {@link stackMode}\n   * is on (a z-stack is loaded), the live `regions` array always holds ONE\n   * slice — the {@link currentSliceZ} slice — so the on-canvas overlays, the\n   * selection projection, and the Regions table keep working unchanged\n   * (they all read {@link getRegions}). The other slices live in\n   * {@link regionsBySlice}; {@link setDisplaySlice} swaps the live set on scrub\n   * and {@link getSliceRegions} flattens every slice (each tagged with its\n   * zero-based {@link Region.z}) for save/export. Off by default (stackMode\n   * false, z 0), so single-plane images are completely unaffected.\n   */\n  private regionsBySlice = new Map<number, Region[]>();\n  private stackMode = false;\n  private currentSliceZ = 0;\n  /** How a stack's regions round-trip to disk (jit-ui#93): `combined` writes one\n   *  z-indexed geojson (single-file z-stack, QuPath schema); `per-slice-file`\n   *  writes one geojson per slice-file (a folder of numbered images). */\n  private stackSaveLayout: 'combined' | 'per-slice-file' = 'combined';\n  /** Slices that were loaded with regions (jit-ui#93). A per-slice-file save\n   *  re-writes these even when now empty, so clearing a slice's regions and\n   *  saving removes its previously-saved geojson (writes an empty one). */\n  private stackInitialNonEmpty = new Set<number>();\n\n  /** Selection is tracked by region *id* internally (stable across edits) and\n   *  projected to array indices on the IRegionStore boundary. */\n  private selectedIds: number[] = [];\n  private readonly selectedIndices$ = new BehaviorSubject<number[]>([]);\n  private readonly regionUpdate$ = new Subject<Region[]>();\n  /** Non-coalesced sibling of regionUpdate$: fires on every change even during a\n   *  batched drag, so live consumers (intensity inset) update per frame. */\n  private readonly regionLiveEdit$ = new Subject<Region[]>();\n\n  /** Emit coalescing for live drags (see IRegionEditApi.beginBatch). */\n  private batchDepth = 0;\n  private pendingEmit = false;\n\n  private readonly plotUtilities = new PlotUtilities();\n\n  constructor(private store: VisualizerStore) {}\n\n  // ── IRegionStore: CRUD ─────────────────────────────────────────────────\n\n  /**\n   * Replace (or, with `append`, add to) the current image's regions. Mints ids\n   * and default names, applies stored classification colours, and emits. When\n   * `isRegionSaveOn` is false the regions are shown transiently (emitted) but\n   * not stored — mirrors the previous Plotly behaviour.\n   */\n  setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean,\n             fillColor?: string, append: boolean = false): void {\n    if (showRegionLabel === undefined) showRegionLabel = this.showShapeLabel;\n    if (isRegionSaveOn === undefined) isRegionSaveOn = this.isRegionSavedOn;\n    if (fillColor === undefined) fillColor = this.fillColor;\n\n    for (const region of regions) {\n      if (region.id == null) region.id = this.nextId++;\n      if (region.name == null) region.name = `shape${region.id}`;\n    }\n    this.applyClassificationColors(regions);\n\n    this.isRegionSavedOn = isRegionSaveOn;\n    if (isRegionSaveOn) {\n      this.recordUndoSnapshot();\n      this.showShapeLabel = showRegionLabel;\n      this.fillColor = fillColor;\n      if (append) {\n        // Reject by id collision (already tracked) or geometry equality (same\n        // coordinates) — the find button can push the same region repeatedly.\n        const added = regions.filter(r =>\n          !this.regions.some(existing => existing.id === r.id || this.regionsEqual(existing, r)));\n        this.regions = this.regions.concat(added);\n      } else {\n        this.regions = regions.slice();\n      }\n      this.syncCache();\n      this.emitSelection();\n      this.emit();\n    } else {\n      // Transient display only — don't touch stored state.\n      this.regionUpdate$.next(regions.slice());\n    }\n  }\n\n  /** The canonical accessor: current image's regions (live instances). */\n  getRegions(): Region[] {\n    return this.regions.slice();\n  }\n\n  // ── Per-slice regions for z-stacks (jit-ui#93) ─────────────────────────\n\n  /** True while a z-stack is loaded and the store holds regions per slice. */\n  isStackMode(): boolean { return this.stackMode; }\n\n  /** The current display slice (zero-based). */\n  getDisplaySlice(): number { return this.currentSliceZ; }\n\n  /** How the current stack persists to disk (jit-ui#93): `combined` = one\n   *  z-indexed geojson (single-file z-stack); `per-slice-file` = one geojson per\n   *  slice-file (folder stack). Meaningless outside stack mode. */\n  getStackSaveLayout(): 'combined' | 'per-slice-file' { return this.stackSaveLayout; }\n\n  /**\n   * Enter per-slice stack mode. `slices` maps each zero-based slice index to\n   * the regions imported for that slice; the store makes `initialZ`'s slice the\n   * live set, so the overlays / selection / Regions table are unchanged (they\n   * still read {@link getRegions}). Freshly-created regions are tagged with the\n   * current slice so they persist on it, and {@link getSliceRegions} returns\n   * every slice for save/export. Ids/names/classification colours are minted\n   * exactly as {@link setRegions} does.\n   */\n  enterStackMode(slices: Map<number, Region[]>, initialZ = 0,\n                 saveLayout: 'combined' | 'per-slice-file' = 'combined'): void {\n    this.stackMode = true;\n    this.stackSaveLayout = saveLayout;\n    this.currentSliceZ = initialZ || 0;\n    this.regionsBySlice = new Map<number, Region[]>();\n    this.stackInitialNonEmpty = new Set<number>();\n    for (const [z, regs] of slices) {\n      const normalized = this.normalizeSlice(regs || [], z);\n      this.regionsBySlice.set(z, normalized);\n      if (normalized.length) this.stackInitialNonEmpty.add(z);\n    }\n    this.regions = (this.regionsBySlice.get(this.currentSliceZ) ?? []).slice();\n    this.previousRegions = this.regions.slice();\n    this.selectedIds = [];\n    this.syncCache();\n    this.resetUndoHistory();\n    this.emitSelection();\n    this.emit();\n  }\n\n  /** Leave stack mode (single-plane image, or the stack was closed). */\n  exitStackMode(): void {\n    if (!this.stackMode) return;\n    this.stackMode = false;\n    this.currentSliceZ = 0;\n    this.regionsBySlice = new Map<number, Region[]>();\n    this.stackInitialNonEmpty = new Set<number>();\n  }\n\n  /**\n   * Show a different slice: capture the current slice's (possibly edited)\n   * regions back into the per-slice store, then load the target slice's regions\n   * as the live set and emit. Undo never crosses a slice. Outside stack mode\n   * this only records the requested slice index (a no-op otherwise: single-plane\n   * regions stay on the default plane — addRegion tags Region.z only in stack\n   * mode, so the recorded index is unused until a stack is entered). (jit-ui#93)\n   */\n  setDisplaySlice(z: number): void {\n    const next = z || 0;\n    if (!this.stackMode) { this.currentSliceZ = next; return; }\n    if (this.currentSliceZ === next) return;\n    this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());\n    this.currentSliceZ = next;\n    this.regions = (this.regionsBySlice.get(next) ?? []).slice();\n    this.previousRegions = this.regions.slice();\n    this.selectedIds = [];\n    this.syncCache();\n    this.resetUndoHistory();\n    this.emitSelection();\n    this.emit();\n  }\n\n  /**\n   * Every slice's regions for save/export, each tagged with its zero-based\n   * slice index in {@link Region.z}. Captures the current slice's live edits\n   * first. Returns the flat single-plane set when not in stack mode. (jit-ui#93)\n   */\n  getSliceRegions(): Region[] {\n    if (!this.stackMode) return this.regions.slice();\n    this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());\n    const out: Region[] = [];\n    const zs = Array.from(this.regionsBySlice.keys()).sort((a, b) => a - b);\n    for (const z of zs) {\n      for (const r of this.regionsBySlice.get(z) as Region[]) {\n        r.z = z;\n        out.push(r);\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Slices to write on a per-slice-file save (folder stack, jit-ui#93): every\n   * slice that currently has regions, PLUS slices that were loaded non-empty but\n   * are now empty (so their file is re-written empty, clearing a slice whose\n   * regions the user deleted). Each returned region is tagged with its z, and\n   * the current live slice is captured first. Empty outside stack mode.\n   */\n  getStackSaveSlices(): Map<number, Region[]> {\n    const out = new Map<number, Region[]>();\n    if (!this.stackMode) return out;\n    this.regionsBySlice.set(this.currentSliceZ, this.regions.slice());\n    const zs = new Set<number>(this.stackInitialNonEmpty);\n    for (const [z, regs] of this.regionsBySlice) if (regs.length) zs.add(z);\n    for (const z of Array.from(zs).sort((a, b) => a - b)) {\n      const regs = (this.regionsBySlice.get(z) ?? []).map((r) => { r.z = z; return r; });\n      out.set(z, regs);\n    }\n    return out;\n  }\n\n  /** Mint ids/names + apply classification colours + tag the slice index, as\n   *  {@link setRegions} does, for regions entering the per-slice store. */\n  private normalizeSlice(regions: Region[], z: number): Region[] {\n    for (const region of regions) {\n      if (region.id == null) region.id = this.nextId++;\n      if (region.name == null) region.name = `shape${region.id}`;\n      region.z = z;\n    }\n    this.applyClassificationColors(regions);\n    return regions.slice();\n  }\n\n  /**\n   * Closed polygons projected for image-processing consumers (segmentation,\n   * trace builders). Open polylines are annotation-only and excluded. Reuses\n   * the neutral PlotUtilities projection so output matches the previous path.\n   */\n  getRegionPolygons(): any[] {\n    const ret: any[] = [];\n    for (const region of this.regions) {\n      const poly: any = this.plotUtilities.getPolygon({ ...region.getShape(this.showShapeLabel) });\n      if (poly == null || poly.closed === false) continue;\n      ret.push(poly);\n    }\n    return ret;\n  }\n\n  getRegionUpdateEvent(): Observable<any[]> {\n    return this.regionUpdate$.asObservable();\n  }\n\n  /** Live (non-coalesced) region-change stream — fires per frame during a drag.\n   *  Used by the intensity-profile inset so it tracks line ROIs live. */\n  getRegionLiveEdit$(): Observable<Region[]> {\n    return this.regionLiveEdit$.asObservable();\n  }\n\n  // ── IRegionStore: selection ────────────────────────────────────────────\n\n  /** Select regions by array index (or [] to clear). Stored internally by id\n   *  so the selection survives subsequent edits/reorders. */\n  setSelectedShapeIndices(indices: number[]): void {\n    const ids: number[] = [];\n    const seen = new Set<number>();\n    for (const i of indices || []) {\n      if (!Number.isFinite(i) || i < 0 || i >= this.regions.length) continue;\n      const id = this.regions[i].id;\n      if (!seen.has(id)) { seen.add(id); ids.push(id); }\n    }\n    this.selectedIds = ids;\n    this.emitSelection();\n  }\n\n  /** Select a single region by identity (id). Backends call this from their\n   *  `selectRegion()`; the OSD overlay + region editor highlight off the\n   *  resulting selection emit. No-op if the region isn't in the store. */\n  selectRegion(region: Region): void {\n    if (region?.id == null || this.indexOfId(region.id) < 0) return;\n    this.selectedIds = [region.id];\n    this.emitSelection();\n  }\n\n  getSelectedShapeIndices$(): Observable<number[]> {\n    return this.selectedIndices$.asObservable();\n  }\n\n  /** Synchronous current selection (array indices) — for callers that need to\n   *  read the selection without subscribing. */\n  getSelectedShapeIndices(): number[] {\n    return this.selectedIndices$.value;\n  }\n\n  /** Delete the currently selected regions and clear the selection. */\n  deleteActiveShape(): void {\n    if (this.selectedIds.length === 0) return;\n    this.recordUndoSnapshot();\n    const ids = new Set(this.selectedIds);\n    this.regions = this.regions.filter(r => !ids.has(r.id));\n    this.selectedIds = [];\n    this.syncCache();\n    this.emitSelection();\n    this.emit();\n  }\n\n  // ── IRegionStore: colours / labels ─────────────────────────────────────\n\n  getShowShapeLabel(): boolean { return this.showShapeLabel; }\n  getShapeColor(): string { return this.shapeColor; }\n  getFillColor(): string { return this.fillColor; }\n\n  /** Convenience setters (not on the contract) for toolbar wiring. */\n  setShowShapeLabel(show: boolean): void { this.showShapeLabel = show; }\n  setShapeColor(color: string): void { this.shapeColor = color; }\n  setFillColor(color: string): void { this.fillColor = color; }\n\n  getClassificationColors(): Map<string, string> { return this.store.getClassificationColors(); }\n  setClassificationColor(label: string, color: string): void { this.store.setClassificationColor(label, color); }\n\n  // ── IRegionStore: previous-shapes buffer ───────────────────────────────\n\n  /** Re-show the last saved snapshot (transient — does not alter stored state). */\n  plotPreviousShapes(): void {\n    this.regionUpdate$.next(this.previousRegions.slice());\n  }\n  setPreviousShapes(shapes: any[]): void { this.previousRegions = (shapes as Region[]).slice(); }\n  getPreviousShapes(): any[] { return this.previousRegions.slice(); }\n\n  // ── IRegionStore: undo / redo (jit-ui#85) ──────────────────────────────\n\n  /** Emits whether an undo step is currently available — drives the toolbar\n   *  Undo button's enabled state (greyed out when false). */\n  getCanUndo$(): Observable<boolean> {\n    return this.canUndo$.asObservable();\n  }\n\n  /** Emits whether a redo step is currently available — drives the toolbar\n   *  Redo button's enabled state. */\n  getCanRedo$(): Observable<boolean> {\n    return this.canRedo$.asObservable();\n  }\n\n  /** Synchronous read of {@link getCanUndo$} — true when at least one region\n   *  action can be undone. */\n  canUndo(): boolean {\n    return this.undoStack.length > 0;\n  }\n\n  /** Synchronous read of {@link getCanRedo$} — true when an undone action can\n   *  be re-applied. */\n  canRedo(): boolean {\n    return this.redoStack.length > 0;\n  }\n\n  /**\n   * Undo the most recent region action, restoring the region set to its state\n   * just before that action and pushing the current state onto the redo stack.\n   * Up to {@link UNDO_LIMIT} steps are retained, so this can be called up to\n   * {@link UNDO_LIMIT} times in a row before the history empties. No-op when\n   * nothing is left to undo.\n   */\n  undo(): void {\n    if (this.undoStack.length === 0) return;\n    const snapshot = this.undoStack.pop() as Region[];\n    // Stash the current (post-action) state so redo can re-apply it.\n    this.redoStack.push(this.cloneRegions(this.regions));\n    if (this.redoStack.length > RegionStore.UNDO_LIMIT) this.redoStack.shift();\n    this.restoreSnapshot(snapshot);\n  }\n\n  /**\n   * Redo the action most recently undone, restoring the region set to the state\n   * it had before that undo and pushing the current state back onto the undo\n   * stack. No-op when there's nothing to redo (the redo stack is cleared by any\n   * fresh region action).\n   */\n  redo(): void {\n    if (this.redoStack.length === 0) return;\n    const snapshot = this.redoStack.pop() as Region[];\n    this.undoStack.push(this.cloneRegions(this.regions));\n    if (this.undoStack.length > RegionStore.UNDO_LIMIT) this.undoStack.shift();\n    this.restoreSnapshot(snapshot);\n  }\n\n  /** Discard the undo/redo history (e.g. on image load/switch — history never\n   *  crosses images). */\n  resetUndoHistory(): void {\n    this.undoStack = [];\n    this.redoStack = [];\n    this.closeUndoBurst();\n    if (this.canUndo$.value) this.canUndo$.next(false);\n    if (this.canRedo$.value) this.canRedo$.next(false);\n  }\n\n  /** Make `snapshot` the live region set and notify both backends. Shared by\n   *  {@link undo} and {@link redo}; the snapshot is already a detached deep\n   *  clone, so it becomes the live array directly. */\n  private restoreSnapshot(snapshot: Region[]): void {\n    // Close any open coalescing burst so the next edit starts a fresh entry,\n    // and flag the restore so it doesn't record itself back into the history.\n    this.closeUndoBurst();\n    this.restoringUndo = true;\n    this.regions = snapshot;\n    // Drop any selected ids the restored set no longer contains.\n    this.selectedIds = this.selectedIds.filter(id => this.indexOfId(id) >= 0);\n    this.syncCache();\n    this.emitSelection();\n    this.restoringUndo = false;\n    this.emitUndoState();\n    // Notify the live + coalesced streams so whichever backend is on screen\n    // re-renders from the restored store state.\n    this.regionLiveEdit$.next(this.regions.slice());\n    this.regionUpdate$.next(this.getRegions());\n  }\n\n  /**\n   * Capture the pre-action region set into the bounded undo history. Called at\n   * the top of every mutating operation, *before* it changes `regions`, so the\n   * snapshot is the state to return to. Rapid commits from one gesture coalesce\n   * into a single entry (see {@link undoStack}). A fresh action also abandons\n   * any redo future.\n   */\n  private recordUndoSnapshot(): void {\n    if (this.restoringUndo) return;\n    const startsBurst = !this.undoBurstOpen;\n    this.armUndoBurst();\n    if (!startsBurst) return;                      // mid-burst — keep first snapshot\n    this.undoStack.push(this.cloneRegions(this.regions));\n    if (this.undoStack.length > RegionStore.UNDO_LIMIT) this.undoStack.shift();\n    this.redoStack = [];                           // a new edit invalidates redo\n    this.emitUndoState();\n  }\n\n  /** Push the current can-undo / can-redo availability to subscribers. */\n  private emitUndoState(): void {\n    const canUndo = this.undoStack.length > 0;\n    const canRedo = this.redoStack.length > 0;\n    if (this.canUndo$.value !== canUndo) this.canUndo$.next(canUndo);\n    if (this.canRedo$.value !== canRedo) this.canRedo$.next(canRedo);\n  }\n\n  /** (Re)arm the idle timer that closes the current coalescing burst. */\n  private armUndoBurst(): void {\n    this.undoBurstOpen = true;\n    if (this.undoBurstTimer) clearTimeout(this.undoBurstTimer);\n    this.undoBurstTimer = setTimeout(() => {\n      this.undoBurstOpen = false;\n      this.undoBurstTimer = null;\n    }, RegionStore.UNDO_COALESCE_MS);\n  }\n\n  private closeUndoBurst(): void {\n    this.undoBurstOpen = false;\n    if (this.undoBurstTimer) { clearTimeout(this.undoBurstTimer); this.undoBurstTimer = null; }\n  }\n\n  private cloneRegions(regions: Region[]): Region[] {\n    return regions.map(r => this.cloneRegion(r));\n  }\n\n  /** Deep clone a region so an in-place geometry edit can't mutate a stored\n   *  history snapshot (bounds are cloned via {@link cloneBounds}). */\n  private cloneRegion(r: Region): Region {\n    const c = new Region();\n    Object.assign(c, r);\n    c.bounds = r.bounds ? this.cloneBounds(r.bounds) : r.bounds;\n    if (Array.isArray(r.tileCoordinates)) c.tileCoordinates = r.tileCoordinates.slice();\n    return c;\n  }\n\n  // ── IRegionStore: GeoJSON I/O (neutral helpers) ────────────────────────\n\n  importRegions(geoJsonStr: string): Region[] {\n    return this.plotUtilities.importROIsFromGeoJson(geoJsonStr);\n  }\n  exportRegions(regions: Region[]): void {\n    this.plotUtilities.saveToFile(this.plotUtilities.exportROIsToGeoJson(regions));\n  }\n  getGeoJsonString(regions: Region[]): string {\n    return this.plotUtilities.exportROIsToGeoJson(regions);\n  }\n\n  // ── IRegionEditApi: structural edits ───────────────────────────────────\n\n  addRegion(region: Region): number {\n    this.recordUndoSnapshot();\n    if (region.id == null) region.id = this.nextId++;\n    if (region.name == null) region.name = `shape${region.id}`;\n    // A region drawn on a stack belongs to the slice currently displayed, so\n    // it saves/reloads on that slice (jit-ui#93). No-op for single-plane images\n    // (currentSliceZ stays 0).\n    if (this.stackMode) region.z = this.currentSliceZ;\n    this.applyClassificationColors([region]);\n    this.regions.push(region);\n    this.selectedIds = [region.id];\n    this.syncCache();\n    this.emitSelection();\n    this.emit();\n    return region.id;\n  }\n\n  removeRegion(id: number): void {\n    const idx = this.indexOfId(id);\n    if (idx < 0) return;\n    this.recordUndoSnapshot();\n    this.regions.splice(idx, 1);\n    this.selectedIds = this.selectedIds.filter(s => s !== id);\n    this.syncCache();\n    this.emitSelection();\n    this.emit();\n  }\n\n  updateBounds(id: number, bounds: Rectangle | Polygon | MultiPolygon): void {\n    const r = this.findById(id);\n    if (!r) return;\n    this.recordUndoSnapshot();\n    r.bounds = this.cloneBounds(bounds);\n    this.syncCache();\n    this.emit();\n  }\n\n  moveRegion(id: number, dx: number, dy: number): void {\n    const r = this.findById(id);\n    if (!r || !r.bounds) return;\n    this.recordUndoSnapshot();\n    const b = r.bounds;\n    if (b instanceof Rectangle) {\n      b.x += dx;\n      b.y += dy;\n    } else if (b instanceof Polygon) {\n      this.translatePolygon(b, dx, dy);\n    } else if (b instanceof MultiPolygon) {\n      // Translate every part (and its holes) together (jit-ui#85).\n      for (const part of b.polygons) this.translatePolygon(part, dx, dy);\n    }\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Translate a polygon's vertices and any holes in place by (dx, dy). */\n  private translatePolygon(p: Polygon, dx: number, dy: number): void {\n    p.xpoints = p.xpoints.map(x => x + dx);\n    p.ypoints = p.ypoints.map(y => y + dy);\n    p.coordinates = p.xpoints.map((x, i) => [x, p.ypoints[i]]);\n    if (p.holes) p.holes = p.holes.map(ring => ring.map(([x, y]) => [x + dx, y + dy]));\n  }\n\n  // ── IRegionEditApi: vertex edits (polygons only) ───────────────────────\n\n  moveVertex(id: number, index: number, x: number, y: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || index < 0 || index >= poly.xpoints.length) return;\n    this.recordUndoSnapshot();\n    poly.xpoints[index] = x;\n    poly.ypoints[index] = y;\n    poly.coordinates[index] = [x, y];\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Move a vertex on a polygon's interior ring (hole) — jit-ui#85. */\n  moveHoleVertex(id: number, holeIndex: number, index: number, x: number, y: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length) return;\n    const ring = poly.holes[holeIndex];\n    if (index < 0 || index >= ring.length) return;\n    this.recordUndoSnapshot();\n    ring[index] = [x, y];\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Insert a vertex on a polygon's interior ring (hole), after `segIndex`\n   *  (the edge's start vertex). No-op for an out-of-range hole — jit-ui#85. */\n  addHoleVertex(id: number, holeIndex: number, segIndex: number, x: number, y: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length) return;\n    const ring = poly.holes[holeIndex];\n    this.recordUndoSnapshot();\n    const at = Math.max(0, Math.min(segIndex + 1, ring.length));\n    ring.splice(at, 0, [x, y]);\n    if (poly.bezier) this.seedHoleHandles(poly); // keep hole handles aligned to the ring\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Delete the vertex at `index` on a polygon's interior ring (hole). Removing\n   *  it below 3 vertices drops the whole hole (a ring with < 3 points bounds no\n   *  area) — jit-ui#85. */\n  deleteHoleVertex(id: number, holeIndex: number, index: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length) return;\n    const ring = poly.holes[holeIndex];\n    if (index < 0 || index >= ring.length) return;\n    this.recordUndoSnapshot();\n    if (ring.length <= 3) {\n      poly.holes.splice(holeIndex, 1);\n      if (poly.holes.length === 0) poly.holes = undefined;\n    } else {\n      ring.splice(index, 1);\n    }\n    if (poly.bezier) this.seedHoleHandles(poly); // keep hole handles aligned to the ring(s)\n    this.syncCache();\n    this.emit();\n  }\n\n  addVertex(id: number, segIndex: number, x: number, y: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly) return;\n    this.recordUndoSnapshot();\n    // Insert after segIndex (the start vertex of the edge). Clamp to range.\n    const at = Math.max(0, Math.min(segIndex + 1, poly.xpoints.length));\n    poly.xpoints.splice(at, 0, x);\n    poly.ypoints.splice(at, 0, y);\n    poly.coordinates = poly.xpoints.map((xx, i) => [xx, poly.ypoints[i]]);\n    poly.npoints = poly.xpoints.length;\n    // Give the new vertex smooth handles from its neighbours; keep the others'\n    // (possibly hand-edited) handles intact.\n    if (poly.bezier && poly.handlesIn && poly.handlesOut) {\n      const n = poly.xpoints.length;\n      const closed = poly.closed !== false;\n      const prev = closed ? (at - 1 + n) % n : Math.max(0, at - 1);\n      const next = closed ? (at + 1) % n : Math.min(n - 1, at + 1);\n      const tx = (poly.xpoints[next] - poly.xpoints[prev]) / 6;\n      const ty = (poly.ypoints[next] - poly.ypoints[prev]) / 6;\n      poly.handlesIn.splice(at, 0, [-tx, -ty]);\n      poly.handlesOut.splice(at, 0, [tx, ty]);\n    }\n    this.syncCache();\n    this.emit();\n  }\n\n  deleteVertex(id: number, index: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || index < 0 || index >= poly.xpoints.length) return;\n    const min = poly.closed === false ? 2 : 3;\n    if (poly.xpoints.length <= min) return; // refuse to degenerate the polygon\n    this.recordUndoSnapshot();\n    poly.xpoints.splice(index, 1);\n    poly.ypoints.splice(index, 1);\n    poly.coordinates = poly.xpoints.map((xx, i) => [xx, poly.ypoints[i]]);\n    poly.npoints = poly.xpoints.length;\n    if (poly.bezier && poly.handlesIn && poly.handlesOut) {\n      poly.handlesIn.splice(index, 1);\n      poly.handlesOut.splice(index, 1);\n    }\n    this.syncCache();\n    this.emit();\n  }\n\n  setBezier(id: number, bezier: boolean): void {\n    const r = this.findById(id);\n    if (!r || !r.bounds) return;\n    if (r.bounds instanceof Polygon) {\n      if (r.bounds.bezier === bezier) return;\n      this.recordUndoSnapshot();\n      this.applyBezier(r.bounds, bezier);\n    } else if (r.bounds instanceof Rectangle && bezier) {\n      this.recordUndoSnapshot();\n      // Smoothing a rectangle: convert it to a 4-anchor closed polygon first.\n      const b = r.bounds;\n      const xs = [b.x, b.x + b.width, b.x + b.width, b.x];\n      const ys = [b.y, b.y, b.y + b.height, b.y + b.height];\n      const poly = new Polygon();\n      poly.npoints = 4;\n      poly.xpoints = xs;\n      poly.ypoints = ys;\n      poly.coordinates = xs.map((x, i) => [x, ys[i]]);\n      poly.closed = true;\n      this.applyBezier(poly, true);\n      r.bounds = poly;\n    } else {\n      return; // bezier=false on a rectangle: nothing to do\n    }\n    this.syncCache();\n    this.emit();\n  }\n\n  /** Turn bezier on (and seed editable handles from the smooth default) or off\n   *  (and drop the handles). */\n  private applyBezier(poly: Polygon, bezier: boolean): void {\n    poly.bezier = bezier;\n    if (bezier) {\n      const off = defaultHandleOffsets(poly.xpoints, poly.ypoints, poly.closed !== false);\n      poly.handlesIn = off.in;\n      poly.handlesOut = off.out;\n      this.seedHoleHandles(poly); // smooth the holes too (donut → bezier curves the holes)\n    } else {\n      poly.handlesIn = undefined;\n      poly.handlesOut = undefined;\n      poly.holeHandlesIn = undefined;\n      poly.holeHandlesOut = undefined;\n    }\n  }\n\n  /** (Re)seed per-hole bezier handles from the Catmull-Rom default, parallel to `poly.holes`. */\n  private seedHoleHandles(poly: Polygon): void {\n    if (!poly.holes || !poly.holes.length) {\n      poly.holeHandlesIn = undefined;\n      poly.holeHandlesOut = undefined;\n      return;\n    }\n    const ins: number[][][] = [];\n    const outs: number[][][] = [];\n    for (const ring of poly.holes) {\n      const off = defaultHandleOffsets(\n        ring.map((p) => p[0]),\n        ring.map((p) => p[1]),\n        true,\n      );\n      ins.push(off.in);\n      outs.push(off.out);\n    }\n    poly.holeHandlesIn = ins;\n    poly.holeHandlesOut = outs;\n  }\n\n  /** Drag a bezier control point on a hole ring vertex (donut bezier editing). */\n  moveHoleBezierHandle(\n    id: number,\n    holeIndex: number,\n    index: number,\n    side: 'in' | 'out',\n    x: number,\n    y: number,\n  ): void {\n    const poly = this.polygonOf(id);\n    if (!poly || !poly.bezier || !poly.holes || holeIndex < 0 || holeIndex >= poly.holes.length) {\n      return;\n    }\n    const ring = poly.holes[holeIndex];\n    if (index < 0 || index >= ring.length) return;\n    this.recordUndoSnapshot();\n    if (!poly.holeHandlesIn || !poly.holeHandlesOut) this.seedHoleHandles(poly);\n    const offset = [x - ring[index][0], y - ring[index][1]];\n    if (side === 'in') poly.holeHandlesIn![holeIndex][index] = offset;\n    else poly.holeHandlesOut![holeIndex][index] = offset;\n    this.syncCache();\n    this.emit();\n  }\n\n  moveBezierHandle(id: number, index: number, side: 'in' | 'out', x: number, y: number): void {\n    const poly = this.polygonOf(id);\n    if (!poly || !poly.bezier || index < 0 || index >= poly.xpoints.length) return;\n    this.recordUndoSnapshot();\n    if (!poly.handlesIn || !poly.handlesOut) {\n      const off = defaultHandleOffsets(poly.xpoints, poly.ypoints, poly.closed !== false);\n      poly.handlesIn = off.in;\n      poly.handlesOut = off.out;\n    }\n    const offset = [x - poly.xpoints[index], y - poly.ypoints[index]];\n    if (side === 'in') poly.handlesIn[index] = offset;\n    else poly.handlesOut[index] = offset;\n    this.syncCache();\n    this.emit();\n  }\n\n  beginBatch(): void { this.batchDepth++; }\n  endBatch(): void {\n    if (this.batchDepth > 0) this.batchDepth--;\n    if (this.batchDepth === 0 && this.pendingEmit) {\n      this.pendingEmit = false;\n      this.regionUpdate$.next(this.getRegions());\n    }\n  }\n\n  // ── per-image lifecycle ────────────────────────────────────────────────\n\n  /**\n   * Switch the active image: snapshot the outgoing regions, restore the\n   * incoming image's (or [] if none), clear selection, and notify. Idempotent\n   * for the same image (so repeated replots of one image keep its regions).\n   */\n  setActiveImage(imageInfo: IImageInfo): void {\n    const newKey = this.deriveImageKey(imageInfo);\n    if (this.currentImageKey === newKey) return;\n    // Switching images ends any per-slice stack session (jit-ui#93); the loader\n    // re-enters stack mode afterwards if the new image is itself a z-stack.\n    this.exitStackMode();\n    if (this.currentImageKey) {\n      this.regionsByImageKey.set(this.currentImageKey, this.regions.slice());\n    }\n    this.currentImageKey = newKey;\n    this.regions = (newKey && this.regionsByImageKey.get(newKey))\n      ? (this.regionsByImageKey.get(newKey) as Region[]).slice()\n      : [];\n    this.previousRegions = this.regions.slice();\n    this.selectedIds = [];\n    // Undo never crosses an image switch.\n    this.resetUndoHistory();\n    this.emitSelection();\n    this.regionUpdate$.next(this.getRegions());\n  }\n\n  /** Drop the entire per-image cache (logout / project switch). */\n  clearRegionsByImageKey(): void {\n    this.regionsByImageKey.clear();\n    this.currentImageKey = undefined;\n    this.regions = [];\n    this.selectedIds = [];\n    this.resetUndoHistory();\n  }\n\n  // ── internals ──────────────────────────────────────────────────────────\n\n  private deriveImageKey(imageInfo: IImageInfo | undefined): string | undefined {\n    if (!imageInfo) return undefined;\n    if (imageInfo.urls && imageInfo.urls.length > 0 && imageInfo.urls[0]) {\n      return imageInfo.urls[0];\n    }\n    return imageInfo.fileName || undefined;\n  }\n\n  /**\n   * Resolve each region's colour from the annotation-class preset set (jit-ui#70).\n   * The presets are the source of truth for colour — this **overrides any colour\n   * embedded in the GeoJSON** (which the YOLO worker writes today). A matching\n   * preset gives the class colour; an unknown class gets a deterministic fallback\n   * colour (and, only when `autoPromote` is on, is added to the editable list).\n   * Regions the user explicitly recoloured (`colorOverridden`) are left untouched.\n   */\n  private applyClassificationColors(regions: Region[]): void {\n    const set = this.store.getPresetSet();\n    const keyOf = (label: string) =>\n      set.matchMode === 'normalized' ? label.trim().toLowerCase() : label;\n    const known = new Set(set.classes.map((c) => keyOf(c.name)));\n    for (const region of regions) {\n      if (!region.label || region.colorOverridden) continue;\n      const preset = findPreset(region.label, set);\n      if (preset) {\n        region.color = preset.color;\n        continue;\n      }\n      const color = fallbackColorFor(region.label, set.fallbackPalette);\n      region.color = color;\n      if (set.autoPromote && !known.has(keyOf(region.label))) {\n        known.add(keyOf(region.label));\n        // In normalized mode, trim the promoted name so leading/trailing\n        // whitespace doesn't create invisible duplicates or odd display names.\n        const name = set.matchMode === 'normalized' ? region.label.trim() : region.label;\n        this.store.upsertClass({ name, color, source: 'auto' });\n      }\n    }\n  }\n\n  private syncCache(): void {\n    if (this.currentImageKey) {\n      this.regionsByImageKey.set(this.currentImageKey, this.regions.slice());\n    }\n  }\n\n  private emit(): void {\n    // Live-edit listeners (e.g. the intensity-profile inset) react on EVERY\n    // change — including per-frame during a batched drag — so they track the\n    // region live. The main regionUpdate$ stays coalesced during a batch (fires\n    // once on endBatch) to keep heavier consumers (Regions tab) calm.\n    this.regionLiveEdit$.next(this.regions.slice());\n    if (this.batchDepth > 0) { this.pendingEmit = true; return; }\n    this.regionUpdate$.next(this.getRegions());\n  }\n\n  /** Project selected ids to current array indices, pruning ids that no longer\n   *  exist, and emit if the index set changed. */\n  private emitSelection(): void {\n    const indices: number[] = [];\n    const liveIds: number[] = [];\n    for (const id of this.selectedIds) {\n      const idx = this.indexOfId(id);\n      if (idx >= 0) { indices.push(idx); liveIds.push(id); }\n    }\n    this.selectedIds = liveIds;\n    if (!this.indicesEqual(this.selectedIndices$.value, indices)) {\n      this.selectedIndices$.next(indices);\n    }\n  }\n\n  private indicesEqual(a: number[], b: number[]): boolean {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n    return true;\n  }\n\n  private findById(id: number): Region | undefined {\n    return this.regions.find(r => r.id === id);\n  }\n\n  private indexOfId(id: number): number {\n    return this.regions.findIndex(r => r.id === id);\n  }\n\n  /** The region's bounds as a Polygon, or undefined if it isn't a polygon. */\n  private polygonOf(id: number): Polygon | undefined {\n    const r = this.findById(id);\n    return r && r.bounds instanceof Polygon ? r.bounds : undefined;\n  }\n\n  private clonePolygon(p: Polygon): Polygon {\n    const poly = new Polygon();\n    poly.npoints = p.npoints;\n    poly.xpoints = p.xpoints.slice();\n    poly.ypoints = p.ypoints.slice();\n    poly.coordinates = p.coordinates.map(c => c.slice());\n    poly.closed = p.closed;\n    poly.bezier = p.bezier;\n    if (p.handlesIn) poly.handlesIn = p.handlesIn.map(o => o.slice());\n    if (p.handlesOut) poly.handlesOut = p.handlesOut.map(o => o.slice());\n    if (p.holes) poly.holes = p.holes.map(ring => ring.map(pt => pt.slice()));\n    if (p.holeHandlesIn) poly.holeHandlesIn = p.holeHandlesIn.map(r => r.map(o => o.slice()));\n    if (p.holeHandlesOut) poly.holeHandlesOut = p.holeHandlesOut.map(r => r.map(o => o.slice()));\n    return poly;\n  }\n\n  private cloneBounds(bounds: Rectangle | Polygon | MultiPolygon): Rectangle | Polygon | MultiPolygon {\n    if (bounds instanceof Rectangle) {\n      const rect = new Rectangle();\n      rect.x = bounds.x; rect.y = bounds.y; rect.width = bounds.width; rect.height = bounds.height;\n      return rect;\n    }\n    if (bounds instanceof MultiPolygon) {\n      const mp = new MultiPolygon();\n      mp.polygons = bounds.polygons.map(p => this.clonePolygon(p));\n      return mp;\n    }\n    return this.clonePolygon(bounds);\n  }\n\n  private regionsEqual(a: Region, b: Region): boolean {\n    const ba = a.bounds, bb = b.bounds;\n    if (ba instanceof Rectangle && bb instanceof Rectangle) {\n      return ba.x === bb.x && ba.y === bb.y && ba.width === bb.width && ba.height === bb.height;\n    }\n    if (ba instanceof MultiPolygon && bb instanceof MultiPolygon) {\n      if (ba.polygons.length !== bb.polygons.length) return false;\n      for (let i = 0; i < ba.polygons.length; i++) {\n        if (!this.polygonsEqual(ba.polygons[i], bb.polygons[i])) return false;\n      }\n      return true;\n    }\n    if (ba instanceof Polygon && bb instanceof Polygon) {\n      return this.polygonsEqual(ba, bb);\n    }\n    return false;\n  }\n\n  private polygonsEqual(pa: Polygon, pb: Polygon): boolean {\n    if ((pa.closed !== false) !== (pb.closed !== false)) return false;\n    if (pa.xpoints.length !== pb.xpoints.length) return false;\n    for (let i = 0; i < pa.xpoints.length; i++) {\n      if (pa.xpoints[i] !== pb.xpoints[i] || pa.ypoints[i] !== pb.ypoints[i]) return false;\n    }\n    return this.holesEqual(pa.holes, pb.holes);\n  }\n\n  /** Compare two polygons' interior-ring (hole) sets for the dedupe path. */\n  private holesEqual(a: number[][][] | undefined, b: number[][][] | undefined): boolean {\n    const na = a?.length ?? 0, nb = b?.length ?? 0;\n    if (na !== nb) return false;\n    for (let h = 0; h < na; h++) {\n      const ra = (a as number[][][])[h], rb = (b as number[][][])[h];\n      if (ra.length !== rb.length) return false;\n      for (let i = 0; i < ra.length; i++) {\n        if (ra[i][0] !== rb[i][0] || ra[i][1] !== rb[i][1]) return false;\n      }\n    }\n    return true;\n  }\n}\n"]}