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

package/esm2022/lib/implementations/osd/osd-region-overlay.mjs

@@ -0,0 +1,1237 @@
+import { OSD } from './osd-lib';
+import { Subscription } from 'rxjs';
+import { Region, Rectangle, Polygon, MultiPolygon } from '../../models/region';
+import { resolveHandles } from '../../models/bezier';
+import { elementToImage, imageToElement } from './osd-coords';
+const SVGNS = 'http://www.w3.org/2000/svg';
+const ZONE_CURSOR = {
+    move: 'move', n: 'ns-resize', s: 'ns-resize', e: 'ew-resize', w: 'ew-resize',
+    ne: 'nesw-resize', sw: 'nesw-resize', nw: 'nwse-resize', se: 'nwse-resize',
+};
+/** Screen-pixel tolerance for grabbing an edge/corner handle. */
+const EDIT_TOL = 8;
+/** Wheel zoom step per scroll tick — mirrors the viewer's `zoomPerScroll`. */
+const ZOOM_PER_SCROLL = 1.1;
+/**
+ * OpenSeadragon implementation of {@link IRegionOverlay}.
+ *
+ * - Renders the store's regions (rect/polygon) in image-pixel space, kept
+ *   aligned on every pan/zoom via the OSD viewport API.
+ * - Draws new rectangle and polygon regions (committed to the shared store).
+ * - Click-to-select in 'select' mode.
+ *
+ * Reads/writes the shared {@link IRegionStore}, so regions stay in sync with the
+ * Region Editor and the Plotly backend. The wand, vertex-eraser and zoom-to-box
+ * tools are NOT handled here — they're owned by OpenSeadragonVisualizerService
+ * (which binds them to OSD via the shared coordinate transform + viewport pixel
+ * readback), the same singleton tool services the Plotly backend uses.
+ */
+export class OsdRegionOverlay {
+    constructor(viewer, store) {
+        this.viewer = viewer;
+        this.store = store;
+        this.subs = new Subscription();
+        this.osd = OSD;
+        this.selected = [];
+        this.mode = 'none';
+        this.rectStart = null; // image coords
+        this.rectCurrent = null;
+        this.polyPoints = []; // image coords
+        /** True while dragging a freehand path (freeform / polyline). */
+        this.freehandDragging = false;
+        /** True while placing a click-to-add polygon ('drawpolygon' mode). */
+        this.drawingPolygon = false;
+        /** Last element-pixel point appended, to thin the freehand path. */
+        this.lastFreehandPx = null;
+        /**
+         * In-progress edit of the selected region:
+         *  - kind 'bounds' — rectangle resize/move or whole-region move (uses `zone`);
+         *  - kind 'vertex' — dragging a single polygon vertex (uses `vertexIndex`).
+         */
+        this.edit = null;
+        this.editDragged = false;
+        /** Rubber-band (marquee) multi-select in 'select' mode: press on empty space
+         *  and drag to select every region the band intersects. Image coords. */
+        this.bandStart = null;
+        this.bandCurrent = null;
+        this.bandDragged = false;
+        this.redrawHandler = () => this.redraw();
+        /** Drive OSD zoom from the wheel while any tool owns the pointer.
+         *
+         * OSD's native scroll-zoom is part of mouse-nav, so `setMouseNavEnabled(false)`
+         * (used by every region tool and by the wand/brush/eraser/SAM tools) disables
+         * it. The covering-canvas tools also sit above the OSD canvas and swallow the
+         * wheel outright. This listener is bound once to the viewer element — an
+         * ancestor of both the OSD canvas and the tool overlays — and forwards the
+         * wheel to a cursor-centred zoom whenever mouse-nav is off. When nav is on (no
+         * tool active) it does nothing and OSD zooms natively. (jit-ui#94) */
+        this.wheelZoomHandler = (e) => {
+            const vp = this.viewer?.viewport;
+            const el = this.viewer?.element;
+            // Nav on → no tool active → let OSD handle scroll-zoom natively.
+            if (!vp || !el || e.deltaY === 0 || this.viewer.isMouseNavEnabled())
+                return;
+            e.preventDefault();
+            const rect = el.getBoundingClientRect();
+            const refPoint = vp.pointFromPixel(new this.osd.Point(e.clientX - rect.left, e.clientY - rect.top));
+            vp.zoomBy(e.deltaY < 0 ? ZOOM_PER_SCROLL : 1 / ZOOM_PER_SCROLL, refPoint);
+            vp.applyConstraints();
+        };
+        this.svg = document.createElementNS(SVGNS, 'svg');
+        Object.assign(this.svg.style, {
+            position: 'absolute', left: '0', top: '0', width: '100%', height: '100%',
+            pointerEvents: 'none', // OSD handles navigation unless we're drawing
+        });
+        this.viewer.canvas.appendChild(this.svg);
+        this.viewer.addHandler('update-viewport', this.redrawHandler);
+        this.viewer.addHandler('animation', this.redrawHandler);
+        this.viewer.addHandler('resize', this.redrawHandler);
+        this.viewer.addHandler('rotate', this.redrawHandler);
+        // Keep wheel-zoom alive while a tool has mouse-nav disabled (see handler).
+        this.viewer.element
+            ?.addEventListener('wheel', this.wheelZoomHandler, { passive: false });
+        this.tracker = new this.osd.MouseTracker({
+            element: this.viewer.canvas,
+            pressHandler: (e) => this.onPress(e),
+            dragHandler: (e) => this.onDrag(e),
+            releaseHandler: (e) => this.onRelease(e),
+            clickHandler: (e) => this.onClick(e),
+            moveHandler: (e) => this.onMove(e),
+        });
+        this.tracker.setTracking(false);
+        this.subs.add(this.store.getRegionUpdateEvent().subscribe(this.redrawHandler));
+        this.subs.add(this.store.getSelectedShapeIndices$().subscribe(idx => {
+            this.selected = idx || [];
+            this.redraw();
+        }));
+        this.redraw();
+    }
+    /** Switch drawing/selection mode; toggles OSD navigation accordingly. */
+    setMode(mode) {
+        this.mode = mode;
+        this.resetInProgress();
+        // Any active region tool takes over the pointer — OSD pan/zoom is disabled
+        // so dragging draws (and clicks select) instead of panning. With no tool,
+        // OSD navigates normally.
+        this.viewer.setMouseNavEnabled(mode === 'none');
+        this.tracker.setTracking(mode !== 'none');
+        this.updateCursor(false);
+        this.redraw();
+    }
+    /** Cursor feedback per mode (crosshair while drawing; pointer over a region
+     *  in select mode). */
+    updateCursor(overRegion) {
+        const canvas = this.viewer.canvas;
+        if (this.mode === 'drawrect' || this.mode === 'drawclosedpath' || this.mode === 'drawopenpath'
+            || this.mode === 'drawpolygon' || this.mode === 'addpoint' || this.mode === 'deletepoint') {
+            canvas.style.cursor = 'crosshair';
+        }
+        else if (this.mode === 'move') {
+            canvas.style.cursor = 'move';
+        }
+        else if (this.mode === 'select') {
+            canvas.style.cursor = overRegion ? 'pointer' : 'default';
+        }
+        else {
+            canvas.style.cursor = ''; // OSD default (grab)
+        }
+    }
+    /** Whether the selected region's vertices/handles should be drawn. Shown
+     *  whenever a region is selected — including `none` (display) mode and while
+     *  another tool (wand, brush, SAM…) is active — so a selection always reveals
+     *  its vertices. Suppressed only while actively drawing a brand-new shape,
+     *  where stray handles would be noise. */
+    get showsSelectedVertices() {
+        return this.mode !== 'drawrect' && this.mode !== 'drawpolygon'
+            && this.mode !== 'drawclosedpath' && this.mode !== 'drawopenpath';
+    }
+    destroy() {
+        this.subs.unsubscribe();
+        this.viewer.element
+            ?.removeEventListener('wheel', this.wheelZoomHandler);
+        this.viewer.removeHandler('update-viewport', this.redrawHandler);
+        this.viewer.removeHandler('animation', this.redrawHandler);
+        this.viewer.removeHandler('resize', this.redrawHandler);
+        this.viewer.removeHandler('rotate', this.redrawHandler);
+        if (this.tracker)
+            this.tracker.destroy();
+        if (this.svg.parentNode)
+            this.svg.parentNode.removeChild(this.svg);
+    }
+    // ── coordinate helpers ───────────────────────────────────────────────
+    /** Image-pixel point -> element pixel point. */
+    toPx(imgX, imgY) {
+        return imageToElement(this.viewer, imgX, imgY);
+    }
+    /** Element pixel point (from a MouseTracker event) -> image-pixel point. */
+    toImage(pos) {
+        const p = elementToImage(this.viewer, pos.x, pos.y);
+        return { x: Math.round(p.x), y: Math.round(p.y) };
+    }
+    // ── rendering ────────────────────────────────────────────────────────
+    redraw() {
+        while (this.svg.firstChild)
+            this.svg.removeChild(this.svg.firstChild);
+        const regions = this.store.getRegions();
+        regions.forEach((r, i) => {
+            const el = this.buildRegionEl(r, this.selected.includes(i));
+            if (el)
+                this.svg.appendChild(el);
+        });
+        // Handles on the selected polygon, so the user can grab/insert/delete
+        // vertices. Bezier regions also get their cubic
+        // control handles (tangent lines + control points), mirroring paper.js's
+        // fullySelected rendering.
+        if (this.showsSelectedVertices) {
+            const sel = this.selectedRegionInfo();
+            const b = sel?.region.bounds;
+            // Handles/vertices take the region's own colour (not the global shape
+            // colour) so they match the shape they belong to.
+            const color = sel ? sel.region.color || this.store.getShapeColor() : '';
+            if (b instanceof Polygon) {
+                if (b.bezier) {
+                    this.drawBezierHandles(b, color);
+                }
+                else {
+                    for (let i = 0; i < b.xpoints.length; i++) {
+                        const q = this.toPx(b.xpoints[i], b.ypoints[i]);
+                        this.svg.appendChild(this.vertexMarker(q.x, q.y, false, color));
+                    }
+                    // Interior-ring (hole) vertices too, so a donut's inner outline shows
+                    // its vertices when selected (jit-ui#85).
+                    if (b.holes) {
+                        for (const ring of b.holes) {
+                            for (const [hx, hy] of ring) {
+                                const q = this.toPx(hx, hy);
+                                this.svg.appendChild(this.vertexMarker(q.x, q.y, false, color));
+                            }
+                        }
+                    }
+                }
+            }
+            else if (b instanceof Rectangle) {
+                // The four corners as grab/resize handles.
+                const corners = [
+                    [b.x, b.y], [b.x + b.width, b.y],
+                    [b.x + b.width, b.y + b.height], [b.x, b.y + b.height],
+                ];
+                for (const [cx, cy] of corners) {
+                    const q = this.toPx(cx, cy);
+                    this.svg.appendChild(this.vertexMarker(q.x, q.y, false, color));
+                }
+            }
+        }
+        // Rubber-band (marquee) selection preview.
+        if (this.mode === 'select' && this.bandStart && this.bandCurrent) {
+            this.svg.appendChild(this.selectionBand(this.bandStart, this.bandCurrent));
+        }
+        // In-progress drawing preview.
+        if (this.mode === 'drawrect' && this.rectStart && this.rectCurrent) {
+            this.svg.appendChild(this.rectPreview(this.rectStart, this.rectCurrent));
+        }
+        if ((this.mode === 'drawclosedpath' || this.mode === 'drawopenpath') && this.polyPoints.length) {
+            this.svg.appendChild(this.polyPreview(this.polyPoints));
+        }
+        // Click-to-place polygon preview: the polyline so far + a marker on the
+        // first vertex (click it to close).
+        if (this.mode === 'drawpolygon' && this.polyPoints.length) {
+            this.svg.appendChild(this.polyPreview(this.polyPoints));
+            const f = this.toPx(this.polyPoints[0].x, this.polyPoints[0].y);
+            this.svg.appendChild(this.vertexMarker(f.x, f.y, true));
+        }
+    }
+    /** A small vertex handle (filled for an emphasised marker, hollow otherwise).
+     *  Colour defaults to the global shape colour (used by the in-progress draw
+     *  preview); selected-region handles pass the region's own colour. */
+    vertexMarker(x, y, emphasised, color = this.store.getShapeColor()) {
+        const c = document.createElementNS(SVGNS, 'circle');
+        c.setAttribute('cx', `${x}`);
+        c.setAttribute('cy', `${y}`);
+        c.setAttribute('r', emphasised ? '5' : '4');
+        c.setAttribute('fill', emphasised ? color : '#ffffff');
+        c.setAttribute('stroke', color);
+        c.setAttribute('stroke-width', '2');
+        return c;
+    }
+    buildRegionEl(region, selected) {
+        const color = region.color || this.store.getShapeColor();
+        const bounds = region.bounds;
+        let pts = null;
+        let closed = true;
+        let el = null;
+        if (bounds instanceof MultiPolygon) {
+            // Multi-part region (jit-ui#85): one even-odd <path> with every part's
+            // exterior plus its holes. All parts' vertices drive the label bbox.
+            const parts = bounds.polygons.filter((p) => (p.xpoints?.length ?? 0) >= 3);
+            if (parts.length === 0)
+                return null;
+            pts = [];
+            let d = '';
+            for (const part of parts) {
+                const ext = part.xpoints.map((x, i) => ({ x, y: part.ypoints[i] }));
+                pts.push(...ext);
+                d += (d ? ' ' : '') + this.straightPathD(ext, true);
+                if (part.holes) {
+                    for (const ring of part.holes) {
+                        d += ' ' + this.straightPathD(ring.map(([x, y]) => ({ x, y })), true);
+                    }
+                }
+            }
+            el = document.createElementNS(SVGNS, 'path');
+            el.setAttribute('d', d);
+            el.setAttribute('fill-rule', 'evenodd');
+        }
+        else if (bounds instanceof Rectangle) {
+            pts = [
+                { x: bounds.x, y: bounds.y },
+                { x: bounds.x + bounds.width, y: bounds.y },
+                { x: bounds.x + bounds.width, y: bounds.y + bounds.height },
+                { x: bounds.x, y: bounds.y + bounds.height },
+            ];
+        }
+        else if (bounds instanceof Polygon) {
+            closed = bounds.closed !== false;
+            // The anchors drive the label bbox and (for non-bezier) the rendered shape.
+            pts = bounds.xpoints.map((x, i) => ({ x, y: bounds.ypoints[i] }));
+        }
+        if (!pts || pts.length === 0)
+            return null;
+        if (!el) {
+            // Bezier regions render as a true cubic-bezier path through the anchors
+            // (paper.js-equivalent smooth curve); everything else as a straight
+            // polygon/polyline.
+            const isBezier = bounds instanceof Polygon && bounds.bezier && pts.length >= 2;
+            // Interior rings (holes) — punch through with even-odd fill (jit-ui#85).
+            const holes = (closed && bounds instanceof Polygon && bounds.holes?.length)
+                ? bounds.holes : null;
+            if (isBezier || holes) {
+                el = document.createElementNS(SVGNS, 'path');
+                // Exterior subpath (smooth for bezier, straight otherwise) followed by a
+                // straight subpath per hole.
+                let d = isBezier ? this.bezierPathD(bounds) : this.straightPathD(pts, closed);
+                if (holes) {
+                    const poly = bounds;
+                    holes.forEach((ring, hi) => {
+                        const xs = ring.map((p) => p[0]);
+                        const ys = ring.map((p) => p[1]);
+                        // When the donut is a bezier, smooth its holes too (jit-ui#102) — using stored hole
+                        // handles when present, else the Catmull-Rom default (via resolveHandles).
+                        d +=
+                            ' ' +
+                                (isBezier
+                                    ? this.ringBezierPathD(xs, ys, poly.holeHandlesIn?.[hi], poly.holeHandlesOut?.[hi], true)
+                                    : this.straightPathD(ring.map(([x, y]) => ({ x, y })), true));
+                    });
+                    el.setAttribute('fill-rule', 'evenodd');
+                }
+                el.setAttribute('d', d);
+            }
+            else {
+                el = document.createElementNS(SVGNS, closed ? 'polygon' : 'polyline');
+                el.setAttribute('points', pts.map(p => { const q = this.toPx(p.x, p.y); return `${q.x},${q.y}`; }).join(' '));
+            }
+        }
+        el.setAttribute('fill', selected ? this.rgba(color, 0.35) : 'none');
+        el.setAttribute('stroke', color);
+        el.setAttribute('stroke-width', selected ? '4' : '2');
+        // The class label (legend), shown when the Region Editor's "show labels" is
+        // on — mirrors Plotly's per-shape label (top-left, drawn in the region's
+        // colour). Without this OSD showed regions with no label even though Plotly
+        // did. region.label is restored from the shape's legend in getRegion().
+        const label = region.label;
+        if (this.store.getShowShapeLabel() && label != null && `${label}`.length > 0) {
+            const g = document.createElementNS(SVGNS, 'g');
+            g.appendChild(el);
+            const minX = Math.min(...pts.map(p => p.x));
+            const minY = Math.min(...pts.map(p => p.y));
+            const q = this.toPx(minX, minY);
+            const text = document.createElementNS(SVGNS, 'text');
+            text.setAttribute('x', `${q.x}`);
+            text.setAttribute('y', `${q.y - 4}`); // just above the top-left corner
+            text.setAttribute('fill', color);
+            text.setAttribute('font-size', '13');
+            text.setAttribute('font-family', 'sans-serif');
+            // Dark halo so the label stays legible over both bright and dark tiles.
+            text.setAttribute('paint-order', 'stroke');
+            text.setAttribute('stroke', 'rgba(0,0,0,0.65)');
+            text.setAttribute('stroke-width', '2');
+            text.textContent = `${label}`;
+            g.appendChild(text);
+            return g;
+        }
+        return el;
+    }
+    /** Marquee rectangle for rubber-band multi-select (dashed outline + faint fill). */
+    selectionBand(a, b) {
+        const corners = [
+            { x: a.x, y: a.y }, { x: b.x, y: a.y }, { x: b.x, y: b.y }, { x: a.x, y: b.y },
+        ];
+        const el = document.createElementNS(SVGNS, 'polygon');
+        el.setAttribute('points', corners.map(p => { const q = this.toPx(p.x, p.y); return `${q.x},${q.y}`; }).join(' '));
+        el.setAttribute('fill', 'rgba(120,170,255,0.15)');
+        el.setAttribute('stroke', '#4a90e2');
+        el.setAttribute('stroke-dasharray', '4 3');
+        el.setAttribute('stroke-width', '1');
+        return el;
+    }
+    rectPreview(a, b) {
+        const corners = [
+            { x: a.x, y: a.y }, { x: b.x, y: a.y }, { x: b.x, y: b.y }, { x: a.x, y: b.y },
+        ];
+        const el = document.createElementNS(SVGNS, 'polygon');
+        el.setAttribute('points', corners.map(p => { const q = this.toPx(p.x, p.y); return `${q.x},${q.y}`; }).join(' '));
+        el.setAttribute('fill', 'none');
+        el.setAttribute('stroke', this.store.getShapeColor());
+        el.setAttribute('stroke-dasharray', '4 3');
+        el.setAttribute('stroke-width', '2');
+        return el;
+    }
+    polyPreview(pts) {
+        const el = document.createElementNS(SVGNS, 'polyline');
+        el.setAttribute('points', pts.map(p => { const q = this.toPx(p.x, p.y); return `${q.x},${q.y}`; }).join(' '));
+        el.setAttribute('fill', 'none');
+        el.setAttribute('stroke', this.store.getShapeColor());
+        el.setAttribute('stroke-dasharray', '4 3');
+        el.setAttribute('stroke-width', '2');
+        return el;
+    }
+    /** SVG path `d` (element-pixel coords) for a straight-edged ring/polyline. */
+    straightPathD(pts, closed) {
+        if (pts.length < 2)
+            return '';
+        let d = '';
+        pts.forEach((p, i) => {
+            const q = this.toPx(p.x, p.y);
+            d += (i === 0 ? 'M ' : ' L ') + `${q.x},${q.y}`;
+        });
+        if (closed)
+            d += ' Z';
+        return d;
+    }
+    /** SVG path `d` (element-pixel coords) for the smooth cubic bezier through a
+     *  polygon's anchors — the paper.js-equivalent curve. */
+    bezierPathD(poly) {
+        const closed = poly.closed !== false;
+        return this.ringBezierPathD(poly.xpoints, poly.ypoints, poly.handlesIn, poly.handlesOut, closed);
+    }
+    /** SVG cubic-bezier path `d` (element px) for any ring (exterior or hole). Uses the stored
+     *  per-vertex handle offsets when present, else the Catmull-Rom default (resolveHandles). */
+    ringBezierPathD(xs, ys, inOff, outOff, closed) {
+        const n = Math.min(xs.length, ys.length);
+        if (n < 2)
+            return '';
+        const h = resolveHandles(xs, ys, closed, inOff, outOff);
+        const px = (x, y) => { const q = this.toPx(x, y); return `${q.x},${q.y}`; };
+        let d = `M ${px(xs[0], ys[0])}`;
+        const segs = closed ? n : n - 1;
+        for (let i = 0; i < segs; i++) {
+            const j = (i + 1) % n;
+            const c1 = h[i].out;
+            const c2 = h[j].in;
+            d += ` C ${px(c1[0], c1[1])} ${px(c2[0], c2[1])} ${px(xs[j], ys[j])}`;
+        }
+        if (closed)
+            d += ' Z';
+        return d;
+    }
+    /**
+     * Draw the bezier editing handles for the selected region, paper.js-style:
+     * each anchor as a small square, with tangent lines out to its two control
+     * points (drawn as small circles).
+     */
+    drawBezierHandles(poly, color) {
+        const xs = poly.xpoints;
+        const ys = poly.ypoints;
+        const drawRing = (rxs, rys, inOff, outOff, closed) => {
+            const h = resolveHandles(rxs, rys, closed, inOff, outOff);
+            for (let i = 0; i < rxs.length; i++) {
+                const a = this.toPx(rxs[i], rys[i]);
+                if (h[i].hasIn)
+                    this.drawHandle(a, this.toPx(h[i].in[0], h[i].in[1]), color);
+                if (h[i].hasOut)
+                    this.drawHandle(a, this.toPx(h[i].out[0], h[i].out[1]), color);
+                this.svg.appendChild(this.anchorSquare(a.x, a.y, color));
+            }
+        };
+        drawRing(xs, ys, poly.handlesIn, poly.handlesOut, poly.closed !== false);
+        // Donut hole rings get their own editable bezier handles (jit-ui#102).
+        if (poly.holes && poly.holeHandlesIn && poly.holeHandlesOut) {
+            poly.holes.forEach((ring, hi) => {
+                const inOff = poly.holeHandlesIn[hi];
+                const outOff = poly.holeHandlesOut[hi];
+                if (inOff && outOff)
+                    drawRing(ring.map((p) => p[0]), ring.map((p) => p[1]), inOff, outOff, true);
+            });
+        }
+    }
+    /** A tangent line from an anchor to a control point, with a circle at the end. */
+    drawHandle(anchor, ctrl, color) {
+        const line = document.createElementNS(SVGNS, 'line');
+        line.setAttribute('x1', `${anchor.x}`);
+        line.setAttribute('y1', `${anchor.y}`);
+        line.setAttribute('x2', `${ctrl.x}`);
+        line.setAttribute('y2', `${ctrl.y}`);
+        line.setAttribute('stroke', color);
+        line.setAttribute('stroke-width', '1');
+        this.svg.appendChild(line);
+        const c = document.createElementNS(SVGNS, 'circle');
+        c.setAttribute('cx', `${ctrl.x}`);
+        c.setAttribute('cy', `${ctrl.y}`);
+        c.setAttribute('r', '3');
+        c.setAttribute('fill', color);
+        this.svg.appendChild(c);
+    }
+    /** A filled-white anchor square (the editable vertex). */
+    anchorSquare(x, y, color) {
+        const r = 3.5;
+        const rect = document.createElementNS(SVGNS, 'rect');
+        rect.setAttribute('x', `${x - r}`);
+        rect.setAttribute('y', `${y - r}`);
+        rect.setAttribute('width', `${2 * r}`);
+        rect.setAttribute('height', `${2 * r}`);
+        rect.setAttribute('fill', '#ffffff');
+        rect.setAttribute('stroke', color);
+        rect.setAttribute('stroke-width', '2');
+        return rect;
+    }
+    rgba(color, alpha) {
+        // Accept #rrggbb; fall back to the color as-is for named/rgb values.
+        if (/^#([0-9a-f]{6})$/i.test(color)) {
+            const r = parseInt(color.slice(1, 3), 16);
+            const g = parseInt(color.slice(3, 5), 16);
+            const b = parseInt(color.slice(5, 7), 16);
+            return `rgba(${r},${g},${b},${alpha})`;
+        }
+        return color;
+    }
+    // ── interaction ──────────────────────────────────────────────────────
+    get isFreehand() {
+        return this.mode === 'drawclosedpath' || this.mode === 'drawopenpath';
+    }
+    onPress(e) {
+        if (this.mode === 'drawrect') {
+            this.rectStart = this.toImage(e.position);
+            this.rectCurrent = this.rectStart;
+            return;
+        }
+        if (this.isFreehand) {
+            // Freehand draw (matches Plotly drawclosedpath/drawopenpath): press to
+            // start, drag to trace, release to commit.
+            this.freehandDragging = true;
+            this.polyPoints = [this.toImage(e.position)];
+            this.lastFreehandPx = { x: e.position.x, y: e.position.y };
+            return;
+        }
+        if (this.mode === 'move') {
+            // Whole-region drag ('move' mode): press inside the selected region
+            // to translate it, ignoring vertices/edges.
+            const sel = this.selectedRegionInfo();
+            if (sel && this.containsPoint(sel.region, this.toImage(e.position))) {
+                this.startEdit('bounds', 'move', -1, sel.region, this.toImage(e.position));
+            }
+            return;
+        }
+        if (this.mode === 'select') {
+            // A bezier control handle takes top priority (it sits off the anchor).
+            const hh = this.hitBezierHandle(e.position);
+            if (hh) {
+                const region = this.store.getRegions()[this.selected[this.selected.length - 1]];
+                this.startEdit('handle', 'move', hh.index, region, this.toImage(e.position), hh.side, hh.ring);
+                return;
+            }
+            // Then dragging a single polygon vertex (over body-move/resize) —
+            // 'select' grabs the nearest segment first.
+            const vh = this.hitVertex(e.position);
+            if (vh) {
+                const region = this.store.getRegions()[this.selected[this.selected.length - 1]];
+                this.startEdit('vertex', 'move', vh.index, region, this.toImage(e.position), 'out', vh.ring);
+                return;
+            }
+            // Otherwise start a move/resize when pressing the selected region's
+            // body/handles.
+            const ez = this.editZoneAt(e.position);
+            if (ez) {
+                this.startEdit('bounds', ez.zone, -1, this.store.getRegions()[ez.index], this.toImage(e.position));
+                return;
+            }
+            // Press on empty space / a non-selected region: begin a rubber-band
+            // multi-select. A plain click (no drag) falls through to onClick, which
+            // single-selects or clears.
+            this.bandStart = this.toImage(e.position);
+            this.bandCurrent = this.bandStart;
+            this.bandDragged = false;
+        }
+    }
+    /** Begin an edit gesture (move/resize or single-vertex drag) and open a store
+     *  batch so the live drag emits once on release. */
+    startEdit(kind, zone, vertexIndex, region, startImg, handleSide = 'out', ring = -1) {
+        this.edit = {
+            kind, zone, vertexIndex, ring, handleSide, id: region.id,
+            startImg, orig: kind === 'bounds' ? this.snapshot(region) : null,
+        };
+        this.editDragged = false;
+        this.store.beginBatch();
+    }
+    onDrag(e) {
+        if (this.mode === 'drawrect' && this.rectStart) {
+            this.rectCurrent = this.toImage(e.position);
+            this.redraw();
+            return;
+        }
+        if (this.freehandDragging && this.isFreehand) {
+            // Thin the path: only sample once the cursor has moved a few screen px.
+            const last = this.lastFreehandPx;
+            if (!last || Math.hypot(e.position.x - last.x, e.position.y - last.y) >= 4) {
+                this.polyPoints.push(this.toImage(e.position));
+                this.lastFreehandPx = { x: e.position.x, y: e.position.y };
+                this.redraw();
+            }
+            return;
+        }
+        if (this.edit) {
+            this.editDragged = true;
+            this.applyEdit(this.toImage(e.position));
+            return;
+        }
+        if (this.bandStart) {
+            this.bandCurrent = this.toImage(e.position);
+            this.bandDragged = true;
+            this.redraw();
+        }
+    }
+    onRelease(e) {
+        if (this.mode === 'drawrect' && this.rectStart) {
+            const end = this.toImage(e.position);
+            const x = Math.min(this.rectStart.x, end.x);
+            const y = Math.min(this.rectStart.y, end.y);
+            const w = Math.abs(end.x - this.rectStart.x);
+            const h = Math.abs(end.y - this.rectStart.y);
+            this.rectStart = this.rectCurrent = null;
+            if (w > 2 && h > 2)
+                this.commitRectangle(x, y, w, h);
+            return;
+        }
+        if (this.freehandDragging) {
+            this.freehandDragging = false;
+            this.lastFreehandPx = null;
+            // Closed = freeform (drawclosedpath); open = polyline (drawopenpath).
+            this.commitPolygon(this.mode === 'drawclosedpath');
+            return;
+        }
+        // Move/resize already applied live; flush the coalesced edits + end the
+        // gesture (keep selection).
+        if (this.edit) {
+            this.store.endBatch();
+            this.edit = null;
+            return;
+        }
+        // Finish a rubber-band selection: select every region the band intersects.
+        if (this.bandStart) {
+            const start = this.bandStart;
+            const end = this.bandCurrent ?? start;
+            this.bandStart = this.bandCurrent = null;
+            const x0 = Math.min(start.x, end.x), y0 = Math.min(start.y, end.y);
+            const x1 = Math.max(start.x, end.x), y1 = Math.max(start.y, end.y);
+            // Only a real drag selects; a click-sized band falls through to onClick.
+            if (this.bandDragged && (x1 - x0 > 2 || y1 - y0 > 2)) {
+                this.store.setSelectedShapeIndices(this.regionsInRect(x0, y0, x1, y1));
+            }
+            this.redraw();
+        }
+    }
+    onClick(e) {
+        if (this.mode === 'select') {
+            // A move/resize/vertex drag or a rubber-band drag also ends with a click
+            // event — don't treat it as a re-selection.
+            if (this.editDragged) {
+                this.editDragged = false;
+                return;
+            }
+            if (this.bandDragged) {
+                this.bandDragged = false;
+                return;
+            }
+            // Shift (or Cmd/Ctrl) toggles the clicked region in/out of the current
+            // selection; a plain click replaces it.
+            const oe = e.originalEvent;
+            const additive = !!oe && (oe.shiftKey || oe.metaKey || oe.ctrlKey);
+            this.selectAt(this.toImage(e.position), additive);
+            return;
+        }
+        if (this.mode === 'drawpolygon') {
+            this.onDrawPolygonClick(e);
+            return;
+        }
+        if (this.mode === 'addpoint') {
+            // Insert a vertex on the clicked edge — exterior or an interior ring.
+            const sel = this.selectedRegionInfo();
+            const edge = sel ? this.hitEdge(e.position, sel.region) : null;
+            if (sel && edge) {
+                if (edge.ring < 0)
+                    this.store.addVertex(sel.region.id, edge.segIndex, edge.x, edge.y);
+                else
+                    this.store.addHoleVertex(sel.region.id, edge.ring, edge.segIndex, edge.x, edge.y);
+            }
+            return;
+        }
+        if (this.mode === 'deletepoint') {
+            // Remove the clicked vertex — exterior or an interior ring (jit-ui#85).
+            const vh = this.hitVertex(e.position);
+            if (vh) {
+                if (vh.ring < 0)
+                    this.store.deleteVertex(vh.id, vh.index);
+                else
+                    this.store.deleteHoleVertex(vh.id, vh.ring, vh.index);
+            }
+            return;
+        }
+    }
+    /**
+     * Click-to-place polygon ('drawpolygon'): the first click starts the
+     * polygon, each subsequent click adds a vertex, and clicking near the first
+     * vertex (with at least 3 placed) closes and commits it.
+     */
+    onDrawPolygonClick(e) {
+        const pt = this.toImage(e.position);
+        if (!this.drawingPolygon) {
+            this.polyPoints = [pt];
+            this.drawingPolygon = true;
+            this.redraw();
+            return;
+        }
+        const first = this.toPx(this.polyPoints[0].x, this.polyPoints[0].y);
+        const onFirst = Math.hypot(e.position.x - first.x, e.position.y - first.y) <= EDIT_TOL;
+        if (onFirst && this.polyPoints.length >= 3) {
+            this.commitPolygon(true); // closes + resets in-progress (incl. drawingPolygon)
+            return;
+        }
+        this.polyPoints.push(pt);
+        this.redraw();
+    }
+    /**
+     * Hover feedback in select mode: move/resize cursors over the selected
+     * region's body/edges/corners, a pointer over any other region.
+     */
+    onMove(e) {
+        if (this.mode !== 'select')
+            return;
+        // A grabbable bezier control handle or vertex of the selected polygon takes
+        // priority.
+        if (this.hitBezierHandle(e.position) || this.hitVertex(e.position)) {
+            this.viewer.canvas.style.cursor = 'pointer';
+            return;
+        }
+        const ez = this.editZoneAt(e.position);
+        if (ez) {
+            this.viewer.canvas.style.cursor = ZONE_CURSOR[ez.zone];
+            return;
+        }
+        this.updateCursor(this.regionIndexAt(this.toImage(e.position)) >= 0);
+    }
+    /**
+     * The move/resize zone under the cursor for the currently-selected region
+     * (rectangles get edge/corner handles + body; polygons get body-move only),
+     * or null if the cursor isn't over the selected region.
+     */
+    editZoneAt(position) {
+        if (this.selected.length === 0)
+            return null;
+        const index = this.selected[this.selected.length - 1];
+        const region = this.store.getRegions()[index];
+        if (!region)
+            return null;
+        const b = region.bounds;
+        if (b instanceof Rectangle) {
+            const a = this.toPx(b.x, b.y);
+            const c = this.toPx(b.x + b.width, b.y + b.height);
+            const zone = this.rectZone(position.x, position.y, Math.min(a.x, c.x), Math.min(a.y, c.y), Math.max(a.x, c.x), Math.max(a.y, c.y));
+            return zone ? { zone, index } : null;
+        }
+        if (b instanceof Polygon || b instanceof MultiPolygon) {
+            // Polygons + multi-part regions support whole-region move (no resize zones).
+            return this.containsPoint(region, this.toImage(position)) ? { zone: 'move', index } : null;
+        }
+        return null;
+    }
+    /** The currently-selected region (the last one selected), or null. */
+    selectedRegionInfo() {
+        if (this.selected.length === 0)
+            return null;
+        const index = this.selected[this.selected.length - 1];
+        const region = this.store.getRegions()[index];
+        return region ? { region, index } : null;
+    }
+    /** The vertex of the selected polygon under the cursor (screen-pixel
+     *  tolerance), or null. Rectangles have no editable vertices. */
+    hitVertex(position) {
+        const sel = this.selectedRegionInfo();
+        if (!sel || !(sel.region.bounds instanceof Polygon))
+            return null;
+        const b = sel.region.bounds;
+        for (let i = 0; i < b.xpoints.length; i++) {
+            const q = this.toPx(b.xpoints[i], b.ypoints[i]);
+            if (Math.hypot(position.x - q.x, position.y - q.y) <= EDIT_TOL) {
+                return { id: sel.region.id, ring: -1, index: i };
+            }
+        }
+        // Interior-ring (hole) vertices are draggable too (jit-ui#85).
+        if (b.holes) {
+            for (let h = 0; h < b.holes.length; h++) {
+                const ring = b.holes[h];
+                for (let i = 0; i < ring.length; i++) {
+                    const q = this.toPx(ring[i][0], ring[i][1]);
+                    if (Math.hypot(position.x - q.x, position.y - q.y) <= EDIT_TOL) {
+                        return { id: sel.region.id, ring: h, index: i };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /** The bezier control handle of the selected region under the cursor (which
+     *  anchor, and whether the in- or out-handle), or null. */
+    hitBezierHandle(position) {
+        const sel = this.selectedRegionInfo();
+        if (!sel || !(sel.region.bounds instanceof Polygon) || !sel.region.bounds.bezier)
+            return null;
+        const b = sel.region.bounds;
+        // Test one ring's control handles; returns the matched vertex/side or null.
+        const testRing = (xs, ys, inOff, outOff, closed, ring) => {
+            const h = resolveHandles(xs, ys, closed, inOff, outOff);
+            for (let i = 0; i < h.length; i++) {
+                if (h[i].hasOut) {
+                    const q = this.toPx(h[i].out[0], h[i].out[1]);
+                    if (Math.hypot(position.x - q.x, position.y - q.y) <= EDIT_TOL) {
+                        return { id: sel.region.id, index: i, side: 'out', ring };
+                    }
+                }
+                if (h[i].hasIn) {
+                    const q = this.toPx(h[i].in[0], h[i].in[1]);
+                    if (Math.hypot(position.x - q.x, position.y - q.y) <= EDIT_TOL) {
+                        return { id: sel.region.id, index: i, side: 'in', ring };
+                    }
+                }
+            }
+            return null;
+        };
+        const ext = testRing(b.xpoints, b.ypoints, b.handlesIn, b.handlesOut, b.closed !== false, -1);
+        if (ext)
+            return ext;
+        // Donut hole rings (jit-ui#102): their own bezier control handles.
+        if (b.holes && b.holeHandlesIn && b.holeHandlesOut) {
+            for (let hi = 0; hi < b.holes.length; hi++) {
+                const ring = b.holes[hi];
+                const hit = testRing(ring.map((p) => p[0]), ring.map((p) => p[1]), b.holeHandlesIn[hi], b.holeHandlesOut[hi], true, hi);
+                if (hit)
+                    return hit;
+            }
+        }
+        return null;
+    }
+    /** The edge of `region`'s polygon nearest the cursor (within tolerance), with
+     *  the clicked point in image coords as the insertion position, or null. */
+    hitEdge(position, region) {
+        if (!(region.bounds instanceof Polygon))
+            return null;
+        const b = region.bounds;
+        let best = -1, bestRing = -1, bestDist = Infinity;
+        // Nearest edge across the exterior (ring -1) and every interior ring (hole).
+        const scan = (xs, ys, ring, closed) => {
+            const n = xs.length;
+            const segCount = closed ? n : n - 1; // closed wraps the last->first edge
+            for (let i = 0; i < segCount; i++) {
+                const j = (i + 1) % n;
+                const a = this.toPx(xs[i], ys[i]);
+                const c = this.toPx(xs[j], ys[j]);
+                const d = this.distToSegmentPx(position, a, c);
+                if (d < bestDist) {
+                    bestDist = d;
+                    best = i;
+                    bestRing = ring;
+                }
+            }
+        };
+        scan(b.xpoints, b.ypoints, -1, b.closed !== false);
+        if (b.holes) {
+            b.holes.forEach((r, h) => scan(r.map(p => p[0]), r.map(p => p[1]), h, true));
+        }
+        if (best < 0 || bestDist > EDIT_TOL)
+            return null;
+        const img = this.toImage(position);
+        return { ring: bestRing, segIndex: best, x: img.x, y: img.y };
+    }
+    /** Classify a screen point against a screen-space rectangle into a zone. */
+    rectZone(px, py, x0, y0, x1, y1) {
+        const t = EDIT_TOL;
+        if (px < x0 - t || px > x1 + t || py < y0 - t || py > y1 + t)
+            return null;
+        const left = Math.abs(px - x0) <= t, right = Math.abs(px - x1) <= t;
+        const top = Math.abs(py - y0) <= t, bottom = Math.abs(py - y1) <= t;
+        if (top && left)
+            return 'nw';
+        if (top && right)
+            return 'ne';
+        if (bottom && left)
+            return 'sw';
+        if (bottom && right)
+            return 'se';
+        if (left)
+            return 'w';
+        if (right)
+            return 'e';
+        if (top)
+            return 'n';
+        if (bottom)
+            return 's';
+        if (px > x0 && px < x1 && py > y0 && py < y1)
+            return 'move';
+        return null;
+    }
+    /** Snapshot the selected region's geometry at the start of an edit. */
+    snapshot(region) {
+        const b = region.bounds;
+        if (b instanceof Rectangle)
+            return { kind: 'rect', x: b.x, y: b.y, w: b.width, h: b.height };
+        if (b instanceof Polygon) {
+            return {
+                kind: 'poly', xs: b.xpoints.slice(), ys: b.ypoints.slice(), closed: b.closed !== false,
+                bezier: b.bezier,
+                inOff: b.handlesIn?.map(o => o.slice()),
+                outOff: b.handlesOut?.map(o => o.slice()),
+                holes: b.holes?.map(ring => ring.map(pt => pt.slice())),
+            };
+        }
+        if (b instanceof MultiPolygon) {
+            return {
+                kind: 'multi',
+                polygons: b.polygons.map((p) => ({
+                    xs: p.xpoints.slice(), ys: p.ypoints.slice(), closed: p.closed !== false,
+                    holes: p.holes?.map(ring => ring.map(pt => pt.slice())),
+                })),
+            };
+        }
+        return { kind: 'rect', x: 0, y: 0, w: 0, h: 0 };
+    }
+    /**
+     * Apply the in-progress move/resize to the region, live, through the
+     * Region-native edit API. Recomputed absolutely from the gesture-start
+     * snapshot (`orig`) + the total delta, so each frame is idempotent.
+     */
+    applyEdit(curImg) {
+        if (!this.edit)
+            return;
+        if (this.edit.kind === 'vertex') {
+            // Drag a single vertex to the cursor (absolute — idempotent). Route to the
+            // exterior or the matching interior ring (hole) — jit-ui#85.
+            if (this.edit.ring < 0) {
+                this.store.moveVertex(this.edit.id, this.edit.vertexIndex, curImg.x, curImg.y);
+            }
+            else {
+                this.store.moveHoleVertex(this.edit.id, this.edit.ring, this.edit.vertexIndex, curImg.x, curImg.y);
+            }
+            this.redraw();
+            return;
+        }
+        if (this.edit.kind === 'handle') {
+            // Drag a bezier control handle to the cursor — exterior (ring -1) or a donut hole ring.
+            if (this.edit.ring < 0) {
+                this.store.moveBezierHandle(this.edit.id, this.edit.vertexIndex, this.edit.handleSide, curImg.x, curImg.y);
+            }
+            else {
+                this.store.moveHoleBezierHandle(this.edit.id, this.edit.ring, this.edit.vertexIndex, this.edit.handleSide, curImg.x, curImg.y);
+            }
+            this.redraw();
+            return;
+        }
+        const dx = curImg.x - this.edit.startImg.x;
+        const dy = curImg.y - this.edit.startImg.y;
+        const o = this.edit.orig;
+        if (o.kind === 'rect') {
+            let x0 = o.x, y0 = o.y, x1 = o.x + o.w, y1 = o.y + o.h;
+            switch (this.edit.zone) {
+                case 'move':
+                    x0 += dx;
+                    x1 += dx;
+                    y0 += dy;
+                    y1 += dy;
+                    break;
+                case 'w':
+                    x0 += dx;
+                    break;
+                case 'e':
+                    x1 += dx;
+                    break;
+                case 'n':
+                    y0 += dy;
+                    break;
+                case 's':
+                    y1 += dy;
+                    break;
+                case 'nw':
+                    x0 += dx;
+                    y0 += dy;
+                    break;
+                case 'ne':
+                    x1 += dx;
+                    y0 += dy;
+                    break;
+                case 'sw':
+                    x0 += dx;
+                    y1 += dy;
+                    break;
+                case 'se':
+                    x1 += dx;
+                    y1 += dy;
+                    break;
+            }
+            const rect = new Rectangle();
+            rect.x = Math.round(Math.min(x0, x1));
+            rect.y = Math.round(Math.min(y0, y1));
+            rect.width = Math.round(Math.abs(x1 - x0));
+            rect.height = Math.round(Math.abs(y1 - y0));
+            this.store.updateBounds(this.edit.id, rect);
+        }
+        else if (o.kind === 'multi') {
+            // Multi-part region: translate every part (and its holes) by the delta.
+            const mp = new MultiPolygon();
+            mp.polygons = o.polygons.map((pp) => {
+                const xs = pp.xs.map((x) => Math.round(x + dx));
+                const ys = pp.ys.map((y) => Math.round(y + dy));
+                const poly = new Polygon();
+                poly.npoints = xs.length;
+                poly.xpoints = xs;
+                poly.ypoints = ys;
+                poly.coordinates = xs.map((x, i) => [x, ys[i]]);
+                poly.closed = pp.closed;
+                if (pp.holes) {
+                    poly.holes = pp.holes.map((ring) => ring.map(([x, y]) => [Math.round(x + dx), Math.round(y + dy)]));
+                }
+                return poly;
+            });
+            this.store.updateBounds(this.edit.id, mp);
+        }
+        else {
+            // Polygon: translate every vertex (the only polygon edit zone is 'move').
+            // Bezier flag + handle offsets are relative, so they carry over unchanged.
+            const xs = o.xs.map((x) => Math.round(x + dx));
+            const ys = o.ys.map((y) => Math.round(y + dy));
+            const poly = new Polygon();
+            poly.npoints = xs.length;
+            poly.xpoints = xs;
+            poly.ypoints = ys;
+            poly.coordinates = xs.map((x, i) => [x, ys[i]]);
+            poly.closed = o.closed;
+            poly.bezier = o.bezier;
+            if (o.inOff)
+                poly.handlesIn = o.inOff.map((off) => off.slice());
+            if (o.outOff)
+                poly.handlesOut = o.outOff.map((off) => off.slice());
+            // Translate interior rings (holes) with the exterior (jit-ui#85).
+            if (o.holes) {
+                poly.holes = o.holes.map((ring) => ring.map(([x, y]) => [Math.round(x + dx), Math.round(y + dy)]));
+            }
+            this.store.updateBounds(this.edit.id, poly);
+        }
+        this.redraw();
+    }
+    selectAt(pt, additive = false) {
+        const idx = this.regionIndexAt(pt);
+        if (additive) {
+            // Shift-click on empty space keeps the current selection.
+            if (idx < 0)
+                return;
+            // `this.selected` mirrors the store's current selection (kept in sync via
+            // the subscription), so it's the source of truth without a sync getter.
+            const cur = this.selected.slice();
+            const at = cur.indexOf(idx);
+            if (at >= 0)
+                cur.splice(at, 1); // toggle off
+            else
+                cur.push(idx); // toggle on
+            this.store.setSelectedShapeIndices(cur);
+            return;
+        }
+        this.store.setSelectedShapeIndices(idx >= 0 ? [idx] : []);
+    }
+    /** Indices of every region whose bounding box intersects the image-space
+     *  rectangle [x0,y0]–[x1,y1] (rubber-band multi-select). */
+    regionsInRect(x0, y0, x1, y1) {
+        const out = [];
+        this.store.getRegions().forEach((r, i) => {
+            const bb = this.regionBBox(r);
+            if (bb && bb.x0 <= x1 && bb.x1 >= x0 && bb.y0 <= y1 && bb.y1 >= y0)
+                out.push(i);
+        });
+        return out;
+    }
+    /** Axis-aligned bounding box of a region in image coords, or null if empty. */
+    regionBBox(r) {
+        const b = r.bounds;
+        if (b instanceof Rectangle) {
+            return { x0: b.x, y0: b.y, x1: b.x + b.width, y1: b.y + b.height };
+        }
+        if (b instanceof Polygon && b.xpoints.length) {
+            return {
+                x0: Math.min(...b.xpoints), y0: Math.min(...b.ypoints),
+                x1: Math.max(...b.xpoints), y1: Math.max(...b.ypoints),
+            };
+        }
+        if (b instanceof MultiPolygon) {
+            let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+            for (const p of b.polygons) {
+                for (let i = 0; i < p.xpoints.length; i++) {
+                    if (p.xpoints[i] < x0)
+                        x0 = p.xpoints[i];
+                    if (p.xpoints[i] > x1)
+                        x1 = p.xpoints[i];
+                    if (p.ypoints[i] < y0)
+                        y0 = p.ypoints[i];
+                    if (p.ypoints[i] > y1)
+                        y1 = p.ypoints[i];
+                }
+            }
+            return x1 >= x0 ? { x0, y0, x1, y1 } : null;
+        }
+        return null;
+    }
+    /** Index of the topmost region under a point, or -1. */
+    regionIndexAt(pt) {
+        const regions = this.store.getRegions();
+        for (let i = regions.length - 1; i >= 0; i--) {
+            if (this.containsPoint(regions[i], pt))
+                return i;
+        }
+        return -1;
+    }
+    containsPoint(region, pt) {
+        const b = region.bounds;
+        if (b instanceof Rectangle) {
+            return pt.x >= b.x && pt.x <= b.x + b.width && pt.y >= b.y && pt.y <= b.y + b.height;
+        }
+        // Multi-part region: inside any part (exterior minus that part's holes).
+        if (b instanceof MultiPolygon) {
+            return b.polygons.some((p) => this.closedPolygonContains(p, pt));
+        }
+        if (b instanceof Polygon) {
+            if (b.closed !== false)
+                return this.closedPolygonContains(b, pt);
+            // Open polyline: no interior — select when the click lands near the line.
+            // Tolerance is in screen pixels so it stays clickable at any zoom.
+            const xs = b.xpoints, ys = b.ypoints, n = xs.length, tolPx = 6;
+            const here = this.toPx(pt.x, pt.y);
+            for (let i = 0; i + 1 < n; i++) {
+                const a = this.toPx(xs[i], ys[i]);
+                const c = this.toPx(xs[i + 1], ys[i + 1]);
+                if (this.distToSegmentPx(here, a, c) <= tolPx)
+                    return true;
+            }
+            return false;
+        }
+        return false;
+    }
+    /** Point-in-closed-polygon (image coords) honouring interior rings (holes):
+     *  inside the exterior AND outside every hole (even-odd). */
+    closedPolygonContains(b, pt) {
+        const inRing = (rxs, rys) => {
+            let hit = false;
+            for (let i = 0, j = rxs.length - 1; i < rxs.length; j = i++) {
+                const intersect = ((rys[i] > pt.y) !== (rys[j] > pt.y))
+                    && (pt.x < ((rxs[j] - rxs[i]) * (pt.y - rys[i])) / (rys[j] - rys[i]) + rxs[i]);
+                if (intersect)
+                    hit = !hit;
+            }
+            return hit;
+        };
+        if (!inRing(b.xpoints, b.ypoints))
+            return false;
+        if (b.holes) {
+            for (const ring of b.holes) {
+                if (inRing(ring.map(p => p[0]), ring.map(p => p[1])))
+                    return false;
+            }
+        }
+        return true;
+    }
+    /** Shortest distance from point p to segment a–b, all in screen pixels. */
+    distToSegmentPx(p, a, b) {
+        const dx = b.x - a.x, dy = b.y - a.y;
+        const len2 = dx * dx + dy * dy;
+        if (len2 === 0)
+            return Math.hypot(p.x - a.x, p.y - a.y);
+        let t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+        t = Math.max(0, Math.min(1, t));
+        return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+    }
+    resetInProgress() {
+        this.rectStart = this.rectCurrent = null;
+        this.polyPoints = [];
+        this.freehandDragging = false;
+        this.drawingPolygon = false;
+        this.lastFreehandPx = null;
+        // Close any open edit batch (e.g. a mode switch mid-drag) so the store's
+        // emit coalescing doesn't get stuck.
+        if (this.edit) {
+            this.store.endBatch();
+            this.edit = null;
+        }
+    }
+    // ── commit to the store ──────────────────────────────────────────────
+    commitRectangle(x, y, w, h) {
+        const region = new Region();
+        const rect = new Rectangle();
+        rect.x = x;
+        rect.y = y;
+        rect.width = w;
+        rect.height = h;
+        region.bounds = rect;
+        region.color = this.store.getShapeColor();
+        this.commitRegion(region);
+    }
+    commitPolygon(closed) {
+        if (this.polyPoints.length < (closed ? 3 : 2)) {
+            this.resetInProgress();
+            return;
+        }
+        const region = new Region();
+        const poly = new Polygon();
+        poly.npoints = this.polyPoints.length;
+        poly.xpoints = this.polyPoints.map(p => p.x);
+        poly.ypoints = this.polyPoints.map(p => p.y);
+        poly.coordinates = this.polyPoints.map(p => [p.x, p.y]);
+        poly.closed = closed;
+        region.bounds = poly;
+        region.color = this.store.getShapeColor();
+        this.resetInProgress();
+        this.commitRegion(region);
+    }
+    /**
+     * Add a freshly-drawn region to the shared store and redraw immediately. The
+     * store mints the id, selects the new region (so it renders solid/highlighted
+     * rather than as a dashed in-progress shape) and emits the full region list to
+     * the Region Editor — we still redraw locally rather than relying solely on
+     * the store's update event, which can be swallowed when Plotly isn't active.
+     */
+    commitRegion(region) {
+        // Default class/annotation name, matching the Plotly backend and the Region
+        // Editor's "Add" actions so a freshly drawn region isn't unlabeled.
+        if (region.label == null)
+            region.label = 'Region';
+        this.store.addRegion(region);
+        this.redraw();
+    }
+    /**
+     * Convert the selected region(s) to/from a bezier curve (toBezier = true /
+     * toPolygon = false). One-shot; the anchors are unchanged,
+     * only the smooth-curve rendering is toggled.
+     */
+    setSelectedBezier(bezier) {
+        const regions = this.store.getRegions();
+        for (const idx of this.selected) {
+            const region = regions[idx];
+            if (region)
+                this.store.setBezier(region.id, bezier);
+        }
+        this.redraw();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"osd-region-overlay.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/osd-region-overlay.ts"],"names":[],"mappings":"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","sourcesContent":["import { OSD } from './osd-lib';\nimport { Subscription } from 'rxjs';\n\nimport { Region, Rectangle, Polygon, MultiPolygon } from '../../models/region';\nimport { resolveHandles } from '../../models/bezier';\nimport { IRegionStore } from '../../contracts/visualizer.contract';\nimport { IRegionEditApi } from '../../contracts/region-store.contract';\nimport { IRegionOverlay, RegionToolMode } from '../../contracts/region-overlay.contract';\nimport { elementToImage, imageToElement } from './osd-coords';\n\n/**\n * The shared region store as the overlay needs it: the cross-backend\n * {@link IRegionStore} (read regions, selection, colours) plus the Region-native\n * {@link IRegionEditApi} (add/move/resize/vertex edits). The shared RegionStore\n * satisfies both. The overlay edits through these typed operations on the\n * neutral Region model — it never touches a backend's own shape representation\n * (e.g. Plotly's `x0/y0/x1/y1` / `M…L…Z` dicts).\n */\nexport type RegionEditStore = IRegionStore & IRegionEditApi;\n\nconst SVGNS = 'http://www.w3.org/2000/svg';\n\n/** Move/resize zones on the selected rectangle. */\ntype EditZone = 'move' | 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';\nconst ZONE_CURSOR: Record<EditZone, string> = {\n  move: 'move', n: 'ns-resize', s: 'ns-resize', e: 'ew-resize', w: 'ew-resize',\n  ne: 'nesw-resize', sw: 'nesw-resize', nw: 'nwse-resize', se: 'nwse-resize',\n};\n/** Screen-pixel tolerance for grabbing an edge/corner handle. */\nconst EDIT_TOL = 8;\n/** Wheel zoom step per scroll tick — mirrors the viewer's `zoomPerScroll`. */\nconst ZOOM_PER_SCROLL = 1.1;\n\n/**\n * OpenSeadragon implementation of {@link IRegionOverlay}.\n *\n * - Renders the store's regions (rect/polygon) in image-pixel space, kept\n *   aligned on every pan/zoom via the OSD viewport API.\n * - Draws new rectangle and polygon regions (committed to the shared store).\n * - Click-to-select in 'select' mode.\n *\n * Reads/writes the shared {@link IRegionStore}, so regions stay in sync with the\n * Region Editor and the Plotly backend. The wand, vertex-eraser and zoom-to-box\n * tools are NOT handled here — they're owned by OpenSeadragonVisualizerService\n * (which binds them to OSD via the shared coordinate transform + viewport pixel\n * readback), the same singleton tool services the Plotly backend uses.\n */\nexport class OsdRegionOverlay implements IRegionOverlay {\n\n  private readonly svg: SVGSVGElement;\n  private readonly subs = new Subscription();\n  private readonly osd: any = OSD;\n\n  private selected: number[] = [];\n  private mode: RegionToolMode = 'none';\n\n  private tracker: any;\n  private rectStart: { x: number; y: number } | null = null; // image coords\n  private rectCurrent: { x: number; y: number } | null = null;\n  private polyPoints: { x: number; y: number }[] = [];        // image coords\n  /** True while dragging a freehand path (freeform / polyline). */\n  private freehandDragging = false;\n  /** True while placing a click-to-add polygon ('drawpolygon' mode). */\n  private drawingPolygon = false;\n  /** Last element-pixel point appended, to thin the freehand path. */\n  private lastFreehandPx: { x: number; y: number } | null = null;\n  /**\n   * In-progress edit of the selected region:\n   *  - kind 'bounds' — rectangle resize/move or whole-region move (uses `zone`);\n   *  - kind 'vertex' — dragging a single polygon vertex (uses `vertexIndex`).\n   */\n  private edit: {\n    kind: 'bounds' | 'vertex' | 'handle';\n    zone: EditZone;\n    vertexIndex: number;\n    /** Which ring the dragged vertex belongs to: -1 = exterior, else a hole\n     *  index into `Polygon.holes` (jit-ui#85). */\n    ring: number;\n    handleSide: 'in' | 'out';\n    id: number;\n    startImg: { x: number; y: number };\n    orig: any;\n  } | null = null;\n  private editDragged = false;\n  /** Rubber-band (marquee) multi-select in 'select' mode: press on empty space\n   *  and drag to select every region the band intersects. Image coords. */\n  private bandStart: { x: number; y: number } | null = null;\n  private bandCurrent: { x: number; y: number } | null = null;\n  private bandDragged = false;\n\n  private readonly redrawHandler = () => this.redraw();\n\n  constructor(private viewer: any, private store: RegionEditStore) {\n    this.svg = document.createElementNS(SVGNS, 'svg') as SVGSVGElement;\n    Object.assign(this.svg.style, {\n      position: 'absolute', left: '0', top: '0', width: '100%', height: '100%',\n      pointerEvents: 'none', // OSD handles navigation unless we're drawing\n    });\n    this.viewer.canvas.appendChild(this.svg);\n\n    this.viewer.addHandler('update-viewport', this.redrawHandler);\n    this.viewer.addHandler('animation', this.redrawHandler);\n    this.viewer.addHandler('resize', this.redrawHandler);\n    this.viewer.addHandler('rotate', this.redrawHandler);\n    // Keep wheel-zoom alive while a tool has mouse-nav disabled (see handler).\n    (this.viewer.element as HTMLElement | undefined)\n      ?.addEventListener('wheel', this.wheelZoomHandler, { passive: false });\n\n    this.tracker = new this.osd.MouseTracker({\n      element: this.viewer.canvas,\n      pressHandler: (e: any) => this.onPress(e),\n      dragHandler: (e: any) => this.onDrag(e),\n      releaseHandler: (e: any) => this.onRelease(e),\n      clickHandler: (e: any) => this.onClick(e),\n      moveHandler: (e: any) => this.onMove(e),\n    });\n    this.tracker.setTracking(false);\n\n    this.subs.add(this.store.getRegionUpdateEvent().subscribe(this.redrawHandler));\n    this.subs.add(this.store.getSelectedShapeIndices$().subscribe(idx => {\n      this.selected = idx || [];\n      this.redraw();\n    }));\n\n    this.redraw();\n  }\n\n  /** Switch drawing/selection mode; toggles OSD navigation accordingly. */\n  setMode(mode: RegionToolMode): void {\n    this.mode = mode;\n    this.resetInProgress();\n    // Any active region tool takes over the pointer — OSD pan/zoom is disabled\n    // so dragging draws (and clicks select) instead of panning. With no tool,\n    // OSD navigates normally.\n    this.viewer.setMouseNavEnabled(mode === 'none');\n    this.tracker.setTracking(mode !== 'none');\n    this.updateCursor(false);\n    this.redraw();\n  }\n\n  /** Drive OSD zoom from the wheel while any tool owns the pointer.\n   *\n   * OSD's native scroll-zoom is part of mouse-nav, so `setMouseNavEnabled(false)`\n   * (used by every region tool and by the wand/brush/eraser/SAM tools) disables\n   * it. The covering-canvas tools also sit above the OSD canvas and swallow the\n   * wheel outright. This listener is bound once to the viewer element — an\n   * ancestor of both the OSD canvas and the tool overlays — and forwards the\n   * wheel to a cursor-centred zoom whenever mouse-nav is off. When nav is on (no\n   * tool active) it does nothing and OSD zooms natively. (jit-ui#94) */\n  private readonly wheelZoomHandler = (e: WheelEvent) => {\n    const vp = this.viewer?.viewport;\n    const el = this.viewer?.element as HTMLElement | undefined;\n    // Nav on → no tool active → let OSD handle scroll-zoom natively.\n    if (!vp || !el || e.deltaY === 0 || this.viewer.isMouseNavEnabled()) return;\n    e.preventDefault();\n    const rect = el.getBoundingClientRect();\n    const refPoint = vp.pointFromPixel(new this.osd.Point(e.clientX - rect.left, e.clientY - rect.top));\n    vp.zoomBy(e.deltaY < 0 ? ZOOM_PER_SCROLL : 1 / ZOOM_PER_SCROLL, refPoint);\n    vp.applyConstraints();\n  };\n\n  /** Cursor feedback per mode (crosshair while drawing; pointer over a region\n   *  in select mode). */\n  private updateCursor(overRegion: boolean): void {\n    const canvas = this.viewer.canvas as HTMLElement;\n    if (this.mode === 'drawrect' || this.mode === 'drawclosedpath' || this.mode === 'drawopenpath'\n        || this.mode === 'drawpolygon' || this.mode === 'addpoint' || this.mode === 'deletepoint') {\n      canvas.style.cursor = 'crosshair';\n    } else if (this.mode === 'move') {\n      canvas.style.cursor = 'move';\n    } else if (this.mode === 'select') {\n      canvas.style.cursor = overRegion ? 'pointer' : 'default';\n    } else {\n      canvas.style.cursor = ''; // OSD default (grab)\n    }\n  }\n\n  /** Whether the selected region's vertices/handles should be drawn. Shown\n   *  whenever a region is selected — including `none` (display) mode and while\n   *  another tool (wand, brush, SAM…) is active — so a selection always reveals\n   *  its vertices. Suppressed only while actively drawing a brand-new shape,\n   *  where stray handles would be noise. */\n  private get showsSelectedVertices(): boolean {\n    return this.mode !== 'drawrect' && this.mode !== 'drawpolygon'\n      && this.mode !== 'drawclosedpath' && this.mode !== 'drawopenpath';\n  }\n\n  destroy(): void {\n    this.subs.unsubscribe();\n    (this.viewer.element as HTMLElement | undefined)\n      ?.removeEventListener('wheel', this.wheelZoomHandler);\n    this.viewer.removeHandler('update-viewport', this.redrawHandler);\n    this.viewer.removeHandler('animation', this.redrawHandler);\n    this.viewer.removeHandler('resize', this.redrawHandler);\n    this.viewer.removeHandler('rotate', this.redrawHandler);\n    if (this.tracker) this.tracker.destroy();\n    if (this.svg.parentNode) this.svg.parentNode.removeChild(this.svg);\n  }\n\n  // ── coordinate helpers ───────────────────────────────────────────────\n  /** Image-pixel point -> element pixel point. */\n  private toPx(imgX: number, imgY: number): { x: number; y: number } {\n    return imageToElement(this.viewer, imgX, imgY);\n  }\n  /** Element pixel point (from a MouseTracker event) -> image-pixel point. */\n  private toImage(pos: any): { x: number; y: number } {\n    const p = elementToImage(this.viewer, pos.x, pos.y);\n    return { x: Math.round(p.x), y: Math.round(p.y) };\n  }\n\n  // ── rendering ────────────────────────────────────────────────────────\n  redraw(): void {\n    while (this.svg.firstChild) this.svg.removeChild(this.svg.firstChild);\n\n    const regions = this.store.getRegions();\n    regions.forEach((r, i) => {\n      const el = this.buildRegionEl(r, this.selected.includes(i));\n      if (el) this.svg.appendChild(el);\n    });\n\n    // Handles on the selected polygon, so the user can grab/insert/delete\n    // vertices. Bezier regions also get their cubic\n    // control handles (tangent lines + control points), mirroring paper.js's\n    // fullySelected rendering.\n    if (this.showsSelectedVertices) {\n      const sel = this.selectedRegionInfo();\n      const b = sel?.region.bounds;\n      // Handles/vertices take the region's own colour (not the global shape\n      // colour) so they match the shape they belong to.\n      const color = sel ? sel.region.color || this.store.getShapeColor() : '';\n      if (b instanceof Polygon) {\n        if (b.bezier) {\n          this.drawBezierHandles(b, color);\n        } else {\n          for (let i = 0; i < b.xpoints.length; i++) {\n            const q = this.toPx(b.xpoints[i], b.ypoints[i]);\n            this.svg.appendChild(this.vertexMarker(q.x, q.y, false, color));\n          }\n          // Interior-ring (hole) vertices too, so a donut's inner outline shows\n          // its vertices when selected (jit-ui#85).\n          if (b.holes) {\n            for (const ring of b.holes) {\n              for (const [hx, hy] of ring) {\n                const q = this.toPx(hx, hy);\n                this.svg.appendChild(this.vertexMarker(q.x, q.y, false, color));\n              }\n            }\n          }\n        }\n      } else if (b instanceof Rectangle) {\n        // The four corners as grab/resize handles.\n        const corners: [number, number][] = [\n          [b.x, b.y], [b.x + b.width, b.y],\n          [b.x + b.width, b.y + b.height], [b.x, b.y + b.height],\n        ];\n        for (const [cx, cy] of corners) {\n          const q = this.toPx(cx, cy);\n          this.svg.appendChild(this.vertexMarker(q.x, q.y, false, color));\n        }\n      }\n    }\n\n    // Rubber-band (marquee) selection preview.\n    if (this.mode === 'select' && this.bandStart && this.bandCurrent) {\n      this.svg.appendChild(this.selectionBand(this.bandStart, this.bandCurrent));\n    }\n\n    // In-progress drawing preview.\n    if (this.mode === 'drawrect' && this.rectStart && this.rectCurrent) {\n      this.svg.appendChild(this.rectPreview(this.rectStart, this.rectCurrent));\n    }\n    if ((this.mode === 'drawclosedpath' || this.mode === 'drawopenpath') && this.polyPoints.length) {\n      this.svg.appendChild(this.polyPreview(this.polyPoints));\n    }\n    // Click-to-place polygon preview: the polyline so far + a marker on the\n    // first vertex (click it to close).\n    if (this.mode === 'drawpolygon' && this.polyPoints.length) {\n      this.svg.appendChild(this.polyPreview(this.polyPoints));\n      const f = this.toPx(this.polyPoints[0].x, this.polyPoints[0].y);\n      this.svg.appendChild(this.vertexMarker(f.x, f.y, true));\n    }\n  }\n\n  /** A small vertex handle (filled for an emphasised marker, hollow otherwise).\n   *  Colour defaults to the global shape colour (used by the in-progress draw\n   *  preview); selected-region handles pass the region's own colour. */\n  private vertexMarker(x: number, y: number, emphasised: boolean,\n                       color: string = this.store.getShapeColor()): SVGElement {\n    const c = document.createElementNS(SVGNS, 'circle');\n    c.setAttribute('cx', `${x}`);\n    c.setAttribute('cy', `${y}`);\n    c.setAttribute('r', emphasised ? '5' : '4');\n    c.setAttribute('fill', emphasised ? color : '#ffffff');\n    c.setAttribute('stroke', color);\n    c.setAttribute('stroke-width', '2');\n    return c;\n  }\n\n  private buildRegionEl(region: Region, selected: boolean): SVGElement | null {\n    const color = region.color || this.store.getShapeColor();\n    const bounds = region.bounds;\n    let pts: { x: number; y: number }[] | null = null;\n    let closed = true;\n    let el: SVGElement | null = null;\n\n    if (bounds instanceof MultiPolygon) {\n      // Multi-part region (jit-ui#85): one even-odd <path> with every part's\n      // exterior plus its holes. All parts' vertices drive the label bbox.\n      const parts = bounds.polygons.filter((p) => (p.xpoints?.length ?? 0) >= 3);\n      if (parts.length === 0) return null;\n      pts = [];\n      let d = '';\n      for (const part of parts) {\n        const ext = part.xpoints.map((x, i) => ({ x, y: part.ypoints[i] }));\n        pts.push(...ext);\n        d += (d ? ' ' : '') + this.straightPathD(ext, true);\n        if (part.holes) {\n          for (const ring of part.holes) {\n            d += ' ' + this.straightPathD(ring.map(([x, y]) => ({ x, y })), true);\n          }\n        }\n      }\n      el = document.createElementNS(SVGNS, 'path');\n      el.setAttribute('d', d);\n      el.setAttribute('fill-rule', 'evenodd');\n    } else if (bounds instanceof Rectangle) {\n      pts = [\n        { x: bounds.x, y: bounds.y },\n        { x: bounds.x + bounds.width, y: bounds.y },\n        { x: bounds.x + bounds.width, y: bounds.y + bounds.height },\n        { x: bounds.x, y: bounds.y + bounds.height },\n      ];\n    } else if (bounds instanceof Polygon) {\n      closed = bounds.closed !== false;\n      // The anchors drive the label bbox and (for non-bezier) the rendered shape.\n      pts = bounds.xpoints.map((x, i) => ({ x, y: bounds.ypoints[i] }));\n    }\n    if (!pts || pts.length === 0) return null;\n\n    if (!el) {\n      // Bezier regions render as a true cubic-bezier path through the anchors\n      // (paper.js-equivalent smooth curve); everything else as a straight\n      // polygon/polyline.\n      const isBezier = bounds instanceof Polygon && bounds.bezier && pts.length >= 2;\n      // Interior rings (holes) — punch through with even-odd fill (jit-ui#85).\n      const holes = (closed && bounds instanceof Polygon && bounds.holes?.length)\n        ? bounds.holes : null;\n      if (isBezier || holes) {\n        el = document.createElementNS(SVGNS, 'path');\n        // Exterior subpath (smooth for bezier, straight otherwise) followed by a\n        // straight subpath per hole.\n        let d = isBezier ? this.bezierPathD(bounds as Polygon) : this.straightPathD(pts, closed);\n        if (holes) {\n          const poly = bounds as Polygon;\n          holes.forEach((ring, hi) => {\n            const xs = ring.map((p) => p[0]);\n            const ys = ring.map((p) => p[1]);\n            // When the donut is a bezier, smooth its holes too (jit-ui#102) — using stored hole\n            // handles when present, else the Catmull-Rom default (via resolveHandles).\n            d +=\n              ' ' +\n              (isBezier\n                ? this.ringBezierPathD(xs, ys, poly.holeHandlesIn?.[hi], poly.holeHandlesOut?.[hi], true)\n                : this.straightPathD(ring.map(([x, y]) => ({ x, y })), true));\n          });\n          el.setAttribute('fill-rule', 'evenodd');\n        }\n        el.setAttribute('d', d);\n      } else {\n        el = document.createElementNS(SVGNS, closed ? 'polygon' : 'polyline');\n        el.setAttribute('points', pts.map(p => { const q = this.toPx(p.x, p.y); return `${q.x},${q.y}`; }).join(' '));\n      }\n    }\n    el.setAttribute('fill', selected ? this.rgba(color, 0.35) : 'none');\n    el.setAttribute('stroke', color);\n    el.setAttribute('stroke-width', selected ? '4' : '2');\n\n    // The class label (legend), shown when the Region Editor's \"show labels\" is\n    // on — mirrors Plotly's per-shape label (top-left, drawn in the region's\n    // colour). Without this OSD showed regions with no label even though Plotly\n    // did. region.label is restored from the shape's legend in getRegion().\n    const label = region.label;\n    if (this.store.getShowShapeLabel() && label != null && `${label}`.length > 0) {\n      const g = document.createElementNS(SVGNS, 'g');\n      g.appendChild(el);\n      const minX = Math.min(...pts.map(p => p.x));\n      const minY = Math.min(...pts.map(p => p.y));\n      const q = this.toPx(minX, minY);\n      const text = document.createElementNS(SVGNS, 'text');\n      text.setAttribute('x', `${q.x}`);\n      text.setAttribute('y', `${q.y - 4}`); // just above the top-left corner\n      text.setAttribute('fill', color);\n      text.setAttribute('font-size', '13');\n      text.setAttribute('font-family', 'sans-serif');\n      // Dark halo so the label stays legible over both bright and dark tiles.\n      text.setAttribute('paint-order', 'stroke');\n      text.setAttribute('stroke', 'rgba(0,0,0,0.65)');\n      text.setAttribute('stroke-width', '2');\n      text.textContent = `${label}`;\n      g.appendChild(text);\n      return g;\n    }\n    return el;\n  }\n\n  /** Marquee rectangle for rubber-band multi-select (dashed outline + faint fill). */\n  private selectionBand(a: { x: number; y: number }, b: { x: number; y: number }): SVGElement {\n    const corners = [\n      { x: a.x, y: a.y }, { x: b.x, y: a.y }, { x: b.x, y: b.y }, { x: a.x, y: b.y },\n    ];\n    const el = document.createElementNS(SVGNS, 'polygon');\n    el.setAttribute('points', corners.map(p => { const q = this.toPx(p.x, p.y); return `${q.x},${q.y}`; }).join(' '));\n    el.setAttribute('fill', 'rgba(120,170,255,0.15)');\n    el.setAttribute('stroke', '#4a90e2');\n    el.setAttribute('stroke-dasharray', '4 3');\n    el.setAttribute('stroke-width', '1');\n    return el;\n  }\n\n  private rectPreview(a: { x: number; y: number }, b: { x: number; y: number }): SVGElement {\n    const corners = [\n      { x: a.x, y: a.y }, { x: b.x, y: a.y }, { x: b.x, y: b.y }, { x: a.x, y: b.y },\n    ];\n    const el = document.createElementNS(SVGNS, 'polygon');\n    el.setAttribute('points', corners.map(p => { const q = this.toPx(p.x, p.y); return `${q.x},${q.y}`; }).join(' '));\n    el.setAttribute('fill', 'none');\n    el.setAttribute('stroke', this.store.getShapeColor());\n    el.setAttribute('stroke-dasharray', '4 3');\n    el.setAttribute('stroke-width', '2');\n    return el;\n  }\n\n  private polyPreview(pts: { x: number; y: number }[]): SVGElement {\n    const el = document.createElementNS(SVGNS, 'polyline');\n    el.setAttribute('points', pts.map(p => { const q = this.toPx(p.x, p.y); return `${q.x},${q.y}`; }).join(' '));\n    el.setAttribute('fill', 'none');\n    el.setAttribute('stroke', this.store.getShapeColor());\n    el.setAttribute('stroke-dasharray', '4 3');\n    el.setAttribute('stroke-width', '2');\n    return el;\n  }\n\n  /** SVG path `d` (element-pixel coords) for a straight-edged ring/polyline. */\n  private straightPathD(pts: { x: number; y: number }[], closed: boolean): string {\n    if (pts.length < 2) return '';\n    let d = '';\n    pts.forEach((p, i) => {\n      const q = this.toPx(p.x, p.y);\n      d += (i === 0 ? 'M ' : ' L ') + `${q.x},${q.y}`;\n    });\n    if (closed) d += ' Z';\n    return d;\n  }\n\n  /** SVG path `d` (element-pixel coords) for the smooth cubic bezier through a\n   *  polygon's anchors — the paper.js-equivalent curve. */\n  private bezierPathD(poly: Polygon): string {\n    const closed = poly.closed !== false;\n    return this.ringBezierPathD(poly.xpoints, poly.ypoints, poly.handlesIn, poly.handlesOut, closed);\n  }\n\n  /** SVG cubic-bezier path `d` (element px) for any ring (exterior or hole). Uses the stored\n   *  per-vertex handle offsets when present, else the Catmull-Rom default (resolveHandles). */\n  private ringBezierPathD(\n    xs: number[], ys: number[], inOff: number[][] | undefined, outOff: number[][] | undefined, closed: boolean,\n  ): string {\n    const n = Math.min(xs.length, ys.length);\n    if (n < 2) return '';\n    const h = resolveHandles(xs, ys, closed, inOff, outOff);\n    const px = (x: number, y: number) => { const q = this.toPx(x, y); return `${q.x},${q.y}`; };\n    let d = `M ${px(xs[0], ys[0])}`;\n    const segs = closed ? n : n - 1;\n    for (let i = 0; i < segs; i++) {\n      const j = (i + 1) % n;\n      const c1 = h[i].out;\n      const c2 = h[j].in;\n      d += ` C ${px(c1[0], c1[1])} ${px(c2[0], c2[1])} ${px(xs[j], ys[j])}`;\n    }\n    if (closed) d += ' Z';\n    return d;\n  }\n\n  /**\n   * Draw the bezier editing handles for the selected region, paper.js-style:\n   * each anchor as a small square, with tangent lines out to its two control\n   * points (drawn as small circles).\n   */\n  private drawBezierHandles(poly: Polygon, color: string): void {\n    const xs = poly.xpoints;\n    const ys = poly.ypoints;\n    const drawRing = (rxs: number[], rys: number[], inOff: number[][] | undefined,\n                      outOff: number[][] | undefined, closed: boolean): void => {\n      const h = resolveHandles(rxs, rys, closed, inOff, outOff);\n      for (let i = 0; i < rxs.length; i++) {\n        const a = this.toPx(rxs[i], rys[i]);\n        if (h[i].hasIn) this.drawHandle(a, this.toPx(h[i].in[0], h[i].in[1]), color);\n        if (h[i].hasOut) this.drawHandle(a, this.toPx(h[i].out[0], h[i].out[1]), color);\n        this.svg.appendChild(this.anchorSquare(a.x, a.y, color));\n      }\n    };\n    drawRing(xs, ys, poly.handlesIn, poly.handlesOut, poly.closed !== false);\n    // Donut hole rings get their own editable bezier handles (jit-ui#102).\n    if (poly.holes && poly.holeHandlesIn && poly.holeHandlesOut) {\n      poly.holes.forEach((ring, hi) => {\n        const inOff = poly.holeHandlesIn![hi];\n        const outOff = poly.holeHandlesOut![hi];\n        if (inOff && outOff) drawRing(ring.map((p) => p[0]), ring.map((p) => p[1]), inOff, outOff, true);\n      });\n    }\n  }\n\n  /** A tangent line from an anchor to a control point, with a circle at the end. */\n  private drawHandle(anchor: { x: number; y: number }, ctrl: { x: number; y: number }, color: string): void {\n    const line = document.createElementNS(SVGNS, 'line');\n    line.setAttribute('x1', `${anchor.x}`); line.setAttribute('y1', `${anchor.y}`);\n    line.setAttribute('x2', `${ctrl.x}`); line.setAttribute('y2', `${ctrl.y}`);\n    line.setAttribute('stroke', color);\n    line.setAttribute('stroke-width', '1');\n    this.svg.appendChild(line);\n    const c = document.createElementNS(SVGNS, 'circle');\n    c.setAttribute('cx', `${ctrl.x}`); c.setAttribute('cy', `${ctrl.y}`);\n    c.setAttribute('r', '3');\n    c.setAttribute('fill', color);\n    this.svg.appendChild(c);\n  }\n\n  /** A filled-white anchor square (the editable vertex). */\n  private anchorSquare(x: number, y: number, color: string): SVGElement {\n    const r = 3.5;\n    const rect = document.createElementNS(SVGNS, 'rect');\n    rect.setAttribute('x', `${x - r}`); rect.setAttribute('y', `${y - r}`);\n    rect.setAttribute('width', `${2 * r}`); rect.setAttribute('height', `${2 * r}`);\n    rect.setAttribute('fill', '#ffffff');\n    rect.setAttribute('stroke', color);\n    rect.setAttribute('stroke-width', '2');\n    return rect;\n  }\n\n  private rgba(color: string, alpha: number): string {\n    // Accept #rrggbb; fall back to the color as-is for named/rgb values.\n    if (/^#([0-9a-f]{6})$/i.test(color)) {\n      const r = parseInt(color.slice(1, 3), 16);\n      const g = parseInt(color.slice(3, 5), 16);\n      const b = parseInt(color.slice(5, 7), 16);\n      return `rgba(${r},${g},${b},${alpha})`;\n    }\n    return color;\n  }\n\n  // ── interaction ──────────────────────────────────────────────────────\n  private get isFreehand(): boolean {\n    return this.mode === 'drawclosedpath' || this.mode === 'drawopenpath';\n  }\n\n  private onPress(e: any): void {\n    if (this.mode === 'drawrect') {\n      this.rectStart = this.toImage(e.position);\n      this.rectCurrent = this.rectStart;\n      return;\n    }\n    if (this.isFreehand) {\n      // Freehand draw (matches Plotly drawclosedpath/drawopenpath): press to\n      // start, drag to trace, release to commit.\n      this.freehandDragging = true;\n      this.polyPoints = [this.toImage(e.position)];\n      this.lastFreehandPx = { x: e.position.x, y: e.position.y };\n      return;\n    }\n    if (this.mode === 'move') {\n      // Whole-region drag ('move' mode): press inside the selected region\n      // to translate it, ignoring vertices/edges.\n      const sel = this.selectedRegionInfo();\n      if (sel && this.containsPoint(sel.region, this.toImage(e.position))) {\n        this.startEdit('bounds', 'move', -1, sel.region, this.toImage(e.position));\n      }\n      return;\n    }\n    if (this.mode === 'select') {\n      // A bezier control handle takes top priority (it sits off the anchor).\n      const hh = this.hitBezierHandle(e.position);\n      if (hh) {\n        const region = this.store.getRegions()[this.selected[this.selected.length - 1]];\n        this.startEdit('handle', 'move', hh.index, region, this.toImage(e.position), hh.side, hh.ring);\n        return;\n      }\n      // Then dragging a single polygon vertex (over body-move/resize) —\n      // 'select' grabs the nearest segment first.\n      const vh = this.hitVertex(e.position);\n      if (vh) {\n        const region = this.store.getRegions()[this.selected[this.selected.length - 1]];\n        this.startEdit('vertex', 'move', vh.index, region, this.toImage(e.position), 'out', vh.ring);\n        return;\n      }\n      // Otherwise start a move/resize when pressing the selected region's\n      // body/handles.\n      const ez = this.editZoneAt(e.position);\n      if (ez) {\n        this.startEdit('bounds', ez.zone, -1, this.store.getRegions()[ez.index], this.toImage(e.position));\n        return;\n      }\n      // Press on empty space / a non-selected region: begin a rubber-band\n      // multi-select. A plain click (no drag) falls through to onClick, which\n      // single-selects or clears.\n      this.bandStart = this.toImage(e.position);\n      this.bandCurrent = this.bandStart;\n      this.bandDragged = false;\n    }\n  }\n\n  /** Begin an edit gesture (move/resize or single-vertex drag) and open a store\n   *  batch so the live drag emits once on release. */\n  private startEdit(kind: 'bounds' | 'vertex' | 'handle', zone: EditZone, vertexIndex: number,\n                    region: Region, startImg: { x: number; y: number },\n                    handleSide: 'in' | 'out' = 'out', ring = -1): void {\n    this.edit = {\n      kind, zone, vertexIndex, ring, handleSide, id: region.id,\n      startImg, orig: kind === 'bounds' ? this.snapshot(region) : null,\n    };\n    this.editDragged = false;\n    this.store.beginBatch();\n  }\n\n  private onDrag(e: any): void {\n    if (this.mode === 'drawrect' && this.rectStart) {\n      this.rectCurrent = this.toImage(e.position);\n      this.redraw();\n      return;\n    }\n    if (this.freehandDragging && this.isFreehand) {\n      // Thin the path: only sample once the cursor has moved a few screen px.\n      const last = this.lastFreehandPx;\n      if (!last || Math.hypot(e.position.x - last.x, e.position.y - last.y) >= 4) {\n        this.polyPoints.push(this.toImage(e.position));\n        this.lastFreehandPx = { x: e.position.x, y: e.position.y };\n        this.redraw();\n      }\n      return;\n    }\n    if (this.edit) {\n      this.editDragged = true;\n      this.applyEdit(this.toImage(e.position));\n      return;\n    }\n    if (this.bandStart) {\n      this.bandCurrent = this.toImage(e.position);\n      this.bandDragged = true;\n      this.redraw();\n    }\n  }\n\n  private onRelease(e: any): void {\n    if (this.mode === 'drawrect' && this.rectStart) {\n      const end = this.toImage(e.position);\n      const x = Math.min(this.rectStart.x, end.x);\n      const y = Math.min(this.rectStart.y, end.y);\n      const w = Math.abs(end.x - this.rectStart.x);\n      const h = Math.abs(end.y - this.rectStart.y);\n      this.rectStart = this.rectCurrent = null;\n      if (w > 2 && h > 2) this.commitRectangle(x, y, w, h);\n      return;\n    }\n    if (this.freehandDragging) {\n      this.freehandDragging = false;\n      this.lastFreehandPx = null;\n      // Closed = freeform (drawclosedpath); open = polyline (drawopenpath).\n      this.commitPolygon(this.mode === 'drawclosedpath');\n      return;\n    }\n    // Move/resize already applied live; flush the coalesced edits + end the\n    // gesture (keep selection).\n    if (this.edit) {\n      this.store.endBatch();\n      this.edit = null;\n      return;\n    }\n    // Finish a rubber-band selection: select every region the band intersects.\n    if (this.bandStart) {\n      const start = this.bandStart;\n      const end = this.bandCurrent ?? start;\n      this.bandStart = this.bandCurrent = null;\n      const x0 = Math.min(start.x, end.x), y0 = Math.min(start.y, end.y);\n      const x1 = Math.max(start.x, end.x), y1 = Math.max(start.y, end.y);\n      // Only a real drag selects; a click-sized band falls through to onClick.\n      if (this.bandDragged && (x1 - x0 > 2 || y1 - y0 > 2)) {\n        this.store.setSelectedShapeIndices(this.regionsInRect(x0, y0, x1, y1));\n      }\n      this.redraw();\n    }\n  }\n\n  private onClick(e: any): void {\n    if (this.mode === 'select') {\n      // A move/resize/vertex drag or a rubber-band drag also ends with a click\n      // event — don't treat it as a re-selection.\n      if (this.editDragged) { this.editDragged = false; return; }\n      if (this.bandDragged) { this.bandDragged = false; return; }\n      // Shift (or Cmd/Ctrl) toggles the clicked region in/out of the current\n      // selection; a plain click replaces it.\n      const oe = e.originalEvent;\n      const additive = !!oe && (oe.shiftKey || oe.metaKey || oe.ctrlKey);\n      this.selectAt(this.toImage(e.position), additive);\n      return;\n    }\n    if (this.mode === 'drawpolygon') {\n      this.onDrawPolygonClick(e);\n      return;\n    }\n    if (this.mode === 'addpoint') {\n      // Insert a vertex on the clicked edge — exterior or an interior ring.\n      const sel = this.selectedRegionInfo();\n      const edge = sel ? this.hitEdge(e.position, sel.region) : null;\n      if (sel && edge) {\n        if (edge.ring < 0) this.store.addVertex(sel.region.id, edge.segIndex, edge.x, edge.y);\n        else this.store.addHoleVertex(sel.region.id, edge.ring, edge.segIndex, edge.x, edge.y);\n      }\n      return;\n    }\n    if (this.mode === 'deletepoint') {\n      // Remove the clicked vertex — exterior or an interior ring (jit-ui#85).\n      const vh = this.hitVertex(e.position);\n      if (vh) {\n        if (vh.ring < 0) this.store.deleteVertex(vh.id, vh.index);\n        else this.store.deleteHoleVertex(vh.id, vh.ring, vh.index);\n      }\n      return;\n    }\n  }\n\n  /**\n   * Click-to-place polygon ('drawpolygon'): the first click starts the\n   * polygon, each subsequent click adds a vertex, and clicking near the first\n   * vertex (with at least 3 placed) closes and commits it.\n   */\n  private onDrawPolygonClick(e: any): void {\n    const pt = this.toImage(e.position);\n    if (!this.drawingPolygon) {\n      this.polyPoints = [pt];\n      this.drawingPolygon = true;\n      this.redraw();\n      return;\n    }\n    const first = this.toPx(this.polyPoints[0].x, this.polyPoints[0].y);\n    const onFirst = Math.hypot(e.position.x - first.x, e.position.y - first.y) <= EDIT_TOL;\n    if (onFirst && this.polyPoints.length >= 3) {\n      this.commitPolygon(true); // closes + resets in-progress (incl. drawingPolygon)\n      return;\n    }\n    this.polyPoints.push(pt);\n    this.redraw();\n  }\n\n  /**\n   * Hover feedback in select mode: move/resize cursors over the selected\n   * region's body/edges/corners, a pointer over any other region.\n   */\n  private onMove(e: any): void {\n    if (this.mode !== 'select') return;\n    // A grabbable bezier control handle or vertex of the selected polygon takes\n    // priority.\n    if (this.hitBezierHandle(e.position) || this.hitVertex(e.position)) {\n      (this.viewer.canvas as HTMLElement).style.cursor = 'pointer';\n      return;\n    }\n    const ez = this.editZoneAt(e.position);\n    if (ez) {\n      (this.viewer.canvas as HTMLElement).style.cursor = ZONE_CURSOR[ez.zone];\n      return;\n    }\n    this.updateCursor(this.regionIndexAt(this.toImage(e.position)) >= 0);\n  }\n\n  /**\n   * The move/resize zone under the cursor for the currently-selected region\n   * (rectangles get edge/corner handles + body; polygons get body-move only),\n   * or null if the cursor isn't over the selected region.\n   */\n  private editZoneAt(position: { x: number; y: number }): { zone: EditZone; index: number } | null {\n    if (this.selected.length === 0) return null;\n    const index = this.selected[this.selected.length - 1];\n    const region = this.store.getRegions()[index];\n    if (!region) return null;\n    const b = region.bounds;\n    if (b instanceof Rectangle) {\n      const a = this.toPx(b.x, b.y);\n      const c = this.toPx(b.x + b.width, b.y + b.height);\n      const zone = this.rectZone(position.x, position.y,\n        Math.min(a.x, c.x), Math.min(a.y, c.y), Math.max(a.x, c.x), Math.max(a.y, c.y));\n      return zone ? { zone, index } : null;\n    }\n    if (b instanceof Polygon || b instanceof MultiPolygon) {\n      // Polygons + multi-part regions support whole-region move (no resize zones).\n      return this.containsPoint(region, this.toImage(position)) ? { zone: 'move', index } : null;\n    }\n    return null;\n  }\n\n  /** The currently-selected region (the last one selected), or null. */\n  private selectedRegionInfo(): { region: Region; index: number } | null {\n    if (this.selected.length === 0) return null;\n    const index = this.selected[this.selected.length - 1];\n    const region = this.store.getRegions()[index];\n    return region ? { region, index } : null;\n  }\n\n  /** The vertex of the selected polygon under the cursor (screen-pixel\n   *  tolerance), or null. Rectangles have no editable vertices. */\n  private hitVertex(position: { x: number; y: number }): { id: number; ring: number; index: number } | null {\n    const sel = this.selectedRegionInfo();\n    if (!sel || !(sel.region.bounds instanceof Polygon)) return null;\n    const b = sel.region.bounds;\n    for (let i = 0; i < b.xpoints.length; i++) {\n      const q = this.toPx(b.xpoints[i], b.ypoints[i]);\n      if (Math.hypot(position.x - q.x, position.y - q.y) <= EDIT_TOL) {\n        return { id: sel.region.id, ring: -1, index: i };\n      }\n    }\n    // Interior-ring (hole) vertices are draggable too (jit-ui#85).\n    if (b.holes) {\n      for (let h = 0; h < b.holes.length; h++) {\n        const ring = b.holes[h];\n        for (let i = 0; i < ring.length; i++) {\n          const q = this.toPx(ring[i][0], ring[i][1]);\n          if (Math.hypot(position.x - q.x, position.y - q.y) <= EDIT_TOL) {\n            return { id: sel.region.id, ring: h, index: i };\n          }\n        }\n      }\n    }\n    return null;\n  }\n\n  /** The bezier control handle of the selected region under the cursor (which\n   *  anchor, and whether the in- or out-handle), or null. */\n  private hitBezierHandle(\n    position: { x: number; y: number },\n  ): { id: number; index: number; side: 'in' | 'out'; ring: number } | null {\n    const sel = this.selectedRegionInfo();\n    if (!sel || !(sel.region.bounds instanceof Polygon) || !sel.region.bounds.bezier) return null;\n    const b = sel.region.bounds;\n    // Test one ring's control handles; returns the matched vertex/side or null.\n    const testRing = (\n      xs: number[], ys: number[], inOff: number[][] | undefined, outOff: number[][] | undefined,\n      closed: boolean, ring: number,\n    ): { id: number; index: number; side: 'in' | 'out'; ring: number } | null => {\n      const h = resolveHandles(xs, ys, closed, inOff, outOff);\n      for (let i = 0; i < h.length; i++) {\n        if (h[i].hasOut) {\n          const q = this.toPx(h[i].out[0], h[i].out[1]);\n          if (Math.hypot(position.x - q.x, position.y - q.y) <= EDIT_TOL) {\n            return { id: sel.region.id, index: i, side: 'out', ring };\n          }\n        }\n        if (h[i].hasIn) {\n          const q = this.toPx(h[i].in[0], h[i].in[1]);\n          if (Math.hypot(position.x - q.x, position.y - q.y) <= EDIT_TOL) {\n            return { id: sel.region.id, index: i, side: 'in', ring };\n          }\n        }\n      }\n      return null;\n    };\n    const ext = testRing(b.xpoints, b.ypoints, b.handlesIn, b.handlesOut, b.closed !== false, -1);\n    if (ext) return ext;\n    // Donut hole rings (jit-ui#102): their own bezier control handles.\n    if (b.holes && b.holeHandlesIn && b.holeHandlesOut) {\n      for (let hi = 0; hi < b.holes.length; hi++) {\n        const ring = b.holes[hi];\n        const hit = testRing(\n          ring.map((p) => p[0]), ring.map((p) => p[1]),\n          b.holeHandlesIn[hi], b.holeHandlesOut[hi], true, hi,\n        );\n        if (hit) return hit;\n      }\n    }\n    return null;\n  }\n\n  /** The edge of `region`'s polygon nearest the cursor (within tolerance), with\n   *  the clicked point in image coords as the insertion position, or null. */\n  private hitEdge(position: { x: number; y: number }, region: Region):\n    { ring: number; segIndex: number; x: number; y: number } | null {\n    if (!(region.bounds instanceof Polygon)) return null;\n    const b = region.bounds;\n    let best = -1, bestRing = -1, bestDist = Infinity;\n    // Nearest edge across the exterior (ring -1) and every interior ring (hole).\n    const scan = (xs: number[], ys: number[], ring: number, closed: boolean) => {\n      const n = xs.length;\n      const segCount = closed ? n : n - 1; // closed wraps the last->first edge\n      for (let i = 0; i < segCount; i++) {\n        const j = (i + 1) % n;\n        const a = this.toPx(xs[i], ys[i]);\n        const c = this.toPx(xs[j], ys[j]);\n        const d = this.distToSegmentPx(position, a, c);\n        if (d < bestDist) { bestDist = d; best = i; bestRing = ring; }\n      }\n    };\n    scan(b.xpoints, b.ypoints, -1, b.closed !== false);\n    if (b.holes) {\n      b.holes.forEach((r, h) => scan(r.map(p => p[0]), r.map(p => p[1]), h, true));\n    }\n    if (best < 0 || bestDist > EDIT_TOL) return null;\n    const img = this.toImage(position);\n    return { ring: bestRing, segIndex: best, x: img.x, y: img.y };\n  }\n\n  /** Classify a screen point against a screen-space rectangle into a zone. */\n  private rectZone(px: number, py: number, x0: number, y0: number, x1: number, y1: number): EditZone | null {\n    const t = EDIT_TOL;\n    if (px < x0 - t || px > x1 + t || py < y0 - t || py > y1 + t) return null;\n    const left = Math.abs(px - x0) <= t, right = Math.abs(px - x1) <= t;\n    const top = Math.abs(py - y0) <= t, bottom = Math.abs(py - y1) <= t;\n    if (top && left) return 'nw';\n    if (top && right) return 'ne';\n    if (bottom && left) return 'sw';\n    if (bottom && right) return 'se';\n    if (left) return 'w';\n    if (right) return 'e';\n    if (top) return 'n';\n    if (bottom) return 's';\n    if (px > x0 && px < x1 && py > y0 && py < y1) return 'move';\n    return null;\n  }\n\n  /** Snapshot the selected region's geometry at the start of an edit. */\n  private snapshot(region: Region): any {\n    const b = region.bounds;\n    if (b instanceof Rectangle) return { kind: 'rect', x: b.x, y: b.y, w: b.width, h: b.height };\n    if (b instanceof Polygon) {\n      return {\n        kind: 'poly', xs: b.xpoints.slice(), ys: b.ypoints.slice(), closed: b.closed !== false,\n        bezier: b.bezier,\n        inOff: b.handlesIn?.map(o => o.slice()),\n        outOff: b.handlesOut?.map(o => o.slice()),\n        holes: b.holes?.map(ring => ring.map(pt => pt.slice())),\n      };\n    }\n    if (b instanceof MultiPolygon) {\n      return {\n        kind: 'multi',\n        polygons: b.polygons.map((p) => ({\n          xs: p.xpoints.slice(), ys: p.ypoints.slice(), closed: p.closed !== false,\n          holes: p.holes?.map(ring => ring.map(pt => pt.slice())),\n        })),\n      };\n    }\n    return { kind: 'rect', x: 0, y: 0, w: 0, h: 0 };\n  }\n\n  /**\n   * Apply the in-progress move/resize to the region, live, through the\n   * Region-native edit API. Recomputed absolutely from the gesture-start\n   * snapshot (`orig`) + the total delta, so each frame is idempotent.\n   */\n  private applyEdit(curImg: { x: number; y: number }): void {\n    if (!this.edit) return;\n\n    if (this.edit.kind === 'vertex') {\n      // Drag a single vertex to the cursor (absolute — idempotent). Route to the\n      // exterior or the matching interior ring (hole) — jit-ui#85.\n      if (this.edit.ring < 0) {\n        this.store.moveVertex(this.edit.id, this.edit.vertexIndex, curImg.x, curImg.y);\n      } else {\n        this.store.moveHoleVertex(this.edit.id, this.edit.ring, this.edit.vertexIndex, curImg.x, curImg.y);\n      }\n      this.redraw();\n      return;\n    }\n\n    if (this.edit.kind === 'handle') {\n      // Drag a bezier control handle to the cursor — exterior (ring -1) or a donut hole ring.\n      if (this.edit.ring < 0) {\n        this.store.moveBezierHandle(this.edit.id, this.edit.vertexIndex, this.edit.handleSide, curImg.x, curImg.y);\n      } else {\n        this.store.moveHoleBezierHandle(\n          this.edit.id, this.edit.ring, this.edit.vertexIndex, this.edit.handleSide, curImg.x, curImg.y,\n        );\n      }\n      this.redraw();\n      return;\n    }\n\n    const dx = curImg.x - this.edit.startImg.x;\n    const dy = curImg.y - this.edit.startImg.y;\n\n    const o = this.edit.orig;\n    if (o.kind === 'rect') {\n      let x0 = o.x, y0 = o.y, x1 = o.x + o.w, y1 = o.y + o.h;\n      switch (this.edit.zone) {\n        case 'move': x0 += dx; x1 += dx; y0 += dy; y1 += dy; break;\n        case 'w': x0 += dx; break;\n        case 'e': x1 += dx; break;\n        case 'n': y0 += dy; break;\n        case 's': y1 += dy; break;\n        case 'nw': x0 += dx; y0 += dy; break;\n        case 'ne': x1 += dx; y0 += dy; break;\n        case 'sw': x0 += dx; y1 += dy; break;\n        case 'se': x1 += dx; y1 += dy; break;\n      }\n      const rect = new Rectangle();\n      rect.x = Math.round(Math.min(x0, x1));\n      rect.y = Math.round(Math.min(y0, y1));\n      rect.width = Math.round(Math.abs(x1 - x0));\n      rect.height = Math.round(Math.abs(y1 - y0));\n      this.store.updateBounds(this.edit.id, rect);\n    } else if (o.kind === 'multi') {\n      // Multi-part region: translate every part (and its holes) by the delta.\n      const mp = new MultiPolygon();\n      mp.polygons = o.polygons.map((pp: any) => {\n        const xs = pp.xs.map((x: number) => Math.round(x + dx));\n        const ys = pp.ys.map((y: number) => Math.round(y + dy));\n        const poly = new Polygon();\n        poly.npoints = xs.length;\n        poly.xpoints = xs;\n        poly.ypoints = ys;\n        poly.coordinates = xs.map((x: number, i: number) => [x, ys[i]]);\n        poly.closed = pp.closed;\n        if (pp.holes) {\n          poly.holes = pp.holes.map((ring: number[][]) =>\n            ring.map(([x, y]: number[]) => [Math.round(x + dx), Math.round(y + dy)]));\n        }\n        return poly;\n      });\n      this.store.updateBounds(this.edit.id, mp);\n    } else {\n      // Polygon: translate every vertex (the only polygon edit zone is 'move').\n      // Bezier flag + handle offsets are relative, so they carry over unchanged.\n      const xs = o.xs.map((x: number) => Math.round(x + dx));\n      const ys = o.ys.map((y: number) => Math.round(y + dy));\n      const poly = new Polygon();\n      poly.npoints = xs.length;\n      poly.xpoints = xs;\n      poly.ypoints = ys;\n      poly.coordinates = xs.map((x: number, i: number) => [x, ys[i]]);\n      poly.closed = o.closed;\n      poly.bezier = o.bezier;\n      if (o.inOff) poly.handlesIn = o.inOff.map((off: number[]) => off.slice());\n      if (o.outOff) poly.handlesOut = o.outOff.map((off: number[]) => off.slice());\n      // Translate interior rings (holes) with the exterior (jit-ui#85).\n      if (o.holes) {\n        poly.holes = o.holes.map((ring: number[][]) =>\n          ring.map(([x, y]: number[]) => [Math.round(x + dx), Math.round(y + dy)]));\n      }\n      this.store.updateBounds(this.edit.id, poly);\n    }\n    this.redraw();\n  }\n\n  private selectAt(pt: { x: number; y: number }, additive = false): void {\n    const idx = this.regionIndexAt(pt);\n    if (additive) {\n      // Shift-click on empty space keeps the current selection.\n      if (idx < 0) return;\n      // `this.selected` mirrors the store's current selection (kept in sync via\n      // the subscription), so it's the source of truth without a sync getter.\n      const cur = this.selected.slice();\n      const at = cur.indexOf(idx);\n      if (at >= 0) cur.splice(at, 1); // toggle off\n      else cur.push(idx);             // toggle on\n      this.store.setSelectedShapeIndices(cur);\n      return;\n    }\n    this.store.setSelectedShapeIndices(idx >= 0 ? [idx] : []);\n  }\n\n  /** Indices of every region whose bounding box intersects the image-space\n   *  rectangle [x0,y0]–[x1,y1] (rubber-band multi-select). */\n  private regionsInRect(x0: number, y0: number, x1: number, y1: number): number[] {\n    const out: number[] = [];\n    this.store.getRegions().forEach((r, i) => {\n      const bb = this.regionBBox(r);\n      if (bb && bb.x0 <= x1 && bb.x1 >= x0 && bb.y0 <= y1 && bb.y1 >= y0) out.push(i);\n    });\n    return out;\n  }\n\n  /** Axis-aligned bounding box of a region in image coords, or null if empty. */\n  private regionBBox(r: Region): { x0: number; y0: number; x1: number; y1: number } | null {\n    const b = r.bounds;\n    if (b instanceof Rectangle) {\n      return { x0: b.x, y0: b.y, x1: b.x + b.width, y1: b.y + b.height };\n    }\n    if (b instanceof Polygon && b.xpoints.length) {\n      return {\n        x0: Math.min(...b.xpoints), y0: Math.min(...b.ypoints),\n        x1: Math.max(...b.xpoints), y1: Math.max(...b.ypoints),\n      };\n    }\n    if (b instanceof MultiPolygon) {\n      let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;\n      for (const p of b.polygons) {\n        for (let i = 0; i < p.xpoints.length; i++) {\n          if (p.xpoints[i] < x0) x0 = p.xpoints[i];\n          if (p.xpoints[i] > x1) x1 = p.xpoints[i];\n          if (p.ypoints[i] < y0) y0 = p.ypoints[i];\n          if (p.ypoints[i] > y1) y1 = p.ypoints[i];\n        }\n      }\n      return x1 >= x0 ? { x0, y0, x1, y1 } : null;\n    }\n    return null;\n  }\n\n  /** Index of the topmost region under a point, or -1. */\n  private regionIndexAt(pt: { x: number; y: number }): number {\n    const regions = this.store.getRegions();\n    for (let i = regions.length - 1; i >= 0; i--) {\n      if (this.containsPoint(regions[i], pt)) return i;\n    }\n    return -1;\n  }\n\n  private containsPoint(region: Region, pt: { x: number; y: number }): boolean {\n    const b = region.bounds;\n    if (b instanceof Rectangle) {\n      return pt.x >= b.x && pt.x <= b.x + b.width && pt.y >= b.y && pt.y <= b.y + b.height;\n    }\n    // Multi-part region: inside any part (exterior minus that part's holes).\n    if (b instanceof MultiPolygon) {\n      return b.polygons.some((p) => this.closedPolygonContains(p, pt));\n    }\n    if (b instanceof Polygon) {\n      if (b.closed !== false) return this.closedPolygonContains(b, pt);\n      // Open polyline: no interior — select when the click lands near the line.\n      // Tolerance is in screen pixels so it stays clickable at any zoom.\n      const xs = b.xpoints, ys = b.ypoints, n = xs.length, tolPx = 6;\n      const here = this.toPx(pt.x, pt.y);\n      for (let i = 0; i + 1 < n; i++) {\n        const a = this.toPx(xs[i], ys[i]);\n        const c = this.toPx(xs[i + 1], ys[i + 1]);\n        if (this.distToSegmentPx(here, a, c) <= tolPx) return true;\n      }\n      return false;\n    }\n    return false;\n  }\n\n  /** Point-in-closed-polygon (image coords) honouring interior rings (holes):\n   *  inside the exterior AND outside every hole (even-odd). */\n  private closedPolygonContains(b: Polygon, pt: { x: number; y: number }): boolean {\n    const inRing = (rxs: number[], rys: number[]): boolean => {\n      let hit = false;\n      for (let i = 0, j = rxs.length - 1; i < rxs.length; j = i++) {\n        const intersect = ((rys[i] > pt.y) !== (rys[j] > pt.y))\n          && (pt.x < ((rxs[j] - rxs[i]) * (pt.y - rys[i])) / (rys[j] - rys[i]) + rxs[i]);\n        if (intersect) hit = !hit;\n      }\n      return hit;\n    };\n    if (!inRing(b.xpoints, b.ypoints)) return false;\n    if (b.holes) {\n      for (const ring of b.holes) {\n        if (inRing(ring.map(p => p[0]), ring.map(p => p[1]))) return false;\n      }\n    }\n    return true;\n  }\n\n  /** Shortest distance from point p to segment a–b, all in screen pixels. */\n  private distToSegmentPx(\n    p: { x: number; y: number }, a: { x: number; y: number }, b: { x: number; y: number },\n  ): number {\n    const dx = b.x - a.x, dy = b.y - a.y;\n    const len2 = dx * dx + dy * dy;\n    if (len2 === 0) return Math.hypot(p.x - a.x, p.y - a.y);\n    let t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;\n    t = Math.max(0, Math.min(1, t));\n    return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));\n  }\n\n  private resetInProgress(): void {\n    this.rectStart = this.rectCurrent = null;\n    this.polyPoints = [];\n    this.freehandDragging = false;\n    this.drawingPolygon = false;\n    this.lastFreehandPx = null;\n    // Close any open edit batch (e.g. a mode switch mid-drag) so the store's\n    // emit coalescing doesn't get stuck.\n    if (this.edit) {\n      this.store.endBatch();\n      this.edit = null;\n    }\n  }\n\n  // ── commit to the store ──────────────────────────────────────────────\n  private commitRectangle(x: number, y: number, w: number, h: number): void {\n    const region = new Region();\n    const rect = new Rectangle();\n    rect.x = x; rect.y = y; rect.width = w; rect.height = h;\n    region.bounds = rect;\n    region.color = this.store.getShapeColor();\n    this.commitRegion(region);\n  }\n\n  private commitPolygon(closed: boolean): void {\n    if (this.polyPoints.length < (closed ? 3 : 2)) { this.resetInProgress(); return; }\n    const region = new Region();\n    const poly = new Polygon();\n    poly.npoints = this.polyPoints.length;\n    poly.xpoints = this.polyPoints.map(p => p.x);\n    poly.ypoints = this.polyPoints.map(p => p.y);\n    poly.coordinates = this.polyPoints.map(p => [p.x, p.y]);\n    poly.closed = closed;\n    region.bounds = poly;\n    region.color = this.store.getShapeColor();\n    this.resetInProgress();\n    this.commitRegion(region);\n  }\n\n  /**\n   * Add a freshly-drawn region to the shared store and redraw immediately. The\n   * store mints the id, selects the new region (so it renders solid/highlighted\n   * rather than as a dashed in-progress shape) and emits the full region list to\n   * the Region Editor — we still redraw locally rather than relying solely on\n   * the store's update event, which can be swallowed when Plotly isn't active.\n   */\n  private commitRegion(region: Region): void {\n    // Default class/annotation name, matching the Plotly backend and the Region\n    // Editor's \"Add\" actions so a freshly drawn region isn't unlabeled.\n    if (region.label == null) region.label = 'Region';\n    this.store.addRegion(region);\n    this.redraw();\n  }\n\n  /**\n   * Convert the selected region(s) to/from a bezier curve (toBezier = true /\n   * toPolygon = false). One-shot; the anchors are unchanged,\n   * only the smooth-curve rendering is toggled.\n   */\n  setSelectedBezier(bezier: boolean): void {\n    const regions = this.store.getRegions();\n    for (const idx of this.selected) {\n      const region = regions[idx];\n      if (region) this.store.setBezier(region.id, bezier);\n    }\n    this.redraw();\n  }\n}\n"]}