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

package/esm2022/lib/implementations/napari-js/napari-region-overlay.mjs

@@ -0,0 +1,847 @@
+import { Subscription } from 'rxjs';
+import { Region, Rectangle, Polygon } from '../../models/region';
+const SVG_NS = 'http://www.w3.org/2000/svg';
+/** Min drag (image px) before a freehand path records another point. */
+const FREEHAND_STEP = 2;
+/** Click-distance (screen px) within which a polygon click snaps closed onto the first vertex. */
+const CLOSE_SNAP_PX = 10;
+/** Screen-px hit radius for grabbing a vertex / rectangle corner handle. */
+const HANDLE_HIT_PX = 9;
+/** Rendered handle size (screen px). */
+const HANDLE_SIZE = 7;
+/**
+ * SVG region overlay for the napari-js WebGPU image view (jit-ui#102), mirroring the OSD backend's
+ * {@link OsdRegionOverlay} but driven by napari's `canvasToWorld`/`worldToCanvas` transforms.
+ * Vector shapes are drawn in an absolutely-positioned `<svg>` over the canvas (no need to push
+ * them through WebGPU). It writes completed shapes to the shared {@link RegionStore} (so save /
+ * undo / export work identically to OSD) and re-renders from the store on every camera move,
+ * region change, and selection change.
+ *
+ * Supports (jit-ui#102): rectangle / polygon / freehand path drawing, click-select and rubber-band
+ * marquee select, pan/zoom gating via `setControlsEnabled`, body move, vertex move/add/delete,
+ * bezier handle editing, and donut holes (including hole vertex + hole-bezier-handle editing) —
+ * full parity with {@link OsdRegionOverlay}.
+ */
+export class NapariRegionOverlay {
+    constructor(host, viewer, store) {
+        this.host = host;
+        this.viewer = viewer;
+        this.store = store;
+        this.subs = new Subscription();
+        this.mode = 'none';
+        this.selected = [];
+        /** In-progress drawing state (image-space). */
+        this.draftRect = null;
+        /** In-progress rubber-band selection marquee (select mode), image-space. */
+        this.marquee = null;
+        /** Dedicated marquee rect element, updated directly during the drag (no full region redraw). */
+        this.marqueeEl = null;
+        this.draftPath = null; // freehand or click polygon
+        this.drawing = false; // pointer is down for rect / freehand
+        /** In-progress manipulation (select/move modes): dragging a body, a polygon vertex, or a
+         *  rectangle corner. `anchor` is the fixed opposite corner for a rectangle resize. */
+        this.edit = null;
+        // ── pointer handlers ──────────────────────────────────────────────────────
+        this.onPointerDown = (e) => {
+            if (this.mode === 'none')
+                return;
+            e.preventDefault();
+            const [ix, iy] = this.toImage(e.clientX, e.clientY);
+            if (this.mode === 'drawrect') {
+                this.draftRect = { x0: ix, y0: iy, x1: ix, y1: iy };
+                this.drawing = true;
+                this.svg.setPointerCapture(e.pointerId);
+            }
+            else if (this.mode === 'drawclosedpath' || this.mode === 'drawopenpath') {
+                this.draftPath = [[ix, iy]];
+                this.drawing = true;
+                this.svg.setPointerCapture(e.pointerId);
+            }
+            else if (this.mode === 'drawpolygon') {
+                this.handlePolygonClick(ix, iy, e.clientX, e.clientY);
+            }
+            else if (this.mode === 'select' || this.mode === 'move') {
+                this.beginManipulation(ix, iy, e);
+            }
+            else if (this.mode === 'addpoint') {
+                this.handleAddPoint(ix, iy);
+            }
+            else if (this.mode === 'deletepoint') {
+                this.handleDeletePoint(ix, iy);
+            }
+            this.redraw();
+        };
+        this.onPointerMove = (e) => {
+            const [ix, iy] = this.toImage(e.clientX, e.clientY);
+            if (this.marquee) {
+                this.marquee.x1 = ix;
+                this.marquee.y1 = iy;
+                this.updateMarqueeEl(); // update just the marquee rect — NOT a full region redraw
+                return;
+            }
+            if (this.edit) {
+                this.applyManipulation(ix, iy);
+                this.redraw();
+                return;
+            }
+            if (!this.drawing)
+                return;
+            if (this.draftRect) {
+                this.draftRect.x1 = ix;
+                this.draftRect.y1 = iy;
+            }
+            else if (this.draftPath) {
+                const last = this.draftPath[this.draftPath.length - 1];
+                if (Math.abs(ix - last[0]) >= FREEHAND_STEP || Math.abs(iy - last[1]) >= FREEHAND_STEP) {
+                    this.draftPath.push([ix, iy]);
+                }
+            }
+            this.redraw();
+        };
+        this.onPointerUp = (e) => {
+            if (this.marquee) {
+                const m = this.marquee;
+                this.marquee = null;
+                this.clearMarqueeEl();
+                try {
+                    this.svg.releasePointerCapture(e.pointerId);
+                }
+                catch {
+                    /* already released */
+                }
+                this.finishMarquee(m); // setSelectedShapeIndices → one redraw via the selection subscription
+                return;
+            }
+            if (this.edit) {
+                this.store.endBatch();
+                this.edit = null;
+                try {
+                    this.svg.releasePointerCapture(e.pointerId);
+                }
+                catch {
+                    /* already released */
+                }
+                this.redraw();
+                return;
+            }
+            if (!this.drawing)
+                return;
+            this.drawing = false;
+            try {
+                this.svg.releasePointerCapture(e.pointerId);
+            }
+            catch {
+                /* capture may already be released */
+            }
+            if (this.draftRect) {
+                const { x0, y0, x1, y1 } = this.draftRect;
+                const x = Math.min(x0, x1);
+                const y = Math.min(y0, y1);
+                const w = Math.abs(x1 - x0);
+                const h = Math.abs(y1 - y0);
+                this.draftRect = null;
+                if (w >= 2 && h >= 2)
+                    this.commitRectangle(x, y, w, h);
+            }
+            else if (this.draftPath) {
+                const pts = this.draftPath;
+                this.draftPath = null;
+                const closed = this.mode === 'drawclosedpath';
+                if (pts.length >= (closed ? 3 : 2))
+                    this.commitPolygon(pts, closed);
+            }
+            this.redraw();
+        };
+        this.onDblClick = (e) => {
+            if (this.mode !== 'drawpolygon' || !this.draftPath)
+                return;
+            e.preventDefault();
+            const pts = this.draftPath;
+            this.draftPath = null;
+            if (pts.length >= 3)
+                this.commitPolygon(pts, true);
+            this.redraw();
+        };
+        if (getComputedStyle(host).position === 'static')
+            host.style.position = 'relative';
+        this.svg = document.createElementNS(SVG_NS, 'svg');
+        Object.assign(this.svg.style, {
+            position: 'absolute',
+            inset: '0',
+            width: '100%',
+            height: '100%',
+            zIndex: '20',
+            pointerEvents: 'none', // until a tool activates
+            touchAction: 'none',
+        });
+        this.host.appendChild(this.svg);
+        this.svg.addEventListener('pointerdown', this.onPointerDown);
+        this.svg.addEventListener('pointermove', this.onPointerMove);
+        this.svg.addEventListener('pointerup', this.onPointerUp);
+        this.svg.addEventListener('dblclick', this.onDblClick);
+        this.subs.add(this.store.getRegionUpdateEvent().subscribe(() => this.redraw()));
+        this.subs.add(this.store.getSelectedShapeIndices$().subscribe((idx) => {
+            this.selected = idx ?? [];
+            this.redraw();
+        }));
+        this.disconnectCamera = this.viewer.camera.changed.connect(() => this.redraw());
+        this.redraw();
+    }
+    // ── IRegionOverlay ────────────────────────────────────────────────────────
+    setMode(mode) {
+        this.mode = mode;
+        this.draftRect = null;
+        this.draftPath = null;
+        this.marquee = null;
+        this.clearMarqueeEl();
+        this.drawing = false;
+        // The overlay owns pointer/navigation gating: while a tool is active it captures the pointer
+        // and the napari camera controls are disabled; 'none' hands the pointer back for pan/zoom.
+        const active = mode !== 'none';
+        this.viewer.setControlsEnabled(!active);
+        this.svg.style.pointerEvents = active ? 'auto' : 'none';
+        this.svg.style.cursor = active ? 'crosshair' : 'default';
+        this.redraw();
+    }
+    setSelectedBezier(bezier) {
+        const sel = this.selectedRegion();
+        if (sel?.id != null)
+            this.store.setBezier(sel.id, bezier);
+    }
+    destroy() {
+        this.svg.removeEventListener('pointerdown', this.onPointerDown);
+        this.svg.removeEventListener('pointermove', this.onPointerMove);
+        this.svg.removeEventListener('pointerup', this.onPointerUp);
+        this.svg.removeEventListener('dblclick', this.onDblClick);
+        this.disconnectCamera();
+        this.subs.unsubscribe();
+        if (this.svg.parentNode)
+            this.svg.parentNode.removeChild(this.svg);
+    }
+    // ── coordinate transforms ─────────────────────────────────────────────────
+    /** Pointer client coords → rounded image coords. */
+    toImage(clientX, clientY) {
+        const [wx, wy] = this.viewer.canvasToWorld(clientX, clientY);
+        return [Math.round(wx), Math.round(wy)];
+    }
+    /** Image coords → SVG-local px (the svg overlays the canvas at the same client rect). */
+    toLocal(imgX, imgY) {
+        const [cx, cy] = this.viewer.worldToCanvas(imgX, imgY);
+        const r = this.svg.getBoundingClientRect();
+        return [cx - r.left, cy - r.top];
+    }
+    /** Click-to-place polygon: add a vertex, or close when clicking near the first one. */
+    handlePolygonClick(ix, iy, clientX, clientY) {
+        if (!this.draftPath) {
+            this.draftPath = [[ix, iy]];
+            return;
+        }
+        const [fx, fy] = this.toLocal(this.draftPath[0][0], this.draftPath[0][1]);
+        const r = this.svg.getBoundingClientRect();
+        const near = Math.hypot(clientX - r.left - fx, clientY - r.top - fy) <= CLOSE_SNAP_PX &&
+            this.draftPath.length >= 3;
+        if (near) {
+            const pts = this.draftPath;
+            this.draftPath = null;
+            this.commitPolygon(pts, true);
+        }
+        else {
+            this.draftPath.push([ix, iy]);
+        }
+    }
+    /** The currently-selected region (single selection), or null. */
+    selectedRegion() {
+        const regions = this.store.getRegions();
+        const i = this.selected[0];
+        return i != null && i >= 0 && i < regions.length ? regions[i] : null;
+    }
+    /** Screen distance (px) between a client point and an image coord. */
+    screenDist(clientX, clientY, imgX, imgY) {
+        const [lx, ly] = this.toLocal(imgX, imgY);
+        const r = this.svg.getBoundingClientRect();
+        return Math.hypot(clientX - r.left - lx, clientY - r.top - ly);
+    }
+    /**
+     * Start a select/move interaction: grab a handle (rectangle corner) or vertex of the already-
+     * selected region first; otherwise select the topmost region under the cursor and drag its body.
+     */
+    beginManipulation(ix, iy, e) {
+        const sel = this.selectedRegion();
+        if (sel?.bounds) {
+            const grab = this.hitHandle(sel, e.clientX, e.clientY);
+            if (grab) {
+                this.store.beginBatch();
+                this.edit = { ...grab, id: sel.id, last: [ix, iy] };
+                this.svg.setPointerCapture(e.pointerId);
+                return;
+            }
+        }
+        // Hit-test bodies, topmost first (last drawn renders on top).
+        const regions = this.store.getRegions();
+        for (let i = regions.length - 1; i >= 0; i--) {
+            if (this.hitTest(regions[i], ix, iy)) {
+                this.store.selectRegion(regions[i]);
+                this.store.beginBatch();
+                this.edit = { kind: 'body', id: regions[i].id, last: [ix, iy] };
+                this.svg.setPointerCapture(e.pointerId);
+                return;
+            }
+        }
+        // Empty space: in select mode start a rubber-band marquee (selects the regions it covers on
+        // release); in move mode just clear the selection.
+        if (this.mode === 'select') {
+            this.marquee = { x0: ix, y0: iy, x1: ix, y1: iy };
+            this.updateMarqueeEl();
+            this.svg.setPointerCapture(e.pointerId);
+        }
+        else {
+            this.store.setSelectedShapeIndices([]);
+        }
+    }
+    /** Create/update the marquee rect element directly (avoids a full region redraw per move). */
+    updateMarqueeEl() {
+        if (!this.marquee)
+            return;
+        if (!this.marqueeEl || !this.marqueeEl.parentNode) {
+            this.marqueeEl = document.createElementNS(SVG_NS, 'rect');
+            this.marqueeEl.setAttribute('stroke', '#4da3ff');
+            this.marqueeEl.setAttribute('stroke-width', '1');
+            this.marqueeEl.setAttribute('stroke-dasharray', '4 3');
+            this.marqueeEl.setAttribute('fill', '#4da3ff');
+            this.marqueeEl.setAttribute('fill-opacity', '0.12');
+            this.marqueeEl.setAttribute('vector-effect', 'non-scaling-stroke');
+            this.svg.appendChild(this.marqueeEl);
+        }
+        const { x0, y0, x1, y1 } = this.marquee;
+        const [lx, ly] = this.toLocal(Math.min(x0, x1), Math.min(y0, y1));
+        const [rx, ry] = this.toLocal(Math.max(x0, x1), Math.max(y0, y1));
+        this.marqueeEl.setAttribute('x', `${lx}`);
+        this.marqueeEl.setAttribute('y', `${ly}`);
+        this.marqueeEl.setAttribute('width', `${Math.abs(rx - lx)}`);
+        this.marqueeEl.setAttribute('height', `${Math.abs(ry - ly)}`);
+    }
+    /** Remove the marquee element from the SVG. */
+    clearMarqueeEl() {
+        if (this.marqueeEl?.parentNode)
+            this.marqueeEl.parentNode.removeChild(this.marqueeEl);
+        this.marqueeEl = null;
+    }
+    /** Test whether a client point grabs a rectangle corner or a polygon vertex of `region`. */
+    hitHandle(region, clientX, clientY) {
+        const b = region.bounds;
+        if (!b)
+            return null;
+        if ('width' in b && 'x' in b) {
+            const r = b;
+            const corners = [
+                [r.x, r.y, [r.x + r.width, r.y + r.height]],
+                [r.x + r.width, r.y, [r.x, r.y + r.height]],
+                [r.x, r.y + r.height, [r.x + r.width, r.y]],
+                [r.x + r.width, r.y + r.height, [r.x, r.y]],
+            ];
+            for (const [cx, cy, anchor] of corners) {
+                if (this.screenDist(clientX, clientY, cx, cy) <= HANDLE_HIT_PX)
+                    return { kind: 'corner', anchor };
+            }
+        }
+        else if ('npoints' in b) {
+            const p = b;
+            // Bezier control points first (they sit off the anchors), so they're grabbable.
+            if (p.bezier && p.handlesIn?.length === p.npoints && p.handlesOut?.length === p.npoints) {
+                for (let i = 0; i < p.npoints; i++) {
+                    const out = p.handlesOut[i];
+                    const inn = p.handlesIn[i];
+                    if (this.screenDist(clientX, clientY, p.xpoints[i] + out[0], p.ypoints[i] + out[1]) <= HANDLE_HIT_PX) {
+                        return { kind: 'bezier', vertexIndex: i, side: 'out' };
+                    }
+                    if (this.screenDist(clientX, clientY, p.xpoints[i] + inn[0], p.ypoints[i] + inn[1]) <= HANDLE_HIT_PX) {
+                        return { kind: 'bezier', vertexIndex: i, side: 'in' };
+                    }
+                }
+            }
+            for (let i = 0; i < p.npoints; i++) {
+                if (this.screenDist(clientX, clientY, p.xpoints[i], p.ypoints[i]) <= HANDLE_HIT_PX) {
+                    return { kind: 'vertex', vertexIndex: i };
+                }
+            }
+            // Hole (donut) ring: bezier control points first, then the vertices.
+            const holes = p.holes ?? [];
+            const holeBezier = !!(p.bezier && p.holeHandlesIn && p.holeHandlesOut);
+            for (let hi = 0; hi < holes.length; hi++) {
+                const ring = holes[hi];
+                if (holeBezier && p.holeHandlesIn[hi] && p.holeHandlesOut[hi]) {
+                    for (let vi = 0; vi < ring.length; vi++) {
+                        const out = p.holeHandlesOut[hi][vi] ?? [0, 0];
+                        const inn = p.holeHandlesIn[hi][vi] ?? [0, 0];
+                        if (this.screenDist(clientX, clientY, ring[vi][0] + out[0], ring[vi][1] + out[1]) <= HANDLE_HIT_PX) {
+                            return { kind: 'holebezier', holeIndex: hi, vertexIndex: vi, side: 'out' };
+                        }
+                        if (this.screenDist(clientX, clientY, ring[vi][0] + inn[0], ring[vi][1] + inn[1]) <= HANDLE_HIT_PX) {
+                            return { kind: 'holebezier', holeIndex: hi, vertexIndex: vi, side: 'in' };
+                        }
+                    }
+                }
+                for (let vi = 0; vi < ring.length; vi++) {
+                    if (this.screenDist(clientX, clientY, ring[vi][0], ring[vi][1]) <= HANDLE_HIT_PX) {
+                        return { kind: 'holevertex', holeIndex: hi, vertexIndex: vi };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /** Apply the live drag for the active manipulation (image coords `ix,iy`). */
+    applyManipulation(ix, iy) {
+        if (!this.edit)
+            return;
+        if (this.edit.kind === 'body') {
+            const [lx, ly] = this.edit.last;
+            this.store.moveRegion(this.edit.id, ix - lx, iy - ly);
+            this.edit.last = [ix, iy];
+        }
+        else if (this.edit.kind === 'vertex' && this.edit.vertexIndex != null) {
+            this.store.moveVertex(this.edit.id, this.edit.vertexIndex, ix, iy);
+        }
+        else if (this.edit.kind === 'corner' && this.edit.anchor) {
+            const [ax, ay] = this.edit.anchor;
+            const rect = new Rectangle();
+            rect.x = Math.min(ax, ix);
+            rect.y = Math.min(ay, iy);
+            rect.width = Math.abs(ix - ax);
+            rect.height = Math.abs(iy - ay);
+            this.store.updateBounds(this.edit.id, rect);
+        }
+        else if (this.edit.kind === 'bezier' && this.edit.vertexIndex != null && this.edit.side) {
+            this.store.moveBezierHandle(this.edit.id, this.edit.vertexIndex, this.edit.side, ix, iy);
+        }
+        else if (this.edit.kind === 'holevertex' &&
+            this.edit.holeIndex != null &&
+            this.edit.vertexIndex != null) {
+            this.store.moveHoleVertex(this.edit.id, this.edit.holeIndex, this.edit.vertexIndex, ix, iy);
+        }
+        else if (this.edit.kind === 'holebezier' &&
+            this.edit.holeIndex != null &&
+            this.edit.vertexIndex != null &&
+            this.edit.side) {
+            this.store.moveHoleBezierHandle(this.edit.id, this.edit.holeIndex, this.edit.vertexIndex, this.edit.side, ix, iy);
+        }
+    }
+    /** addpoint mode: insert a vertex on the selected polygon's nearest edge at the click. */
+    handleAddPoint(ix, iy) {
+        const sel = this.selectedRegion();
+        const b = sel?.bounds;
+        if (!sel || !b || !('npoints' in b))
+            return;
+        const p = b;
+        let bestSeg = 0;
+        let bestD = Infinity;
+        const segs = p.closed === false ? p.npoints - 1 : p.npoints;
+        for (let s = 0; s < segs; s++) {
+            const j = (s + 1) % p.npoints;
+            const d = this.pointSegDist(ix, iy, p.xpoints[s], p.ypoints[s], p.xpoints[j], p.ypoints[j]);
+            if (d < bestD) {
+                bestD = d;
+                bestSeg = s;
+            }
+        }
+        this.store.addVertex(sel.id, bestSeg, ix, iy);
+    }
+    /** deletepoint mode: remove the selected polygon's vertex nearest the click. */
+    handleDeletePoint(ix, iy) {
+        const sel = this.selectedRegion();
+        const b = sel?.bounds;
+        if (!sel || !b || !('npoints' in b))
+            return;
+        const p = b;
+        let best = -1;
+        let bestD = Infinity;
+        for (let i = 0; i < p.npoints; i++) {
+            const d = Math.hypot(p.xpoints[i] - ix, p.ypoints[i] - iy);
+            if (d < bestD) {
+                bestD = d;
+                best = i;
+            }
+        }
+        if (best >= 0)
+            this.store.deleteVertex(sel.id, best);
+    }
+    /** Distance from point (px,py) to segment (ax,ay)-(bx,by), in image units. */
+    pointSegDist(px, py, ax, ay, bx, by) {
+        const dx = bx - ax;
+        const dy = by - ay;
+        const len2 = dx * dx + dy * dy || 1;
+        let t = ((px - ax) * dx + (py - ay) * dy) / len2;
+        t = Math.max(0, Math.min(1, t));
+        return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+    }
+    /** Finalize a rubber-band marquee: select every region whose bounding box it overlaps (a tiny
+     *  marquee is treated as a click on empty space → clear the selection). */
+    finishMarquee(m) {
+        const x0 = Math.min(m.x0, m.x1);
+        const x1 = Math.max(m.x0, m.x1);
+        const y0 = Math.min(m.y0, m.y1);
+        const y1 = Math.max(m.y0, m.y1);
+        if (x1 - x0 < 3 && y1 - y0 < 3) {
+            this.store.setSelectedShapeIndices([]);
+            return;
+        }
+        const indices = [];
+        this.store.getRegions().forEach((r, i) => {
+            if (r.isProfile?.())
+                return;
+            const bb = this.regionBBox(r);
+            if (bb && bb.x0 <= x1 && bb.x1 >= x0 && bb.y0 <= y1 && bb.y1 >= y0)
+                indices.push(i);
+        });
+        this.store.setSelectedShapeIndices(indices);
+    }
+    /** A region's bounding box in image coords (rectangle, polygon, or multipolygon), or null. */
+    regionBBox(region) {
+        const b = region.bounds;
+        if (!b)
+            return null;
+        if ('width' in b && 'x' in b) {
+            const r = b;
+            return { x0: r.x, y0: r.y, x1: r.x + r.width, y1: r.y + r.height };
+        }
+        const acc = { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity };
+        const addRing = (xs, ys) => {
+            for (let i = 0; i < xs.length; i++) {
+                if (xs[i] < acc.x0)
+                    acc.x0 = xs[i];
+                if (xs[i] > acc.x1)
+                    acc.x1 = xs[i];
+                if (ys[i] < acc.y0)
+                    acc.y0 = ys[i];
+                if (ys[i] > acc.y1)
+                    acc.y1 = ys[i];
+            }
+        };
+        if ('npoints' in b) {
+            const p = b;
+            addRing(p.xpoints, p.ypoints);
+        }
+        else if ('polygons' in b) {
+            for (const p of b.polygons)
+                addRing(p.xpoints, p.ypoints);
+        }
+        else {
+            return null;
+        }
+        return isFinite(acc.x0) ? acc : null;
+    }
+    // ── shape commit ──────────────────────────────────────────────────────────
+    commitRectangle(x, y, width, height) {
+        const rect = new Rectangle();
+        rect.x = x;
+        rect.y = y;
+        rect.width = width;
+        rect.height = height;
+        const region = new Region();
+        region.bounds = rect;
+        region.color = this.store.getShapeColor();
+        this.store.addRegion(region);
+    }
+    commitPolygon(points, closed) {
+        const poly = new Polygon();
+        poly.npoints = points.length;
+        poly.xpoints = points.map((p) => p[0]);
+        poly.ypoints = points.map((p) => p[1]);
+        poly.coordinates = points.map((p) => [p[0], p[1]]);
+        poly.closed = closed;
+        const region = new Region();
+        region.bounds = poly;
+        region.color = this.store.getShapeColor();
+        region.label = 'Region';
+        this.store.addRegion(region);
+    }
+    // ── rendering ─────────────────────────────────────────────────────────────
+    hitTest(region, x, y) {
+        const b = region.bounds;
+        if (!b)
+            return false;
+        if ('width' in b && 'x' in b) {
+            const r = b;
+            return x >= r.x && x <= r.x + r.width && y >= r.y && y <= r.y + r.height;
+        }
+        if ('npoints' in b) {
+            const p = b;
+            let inside = false;
+            for (let i = 0, j = p.npoints - 1; i < p.npoints; j = i++) {
+                const xi = p.xpoints[i];
+                const yi = p.ypoints[i];
+                const xj = p.xpoints[j];
+                const yj = p.ypoints[j];
+                if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi)
+                    inside = !inside;
+            }
+            return inside;
+        }
+        return false;
+    }
+    redraw() {
+        while (this.svg.firstChild)
+            this.svg.removeChild(this.svg.firstChild);
+        const regions = this.store.getRegions();
+        regions.forEach((region, i) => {
+            if (region.isProfile?.())
+                return;
+            const isSel = this.selected.includes(i);
+            const el = this.buildRegionEl(region, isSel);
+            if (el)
+                this.svg.appendChild(el);
+            this.drawLabel(region);
+            if (isSel)
+                this.drawHandles(region);
+        });
+        this.drawDraft();
+    }
+    /** Draw a region's classification label at its top-left, when labels are enabled (matches OSD). */
+    drawLabel(region) {
+        if (!this.store.getShowShapeLabel() || region.isProfile?.())
+            return;
+        const label = region.label;
+        const b = region.bounds;
+        if (!label || !b)
+            return;
+        let ix;
+        let iy;
+        if ('width' in b && 'x' in b) {
+            ix = b.x;
+            iy = b.y;
+        }
+        else if ('npoints' in b) {
+            const p = b;
+            ix = p.xpoints.reduce((m, x) => Math.min(m, x), Infinity);
+            iy = p.ypoints.reduce((m, y) => Math.min(m, y), Infinity);
+        }
+        else {
+            return;
+        }
+        const [lx, ly] = this.toLocal(ix, iy);
+        const text = document.createElementNS(SVG_NS, 'text');
+        text.setAttribute('x', `${lx}`);
+        text.setAttribute('y', `${ly - 4}`);
+        text.setAttribute('fill', '#fff');
+        text.setAttribute('stroke', '#000');
+        text.setAttribute('stroke-width', '3');
+        text.setAttribute('paint-order', 'stroke');
+        text.setAttribute('font', '12px sans-serif');
+        text.setAttribute('pointer-events', 'none');
+        text.textContent = label;
+        this.svg.appendChild(text);
+    }
+    /** Draw grab handles for the selected region: rectangle corners or polygon vertices. */
+    drawHandles(region) {
+        const b = region.bounds;
+        if (!b)
+            return;
+        const stroke = region.color || this.store.getShapeColor() || '#00ffff';
+        const handle = (imgX, imgY) => {
+            const [lx, ly] = this.toLocal(imgX, imgY);
+            const el = document.createElementNS(SVG_NS, 'rect');
+            el.setAttribute('x', `${lx - HANDLE_SIZE / 2}`);
+            el.setAttribute('y', `${ly - HANDLE_SIZE / 2}`);
+            el.setAttribute('width', `${HANDLE_SIZE}`);
+            el.setAttribute('height', `${HANDLE_SIZE}`);
+            el.setAttribute('fill', '#fff');
+            el.setAttribute('stroke', stroke);
+            el.setAttribute('stroke-width', '1.5');
+            this.svg.appendChild(el);
+        };
+        if ('width' in b && 'x' in b) {
+            const r = b;
+            handle(r.x, r.y);
+            handle(r.x + r.width, r.y);
+            handle(r.x, r.y + r.height);
+            handle(r.x + r.width, r.y + r.height);
+        }
+        else if ('npoints' in b) {
+            const p = b;
+            const isBezier = p.bezier && p.handlesIn?.length === p.npoints && p.handlesOut?.length === p.npoints;
+            for (let i = 0; i < p.npoints; i++)
+                handle(p.xpoints[i], p.ypoints[i]);
+            for (const ring of p.holes ?? [])
+                for (const [hx, hy] of ring)
+                    handle(hx, hy);
+            // Bezier regions also expose their tangent control points (circles) joined to the anchor
+            // by a thin line, matching the OSD overlay's editable bezier handles.
+            if (isBezier) {
+                const hIn = p.handlesIn;
+                const hOut = p.handlesOut;
+                for (let i = 0; i < p.npoints; i++) {
+                    this.drawBezierHandle(p.xpoints[i], p.ypoints[i], hOut[i], stroke);
+                    this.drawBezierHandle(p.xpoints[i], p.ypoints[i], hIn[i], stroke);
+                }
+            }
+            // Donut hole bezier control handles.
+            if (p.bezier && p.holeHandlesIn && p.holeHandlesOut) {
+                (p.holes ?? []).forEach((ring, hi) => {
+                    const hIn = p.holeHandlesIn[hi];
+                    const hOut = p.holeHandlesOut[hi];
+                    if (!hIn || !hOut)
+                        return;
+                    ring.forEach(([hx, hy], vi) => {
+                        this.drawBezierHandle(hx, hy, hOut[vi], stroke);
+                        this.drawBezierHandle(hx, hy, hIn[vi], stroke);
+                    });
+                });
+            }
+        }
+    }
+    /** Draw one bezier control point (anchor + handle offset) as a small circle connected to its
+     *  anchor by a tangent line. `handle` is the [dx,dy] offset from the anchor in image space. */
+    drawBezierHandle(ax, ay, handle, stroke) {
+        if (!handle || (handle[0] === 0 && handle[1] === 0))
+            return;
+        const [alx, aly] = this.toLocal(ax, ay);
+        const [hlx, hly] = this.toLocal(ax + handle[0], ay + handle[1]);
+        const line = document.createElementNS(SVG_NS, 'line');
+        line.setAttribute('x1', `${alx}`);
+        line.setAttribute('y1', `${aly}`);
+        line.setAttribute('x2', `${hlx}`);
+        line.setAttribute('y2', `${hly}`);
+        line.setAttribute('stroke', stroke);
+        line.setAttribute('stroke-width', '1');
+        line.setAttribute('stroke-opacity', '0.7');
+        this.svg.appendChild(line);
+        const dot = document.createElementNS(SVG_NS, 'circle');
+        dot.setAttribute('cx', `${hlx}`);
+        dot.setAttribute('cy', `${hly}`);
+        dot.setAttribute('r', `${HANDLE_SIZE / 2}`);
+        dot.setAttribute('fill', stroke);
+        dot.setAttribute('stroke', '#fff');
+        dot.setAttribute('stroke-width', '1');
+        this.svg.appendChild(dot);
+    }
+    buildRegionEl(region, isSelected) {
+        const b = region.bounds;
+        if (!b)
+            return null;
+        const stroke = region.color || this.store.getShapeColor() || '#00ffff';
+        if ('width' in b && 'x' in b) {
+            const r = b;
+            const [lx, ly] = this.toLocal(r.x, r.y);
+            const [rx, ry] = this.toLocal(r.x + r.width, r.y + r.height);
+            const el = document.createElementNS(SVG_NS, 'rect');
+            el.setAttribute('x', `${Math.min(lx, rx)}`);
+            el.setAttribute('y', `${Math.min(ly, ry)}`);
+            el.setAttribute('width', `${Math.abs(rx - lx)}`);
+            el.setAttribute('height', `${Math.abs(ry - ly)}`);
+            this.style(el, stroke, isSelected);
+            return el;
+        }
+        if ('npoints' in b) {
+            const p = b;
+            const isBezier = !!p.bezier && p.handlesIn?.length === p.npoints && p.handlesOut?.length === p.npoints;
+            const hasHoles = !!(p.holes && p.holes.length);
+            // Bezier or donut (holes) → a single <path>; holes use even-odd fill so they punch through.
+            if (isBezier || hasHoles) {
+                const el = document.createElementNS(SVG_NS, 'path');
+                el.setAttribute('d', this.polygonPathData(p, isBezier));
+                if (hasHoles)
+                    el.setAttribute('fill-rule', 'evenodd');
+                this.style(el, stroke, isSelected);
+                return el;
+            }
+            const pts = p.xpoints
+                .map((_, i) => this.toLocal(p.xpoints[i], p.ypoints[i]).join(','))
+                .join(' ');
+            const el = document.createElementNS(SVG_NS, p.closed === false ? 'polyline' : 'polygon');
+            el.setAttribute('points', pts);
+            this.style(el, stroke, isSelected);
+            return el;
+        }
+        return null;
+    }
+    /** Path data for a polygon: the exterior ring (bezier or straight) plus any holes (bezier when
+     *  the donut carries hole handles, else straight) as sub-paths — even-odd fill cuts them out. */
+    polygonPathData(p, isBezier) {
+        let d = isBezier
+            ? this.ringBezierPath(p.xpoints, p.ypoints, p.handlesIn, p.handlesOut, p.closed !== false)
+            : this.straightPath(p.xpoints, p.ypoints, p.closed !== false);
+        const holeBezier = !!(p.bezier && p.holeHandlesIn && p.holeHandlesOut);
+        (p.holes ?? []).forEach((ring, hi) => {
+            if (ring.length < 3)
+                return;
+            const xs = ring.map((pt) => pt[0]);
+            const ys = ring.map((pt) => pt[1]);
+            if (holeBezier && p.holeHandlesIn[hi] && p.holeHandlesOut[hi]) {
+                d += ' ' + this.ringBezierPath(xs, ys, p.holeHandlesIn[hi], p.holeHandlesOut[hi], true);
+            }
+            else {
+                d += ' ' + this.straightPath(xs, ys, true);
+            }
+        });
+        return d;
+    }
+    /** SVG path data for a straight ring/polyline in image coords (closed appends `Z`). */
+    straightPath(xs, ys, closed) {
+        let d = '';
+        for (let i = 0; i < xs.length; i++) {
+            const [lx, ly] = this.toLocal(xs[i], ys[i]);
+            d += (i === 0 ? 'M' : ' L') + ` ${lx},${ly}`;
+        }
+        return closed ? d + ' Z' : d;
+    }
+    /** SVG cubic-bezier path data for any ring (exterior or hole): anchors joined by cubic segments
+     *  whose control points are `anchor + handleOut` (leaving) and `nextAnchor + handleIn` (arriving),
+     *  in image space. Used for both the exterior and (donut) hole rings. */
+    ringBezierPath(xs, ys, hIn, hOut, closed) {
+        const n = xs.length;
+        const anchor = (i) => this.toLocal(xs[i], ys[i]);
+        const ctrlOut = (i) => this.toLocal(xs[i] + (hOut[i]?.[0] ?? 0), ys[i] + (hOut[i]?.[1] ?? 0));
+        const ctrlIn = (i) => this.toLocal(xs[i] + (hIn[i]?.[0] ?? 0), ys[i] + (hIn[i]?.[1] ?? 0));
+        const [sx, sy] = anchor(0);
+        let d = `M ${sx},${sy}`;
+        const segments = closed ? n : n - 1;
+        for (let s = 0; s < segments; s++) {
+            const i = s;
+            const j = (s + 1) % n;
+            const [c1x, c1y] = ctrlOut(i);
+            const [c2x, c2y] = ctrlIn(j);
+            const [ex, ey] = anchor(j);
+            d += ` C ${c1x},${c1y} ${c2x},${c2y} ${ex},${ey}`;
+        }
+        if (closed)
+            d += ' Z';
+        return d;
+    }
+    style(el, stroke, isSelected) {
+        el.setAttribute('stroke', stroke);
+        el.setAttribute('stroke-width', isSelected ? '4' : '2');
+        el.setAttribute('fill', isSelected ? stroke : 'none');
+        el.setAttribute('fill-opacity', isSelected ? '0.35' : '0');
+        el.setAttribute('vector-effect', 'non-scaling-stroke');
+    }
+    /** Draw the in-progress rectangle / path preview. */
+    drawDraft() {
+        if (this.draftRect) {
+            const { x0, y0, x1, y1 } = this.draftRect;
+            const [lx, ly] = this.toLocal(Math.min(x0, x1), Math.min(y0, y1));
+            const [rx, ry] = this.toLocal(Math.max(x0, x1), Math.max(y0, y1));
+            const el = document.createElementNS(SVG_NS, 'rect');
+            el.setAttribute('x', `${lx}`);
+            el.setAttribute('y', `${ly}`);
+            el.setAttribute('width', `${Math.abs(rx - lx)}`);
+            el.setAttribute('height', `${Math.abs(ry - ly)}`);
+            this.styleDraft(el);
+            this.svg.appendChild(el);
+        }
+        if (this.draftPath && this.draftPath.length) {
+            const pts = this.draftPath.map(([x, y]) => this.toLocal(x, y).join(',')).join(' ');
+            const el = document.createElementNS(SVG_NS, 'polyline');
+            el.setAttribute('points', pts);
+            this.styleDraft(el);
+            this.svg.appendChild(el);
+        }
+    }
+    styleDraft(el) {
+        el.setAttribute('stroke', this.store.getShapeColor() || '#00ffff');
+        el.setAttribute('stroke-width', '2');
+        el.setAttribute('stroke-dasharray', '4 3');
+        el.setAttribute('fill', 'none');
+        el.setAttribute('vector-effect', 'non-scaling-stroke');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-region-overlay.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-region-overlay.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subscription } from 'rxjs';\n\nimport { IRegionOverlay, RegionToolMode } from '../../contracts/region-overlay.contract';\nimport { Region, Rectangle, Polygon } from '../../models/region';\nimport { RegionStore } from '../../store/region-store.service';\n\nconst SVG_NS = 'http://www.w3.org/2000/svg';\n/** Min drag (image px) before a freehand path records another point. */\nconst FREEHAND_STEP = 2;\n/** Click-distance (screen px) within which a polygon click snaps closed onto the first vertex. */\nconst CLOSE_SNAP_PX = 10;\n/** Screen-px hit radius for grabbing a vertex / rectangle corner handle. */\nconst HANDLE_HIT_PX = 9;\n/** Rendered handle size (screen px). */\nconst HANDLE_SIZE = 7;\n\n/** The slice of the napari Viewer the overlay needs (coord transforms + control gating). */\ninterface OverlayViewer {\n  canvasToWorld(clientX: number, clientY: number): [number, number];\n  worldToCanvas(worldX: number, worldY: number): [number, number];\n  setControlsEnabled(enabled: boolean): void;\n  readonly camera: { readonly changed: { connect(listener: () => void): () => void } };\n}\n\n/**\n * SVG region overlay for the napari-js WebGPU image view (jit-ui#102), mirroring the OSD backend's\n * {@link OsdRegionOverlay} but driven by napari's `canvasToWorld`/`worldToCanvas` transforms.\n * Vector shapes are drawn in an absolutely-positioned `<svg>` over the canvas (no need to push\n * them through WebGPU). It writes completed shapes to the shared {@link RegionStore} (so save /\n * undo / export work identically to OSD) and re-renders from the store on every camera move,\n * region change, and selection change.\n *\n * Supports (jit-ui#102): rectangle / polygon / freehand path drawing, click-select and rubber-band\n * marquee select, pan/zoom gating via `setControlsEnabled`, body move, vertex move/add/delete,\n * bezier handle editing, and donut holes (including hole vertex + hole-bezier-handle editing) —\n * full parity with {@link OsdRegionOverlay}.\n */\nexport class NapariRegionOverlay implements IRegionOverlay {\n  private readonly svg: SVGSVGElement;\n  private readonly subs = new Subscription();\n  private readonly disconnectCamera: () => void;\n\n  private mode: RegionToolMode = 'none';\n  private selected: number[] = [];\n\n  /** In-progress drawing state (image-space). */\n  private draftRect: { x0: number; y0: number; x1: number; y1: number } | null = null;\n  /** In-progress rubber-band selection marquee (select mode), image-space. */\n  private marquee: { x0: number; y0: number; x1: number; y1: number } | null = null;\n  /** Dedicated marquee rect element, updated directly during the drag (no full region redraw). */\n  private marqueeEl: SVGRectElement | null = null;\n  private draftPath: Array<[number, number]> | null = null; // freehand or click polygon\n  private drawing = false; // pointer is down for rect / freehand\n\n  /** In-progress manipulation (select/move modes): dragging a body, a polygon vertex, or a\n   *  rectangle corner. `anchor` is the fixed opposite corner for a rectangle resize. */\n  private edit: {\n    kind: 'body' | 'vertex' | 'corner' | 'bezier' | 'holevertex' | 'holebezier';\n    id: number;\n    vertexIndex?: number;\n    holeIndex?: number;\n    side?: 'in' | 'out';\n    anchor?: [number, number];\n    last: [number, number];\n  } | null = null;\n\n  constructor(\n    private readonly host: HTMLElement,\n    private readonly viewer: OverlayViewer,\n    private readonly store: RegionStore,\n  ) {\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n    this.svg = document.createElementNS(SVG_NS, 'svg');\n    Object.assign(this.svg.style, {\n      position: 'absolute',\n      inset: '0',\n      width: '100%',\n      height: '100%',\n      zIndex: '20',\n      pointerEvents: 'none', // until a tool activates\n      touchAction: 'none',\n    } as Partial<CSSStyleDeclaration>);\n    this.host.appendChild(this.svg);\n\n    this.svg.addEventListener('pointerdown', this.onPointerDown);\n    this.svg.addEventListener('pointermove', this.onPointerMove);\n    this.svg.addEventListener('pointerup', this.onPointerUp);\n    this.svg.addEventListener('dblclick', this.onDblClick);\n\n    this.subs.add(this.store.getRegionUpdateEvent().subscribe(() => this.redraw()));\n    this.subs.add(\n      this.store.getSelectedShapeIndices$().subscribe((idx) => {\n        this.selected = idx ?? [];\n        this.redraw();\n      }),\n    );\n    this.disconnectCamera = this.viewer.camera.changed.connect(() => this.redraw());\n    this.redraw();\n  }\n\n  // ── IRegionOverlay ────────────────────────────────────────────────────────\n  setMode(mode: RegionToolMode): void {\n    this.mode = mode;\n    this.draftRect = null;\n    this.draftPath = null;\n    this.marquee = null;\n    this.clearMarqueeEl();\n    this.drawing = false;\n    // The overlay owns pointer/navigation gating: while a tool is active it captures the pointer\n    // and the napari camera controls are disabled; 'none' hands the pointer back for pan/zoom.\n    const active = mode !== 'none';\n    this.viewer.setControlsEnabled(!active);\n    this.svg.style.pointerEvents = active ? 'auto' : 'none';\n    this.svg.style.cursor = active ? 'crosshair' : 'default';\n    this.redraw();\n  }\n\n  setSelectedBezier(bezier: boolean): void {\n    const sel = this.selectedRegion();\n    if (sel?.id != null) this.store.setBezier(sel.id, bezier);\n  }\n\n  destroy(): void {\n    this.svg.removeEventListener('pointerdown', this.onPointerDown);\n    this.svg.removeEventListener('pointermove', this.onPointerMove);\n    this.svg.removeEventListener('pointerup', this.onPointerUp);\n    this.svg.removeEventListener('dblclick', this.onDblClick);\n    this.disconnectCamera();\n    this.subs.unsubscribe();\n    if (this.svg.parentNode) this.svg.parentNode.removeChild(this.svg);\n  }\n\n  // ── coordinate transforms ─────────────────────────────────────────────────\n  /** Pointer client coords → rounded image coords. */\n  private toImage(clientX: number, clientY: number): [number, number] {\n    const [wx, wy] = this.viewer.canvasToWorld(clientX, clientY);\n    return [Math.round(wx), Math.round(wy)];\n  }\n\n  /** Image coords → SVG-local px (the svg overlays the canvas at the same client rect). */\n  private toLocal(imgX: number, imgY: number): [number, number] {\n    const [cx, cy] = this.viewer.worldToCanvas(imgX, imgY);\n    const r = this.svg.getBoundingClientRect();\n    return [cx - r.left, cy - r.top];\n  }\n\n  // ── pointer handlers ──────────────────────────────────────────────────────\n  private readonly onPointerDown = (e: PointerEvent): void => {\n    if (this.mode === 'none') return;\n    e.preventDefault();\n    const [ix, iy] = this.toImage(e.clientX, e.clientY);\n    if (this.mode === 'drawrect') {\n      this.draftRect = { x0: ix, y0: iy, x1: ix, y1: iy };\n      this.drawing = true;\n      this.svg.setPointerCapture(e.pointerId);\n    } else if (this.mode === 'drawclosedpath' || this.mode === 'drawopenpath') {\n      this.draftPath = [[ix, iy]];\n      this.drawing = true;\n      this.svg.setPointerCapture(e.pointerId);\n    } else if (this.mode === 'drawpolygon') {\n      this.handlePolygonClick(ix, iy, e.clientX, e.clientY);\n    } else if (this.mode === 'select' || this.mode === 'move') {\n      this.beginManipulation(ix, iy, e);\n    } else if (this.mode === 'addpoint') {\n      this.handleAddPoint(ix, iy);\n    } else if (this.mode === 'deletepoint') {\n      this.handleDeletePoint(ix, iy);\n    }\n    this.redraw();\n  };\n\n  private readonly onPointerMove = (e: PointerEvent): void => {\n    const [ix, iy] = this.toImage(e.clientX, e.clientY);\n    if (this.marquee) {\n      this.marquee.x1 = ix;\n      this.marquee.y1 = iy;\n      this.updateMarqueeEl(); // update just the marquee rect — NOT a full region redraw\n      return;\n    }\n    if (this.edit) {\n      this.applyManipulation(ix, iy);\n      this.redraw();\n      return;\n    }\n    if (!this.drawing) return;\n    if (this.draftRect) {\n      this.draftRect.x1 = ix;\n      this.draftRect.y1 = iy;\n    } else if (this.draftPath) {\n      const last = this.draftPath[this.draftPath.length - 1];\n      if (Math.abs(ix - last[0]) >= FREEHAND_STEP || Math.abs(iy - last[1]) >= FREEHAND_STEP) {\n        this.draftPath.push([ix, iy]);\n      }\n    }\n    this.redraw();\n  };\n\n  private readonly onPointerUp = (e: PointerEvent): void => {\n    if (this.marquee) {\n      const m = this.marquee;\n      this.marquee = null;\n      this.clearMarqueeEl();\n      try {\n        this.svg.releasePointerCapture(e.pointerId);\n      } catch {\n        /* already released */\n      }\n      this.finishMarquee(m); // setSelectedShapeIndices → one redraw via the selection subscription\n      return;\n    }\n    if (this.edit) {\n      this.store.endBatch();\n      this.edit = null;\n      try {\n        this.svg.releasePointerCapture(e.pointerId);\n      } catch {\n        /* already released */\n      }\n      this.redraw();\n      return;\n    }\n    if (!this.drawing) return;\n    this.drawing = false;\n    try {\n      this.svg.releasePointerCapture(e.pointerId);\n    } catch {\n      /* capture may already be released */\n    }\n    if (this.draftRect) {\n      const { x0, y0, x1, y1 } = this.draftRect;\n      const x = Math.min(x0, x1);\n      const y = Math.min(y0, y1);\n      const w = Math.abs(x1 - x0);\n      const h = Math.abs(y1 - y0);\n      this.draftRect = null;\n      if (w >= 2 && h >= 2) this.commitRectangle(x, y, w, h);\n    } else if (this.draftPath) {\n      const pts = this.draftPath;\n      this.draftPath = null;\n      const closed = this.mode === 'drawclosedpath';\n      if (pts.length >= (closed ? 3 : 2)) this.commitPolygon(pts, closed);\n    }\n    this.redraw();\n  };\n\n  /** Click-to-place polygon: add a vertex, or close when clicking near the first one. */\n  private handlePolygonClick(ix: number, iy: number, clientX: number, clientY: number): void {\n    if (!this.draftPath) {\n      this.draftPath = [[ix, iy]];\n      return;\n    }\n    const [fx, fy] = this.toLocal(this.draftPath[0][0], this.draftPath[0][1]);\n    const r = this.svg.getBoundingClientRect();\n    const near =\n      Math.hypot(clientX - r.left - fx, clientY - r.top - fy) <= CLOSE_SNAP_PX &&\n      this.draftPath.length >= 3;\n    if (near) {\n      const pts = this.draftPath;\n      this.draftPath = null;\n      this.commitPolygon(pts, true);\n    } else {\n      this.draftPath.push([ix, iy]);\n    }\n  }\n\n  private readonly onDblClick = (e: MouseEvent): void => {\n    if (this.mode !== 'drawpolygon' || !this.draftPath) return;\n    e.preventDefault();\n    const pts = this.draftPath;\n    this.draftPath = null;\n    if (pts.length >= 3) this.commitPolygon(pts, true);\n    this.redraw();\n  };\n\n  /** The currently-selected region (single selection), or null. */\n  private selectedRegion(): Region | null {\n    const regions = this.store.getRegions();\n    const i = this.selected[0];\n    return i != null && i >= 0 && i < regions.length ? regions[i] : null;\n  }\n\n  /** Screen distance (px) between a client point and an image coord. */\n  private screenDist(clientX: number, clientY: number, imgX: number, imgY: number): number {\n    const [lx, ly] = this.toLocal(imgX, imgY);\n    const r = this.svg.getBoundingClientRect();\n    return Math.hypot(clientX - r.left - lx, clientY - r.top - ly);\n  }\n\n  /**\n   * Start a select/move interaction: grab a handle (rectangle corner) or vertex of the already-\n   * selected region first; otherwise select the topmost region under the cursor and drag its body.\n   */\n  private beginManipulation(ix: number, iy: number, e: PointerEvent): void {\n    const sel = this.selectedRegion();\n    if (sel?.bounds) {\n      const grab = this.hitHandle(sel, e.clientX, e.clientY);\n      if (grab) {\n        this.store.beginBatch();\n        this.edit = { ...grab, id: sel.id, last: [ix, iy] };\n        this.svg.setPointerCapture(e.pointerId);\n        return;\n      }\n    }\n    // Hit-test bodies, topmost first (last drawn renders on top).\n    const regions = this.store.getRegions();\n    for (let i = regions.length - 1; i >= 0; i--) {\n      if (this.hitTest(regions[i], ix, iy)) {\n        this.store.selectRegion(regions[i]);\n        this.store.beginBatch();\n        this.edit = { kind: 'body', id: regions[i].id, last: [ix, iy] };\n        this.svg.setPointerCapture(e.pointerId);\n        return;\n      }\n    }\n    // Empty space: in select mode start a rubber-band marquee (selects the regions it covers on\n    // release); in move mode just clear the selection.\n    if (this.mode === 'select') {\n      this.marquee = { x0: ix, y0: iy, x1: ix, y1: iy };\n      this.updateMarqueeEl();\n      this.svg.setPointerCapture(e.pointerId);\n    } else {\n      this.store.setSelectedShapeIndices([]);\n    }\n  }\n\n  /** Create/update the marquee rect element directly (avoids a full region redraw per move). */\n  private updateMarqueeEl(): void {\n    if (!this.marquee) return;\n    if (!this.marqueeEl || !this.marqueeEl.parentNode) {\n      this.marqueeEl = document.createElementNS(SVG_NS, 'rect');\n      this.marqueeEl.setAttribute('stroke', '#4da3ff');\n      this.marqueeEl.setAttribute('stroke-width', '1');\n      this.marqueeEl.setAttribute('stroke-dasharray', '4 3');\n      this.marqueeEl.setAttribute('fill', '#4da3ff');\n      this.marqueeEl.setAttribute('fill-opacity', '0.12');\n      this.marqueeEl.setAttribute('vector-effect', 'non-scaling-stroke');\n      this.svg.appendChild(this.marqueeEl);\n    }\n    const { x0, y0, x1, y1 } = this.marquee;\n    const [lx, ly] = this.toLocal(Math.min(x0, x1), Math.min(y0, y1));\n    const [rx, ry] = this.toLocal(Math.max(x0, x1), Math.max(y0, y1));\n    this.marqueeEl.setAttribute('x', `${lx}`);\n    this.marqueeEl.setAttribute('y', `${ly}`);\n    this.marqueeEl.setAttribute('width', `${Math.abs(rx - lx)}`);\n    this.marqueeEl.setAttribute('height', `${Math.abs(ry - ly)}`);\n  }\n\n  /** Remove the marquee element from the SVG. */\n  private clearMarqueeEl(): void {\n    if (this.marqueeEl?.parentNode) this.marqueeEl.parentNode.removeChild(this.marqueeEl);\n    this.marqueeEl = null;\n  }\n\n  /** Test whether a client point grabs a rectangle corner or a polygon vertex of `region`. */\n  private hitHandle(\n    region: Region,\n    clientX: number,\n    clientY: number,\n  ):\n    | { kind: 'corner'; anchor: [number, number] }\n    | { kind: 'vertex'; vertexIndex: number }\n    | { kind: 'bezier'; vertexIndex: number; side: 'in' | 'out' }\n    | { kind: 'holevertex'; holeIndex: number; vertexIndex: number }\n    | { kind: 'holebezier'; holeIndex: number; vertexIndex: number; side: 'in' | 'out' }\n    | null {\n    const b = region.bounds;\n    if (!b) return null;\n    if ('width' in b && 'x' in b) {\n      const r = b as Rectangle;\n      const corners: Array<[number, number, [number, number]]> = [\n        [r.x, r.y, [r.x + r.width, r.y + r.height]],\n        [r.x + r.width, r.y, [r.x, r.y + r.height]],\n        [r.x, r.y + r.height, [r.x + r.width, r.y]],\n        [r.x + r.width, r.y + r.height, [r.x, r.y]],\n      ];\n      for (const [cx, cy, anchor] of corners) {\n        if (this.screenDist(clientX, clientY, cx, cy) <= HANDLE_HIT_PX) return { kind: 'corner', anchor };\n      }\n    } else if ('npoints' in b) {\n      const p = b as Polygon;\n      // Bezier control points first (they sit off the anchors), so they're grabbable.\n      if (p.bezier && p.handlesIn?.length === p.npoints && p.handlesOut?.length === p.npoints) {\n        for (let i = 0; i < p.npoints; i++) {\n          const out = p.handlesOut[i];\n          const inn = p.handlesIn[i];\n          if (this.screenDist(clientX, clientY, p.xpoints[i] + out[0], p.ypoints[i] + out[1]) <= HANDLE_HIT_PX) {\n            return { kind: 'bezier', vertexIndex: i, side: 'out' };\n          }\n          if (this.screenDist(clientX, clientY, p.xpoints[i] + inn[0], p.ypoints[i] + inn[1]) <= HANDLE_HIT_PX) {\n            return { kind: 'bezier', vertexIndex: i, side: 'in' };\n          }\n        }\n      }\n      for (let i = 0; i < p.npoints; i++) {\n        if (this.screenDist(clientX, clientY, p.xpoints[i], p.ypoints[i]) <= HANDLE_HIT_PX) {\n          return { kind: 'vertex', vertexIndex: i };\n        }\n      }\n      // Hole (donut) ring: bezier control points first, then the vertices.\n      const holes = p.holes ?? [];\n      const holeBezier = !!(p.bezier && p.holeHandlesIn && p.holeHandlesOut);\n      for (let hi = 0; hi < holes.length; hi++) {\n        const ring = holes[hi];\n        if (holeBezier && p.holeHandlesIn![hi] && p.holeHandlesOut![hi]) {\n          for (let vi = 0; vi < ring.length; vi++) {\n            const out = p.holeHandlesOut![hi][vi] ?? [0, 0];\n            const inn = p.holeHandlesIn![hi][vi] ?? [0, 0];\n            if (this.screenDist(clientX, clientY, ring[vi][0] + out[0], ring[vi][1] + out[1]) <= HANDLE_HIT_PX) {\n              return { kind: 'holebezier', holeIndex: hi, vertexIndex: vi, side: 'out' };\n            }\n            if (this.screenDist(clientX, clientY, ring[vi][0] + inn[0], ring[vi][1] + inn[1]) <= HANDLE_HIT_PX) {\n              return { kind: 'holebezier', holeIndex: hi, vertexIndex: vi, side: 'in' };\n            }\n          }\n        }\n        for (let vi = 0; vi < ring.length; vi++) {\n          if (this.screenDist(clientX, clientY, ring[vi][0], ring[vi][1]) <= HANDLE_HIT_PX) {\n            return { kind: 'holevertex', holeIndex: hi, vertexIndex: vi };\n          }\n        }\n      }\n    }\n    return null;\n  }\n\n  /** Apply the live drag for the active manipulation (image coords `ix,iy`). */\n  private applyManipulation(ix: number, iy: number): void {\n    if (!this.edit) return;\n    if (this.edit.kind === 'body') {\n      const [lx, ly] = this.edit.last;\n      this.store.moveRegion(this.edit.id, ix - lx, iy - ly);\n      this.edit.last = [ix, iy];\n    } else if (this.edit.kind === 'vertex' && this.edit.vertexIndex != null) {\n      this.store.moveVertex(this.edit.id, this.edit.vertexIndex, ix, iy);\n    } else if (this.edit.kind === 'corner' && this.edit.anchor) {\n      const [ax, ay] = this.edit.anchor;\n      const rect = new Rectangle();\n      rect.x = Math.min(ax, ix);\n      rect.y = Math.min(ay, iy);\n      rect.width = Math.abs(ix - ax);\n      rect.height = Math.abs(iy - ay);\n      this.store.updateBounds(this.edit.id, rect);\n    } else if (this.edit.kind === 'bezier' && this.edit.vertexIndex != null && this.edit.side) {\n      this.store.moveBezierHandle(this.edit.id, this.edit.vertexIndex, this.edit.side, ix, iy);\n    } else if (\n      this.edit.kind === 'holevertex' &&\n      this.edit.holeIndex != null &&\n      this.edit.vertexIndex != null\n    ) {\n      this.store.moveHoleVertex(this.edit.id, this.edit.holeIndex, this.edit.vertexIndex, ix, iy);\n    } else if (\n      this.edit.kind === 'holebezier' &&\n      this.edit.holeIndex != null &&\n      this.edit.vertexIndex != null &&\n      this.edit.side\n    ) {\n      this.store.moveHoleBezierHandle(\n        this.edit.id,\n        this.edit.holeIndex,\n        this.edit.vertexIndex,\n        this.edit.side,\n        ix,\n        iy,\n      );\n    }\n  }\n\n  /** addpoint mode: insert a vertex on the selected polygon's nearest edge at the click. */\n  private handleAddPoint(ix: number, iy: number): void {\n    const sel = this.selectedRegion();\n    const b = sel?.bounds;\n    if (!sel || !b || !('npoints' in b)) return;\n    const p = b as Polygon;\n    let bestSeg = 0;\n    let bestD = Infinity;\n    const segs = p.closed === false ? p.npoints - 1 : p.npoints;\n    for (let s = 0; s < segs; s++) {\n      const j = (s + 1) % p.npoints;\n      const d = this.pointSegDist(ix, iy, p.xpoints[s], p.ypoints[s], p.xpoints[j], p.ypoints[j]);\n      if (d < bestD) {\n        bestD = d;\n        bestSeg = s;\n      }\n    }\n    this.store.addVertex(sel.id, bestSeg, ix, iy);\n  }\n\n  /** deletepoint mode: remove the selected polygon's vertex nearest the click. */\n  private handleDeletePoint(ix: number, iy: number): void {\n    const sel = this.selectedRegion();\n    const b = sel?.bounds;\n    if (!sel || !b || !('npoints' in b)) return;\n    const p = b as Polygon;\n    let best = -1;\n    let bestD = Infinity;\n    for (let i = 0; i < p.npoints; i++) {\n      const d = Math.hypot(p.xpoints[i] - ix, p.ypoints[i] - iy);\n      if (d < bestD) {\n        bestD = d;\n        best = i;\n      }\n    }\n    if (best >= 0) this.store.deleteVertex(sel.id, best);\n  }\n\n  /** Distance from point (px,py) to segment (ax,ay)-(bx,by), in image units. */\n  private pointSegDist(\n    px: number,\n    py: number,\n    ax: number,\n    ay: number,\n    bx: number,\n    by: number,\n  ): number {\n    const dx = bx - ax;\n    const dy = by - ay;\n    const len2 = dx * dx + dy * dy || 1;\n    let t = ((px - ax) * dx + (py - ay) * dy) / len2;\n    t = Math.max(0, Math.min(1, t));\n    return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));\n  }\n\n  /** Finalize a rubber-band marquee: select every region whose bounding box it overlaps (a tiny\n   *  marquee is treated as a click on empty space → clear the selection). */\n  private finishMarquee(m: { x0: number; y0: number; x1: number; y1: number }): void {\n    const x0 = Math.min(m.x0, m.x1);\n    const x1 = Math.max(m.x0, m.x1);\n    const y0 = Math.min(m.y0, m.y1);\n    const y1 = Math.max(m.y0, m.y1);\n    if (x1 - x0 < 3 && y1 - y0 < 3) {\n      this.store.setSelectedShapeIndices([]);\n      return;\n    }\n    const indices: number[] = [];\n    this.store.getRegions().forEach((r, i) => {\n      if (r.isProfile?.()) return;\n      const bb = this.regionBBox(r);\n      if (bb && bb.x0 <= x1 && bb.x1 >= x0 && bb.y0 <= y1 && bb.y1 >= y0) indices.push(i);\n    });\n    this.store.setSelectedShapeIndices(indices);\n  }\n\n  /** A region's bounding box in image coords (rectangle, polygon, or multipolygon), or null. */\n  private regionBBox(\n    region: Region,\n  ): { x0: number; y0: number; x1: number; y1: number } | null {\n    const b = region.bounds;\n    if (!b) return null;\n    if ('width' in b && 'x' in b) {\n      const r = b as Rectangle;\n      return { x0: r.x, y0: r.y, x1: r.x + r.width, y1: r.y + r.height };\n    }\n    const acc = { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity };\n    const addRing = (xs: number[], ys: number[]): void => {\n      for (let i = 0; i < xs.length; i++) {\n        if (xs[i] < acc.x0) acc.x0 = xs[i];\n        if (xs[i] > acc.x1) acc.x1 = xs[i];\n        if (ys[i] < acc.y0) acc.y0 = ys[i];\n        if (ys[i] > acc.y1) acc.y1 = ys[i];\n      }\n    };\n    if ('npoints' in b) {\n      const p = b as Polygon;\n      addRing(p.xpoints, p.ypoints);\n    } else if ('polygons' in b) {\n      for (const p of (b as { polygons: Polygon[] }).polygons) addRing(p.xpoints, p.ypoints);\n    } else {\n      return null;\n    }\n    return isFinite(acc.x0) ? acc : null;\n  }\n\n  // ── shape commit ──────────────────────────────────────────────────────────\n  private commitRectangle(x: number, y: number, width: number, height: number): void {\n    const rect = new Rectangle();\n    rect.x = x;\n    rect.y = y;\n    rect.width = width;\n    rect.height = height;\n    const region = new Region();\n    region.bounds = rect;\n    region.color = this.store.getShapeColor();\n    this.store.addRegion(region);\n  }\n\n  private commitPolygon(points: Array<[number, number]>, closed: boolean): void {\n    const poly = new Polygon();\n    poly.npoints = points.length;\n    poly.xpoints = points.map((p) => p[0]);\n    poly.ypoints = points.map((p) => p[1]);\n    poly.coordinates = points.map((p) => [p[0], p[1]]);\n    poly.closed = closed;\n    const region = new Region();\n    region.bounds = poly;\n    region.color = this.store.getShapeColor();\n    region.label = 'Region';\n    this.store.addRegion(region);\n  }\n\n  // ── rendering ─────────────────────────────────────────────────────────────\n  private hitTest(region: Region, x: number, y: number): boolean {\n    const b = region.bounds;\n    if (!b) return false;\n    if ('width' in b && 'x' in b) {\n      const r = b as Rectangle;\n      return x >= r.x && x <= r.x + r.width && y >= r.y && y <= r.y + r.height;\n    }\n    if ('npoints' in b) {\n      const p = b as Polygon;\n      let inside = false;\n      for (let i = 0, j = p.npoints - 1; i < p.npoints; j = i++) {\n        const xi = p.xpoints[i];\n        const yi = p.ypoints[i];\n        const xj = p.xpoints[j];\n        const yj = p.ypoints[j];\n        if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi) inside = !inside;\n      }\n      return inside;\n    }\n    return false;\n  }\n\n  redraw(): void {\n    while (this.svg.firstChild) this.svg.removeChild(this.svg.firstChild);\n    const regions = this.store.getRegions();\n    regions.forEach((region, i) => {\n      if (region.isProfile?.()) return;\n      const isSel = this.selected.includes(i);\n      const el = this.buildRegionEl(region, isSel);\n      if (el) this.svg.appendChild(el);\n      this.drawLabel(region);\n      if (isSel) this.drawHandles(region);\n    });\n    this.drawDraft();\n  }\n\n  /** Draw a region's classification label at its top-left, when labels are enabled (matches OSD). */\n  private drawLabel(region: Region): void {\n    if (!this.store.getShowShapeLabel() || region.isProfile?.()) return;\n    const label = region.label;\n    const b = region.bounds;\n    if (!label || !b) return;\n    let ix: number;\n    let iy: number;\n    if ('width' in b && 'x' in b) {\n      ix = (b as Rectangle).x;\n      iy = (b as Rectangle).y;\n    } else if ('npoints' in b) {\n      const p = b as Polygon;\n      ix = p.xpoints.reduce((m, x) => Math.min(m, x), Infinity);\n      iy = p.ypoints.reduce((m, y) => Math.min(m, y), Infinity);\n    } else {\n      return;\n    }\n    const [lx, ly] = this.toLocal(ix, iy);\n    const text = document.createElementNS(SVG_NS, 'text');\n    text.setAttribute('x', `${lx}`);\n    text.setAttribute('y', `${ly - 4}`);\n    text.setAttribute('fill', '#fff');\n    text.setAttribute('stroke', '#000');\n    text.setAttribute('stroke-width', '3');\n    text.setAttribute('paint-order', 'stroke');\n    text.setAttribute('font', '12px sans-serif');\n    text.setAttribute('pointer-events', 'none');\n    text.textContent = label;\n    this.svg.appendChild(text);\n  }\n\n  /** Draw grab handles for the selected region: rectangle corners or polygon vertices. */\n  private drawHandles(region: Region): void {\n    const b = region.bounds;\n    if (!b) return;\n    const stroke = region.color || this.store.getShapeColor() || '#00ffff';\n    const handle = (imgX: number, imgY: number): void => {\n      const [lx, ly] = this.toLocal(imgX, imgY);\n      const el = document.createElementNS(SVG_NS, 'rect');\n      el.setAttribute('x', `${lx - HANDLE_SIZE / 2}`);\n      el.setAttribute('y', `${ly - HANDLE_SIZE / 2}`);\n      el.setAttribute('width', `${HANDLE_SIZE}`);\n      el.setAttribute('height', `${HANDLE_SIZE}`);\n      el.setAttribute('fill', '#fff');\n      el.setAttribute('stroke', stroke);\n      el.setAttribute('stroke-width', '1.5');\n      this.svg.appendChild(el);\n    };\n    if ('width' in b && 'x' in b) {\n      const r = b as Rectangle;\n      handle(r.x, r.y);\n      handle(r.x + r.width, r.y);\n      handle(r.x, r.y + r.height);\n      handle(r.x + r.width, r.y + r.height);\n    } else if ('npoints' in b) {\n      const p = b as Polygon;\n      const isBezier = p.bezier && p.handlesIn?.length === p.npoints && p.handlesOut?.length === p.npoints;\n      for (let i = 0; i < p.npoints; i++) handle(p.xpoints[i], p.ypoints[i]);\n      for (const ring of p.holes ?? []) for (const [hx, hy] of ring) handle(hx, hy);\n      // Bezier regions also expose their tangent control points (circles) joined to the anchor\n      // by a thin line, matching the OSD overlay's editable bezier handles.\n      if (isBezier) {\n        const hIn = p.handlesIn as number[][];\n        const hOut = p.handlesOut as number[][];\n        for (let i = 0; i < p.npoints; i++) {\n          this.drawBezierHandle(p.xpoints[i], p.ypoints[i], hOut[i], stroke);\n          this.drawBezierHandle(p.xpoints[i], p.ypoints[i], hIn[i], stroke);\n        }\n      }\n      // Donut hole bezier control handles.\n      if (p.bezier && p.holeHandlesIn && p.holeHandlesOut) {\n        (p.holes ?? []).forEach((ring, hi) => {\n          const hIn = p.holeHandlesIn![hi];\n          const hOut = p.holeHandlesOut![hi];\n          if (!hIn || !hOut) return;\n          ring.forEach(([hx, hy], vi) => {\n            this.drawBezierHandle(hx, hy, hOut[vi], stroke);\n            this.drawBezierHandle(hx, hy, hIn[vi], stroke);\n          });\n        });\n      }\n    }\n  }\n\n  /** Draw one bezier control point (anchor + handle offset) as a small circle connected to its\n   *  anchor by a tangent line. `handle` is the [dx,dy] offset from the anchor in image space. */\n  private drawBezierHandle(ax: number, ay: number, handle: number[], stroke: string): void {\n    if (!handle || (handle[0] === 0 && handle[1] === 0)) return;\n    const [alx, aly] = this.toLocal(ax, ay);\n    const [hlx, hly] = this.toLocal(ax + handle[0], ay + handle[1]);\n    const line = document.createElementNS(SVG_NS, 'line');\n    line.setAttribute('x1', `${alx}`);\n    line.setAttribute('y1', `${aly}`);\n    line.setAttribute('x2', `${hlx}`);\n    line.setAttribute('y2', `${hly}`);\n    line.setAttribute('stroke', stroke);\n    line.setAttribute('stroke-width', '1');\n    line.setAttribute('stroke-opacity', '0.7');\n    this.svg.appendChild(line);\n    const dot = document.createElementNS(SVG_NS, 'circle');\n    dot.setAttribute('cx', `${hlx}`);\n    dot.setAttribute('cy', `${hly}`);\n    dot.setAttribute('r', `${HANDLE_SIZE / 2}`);\n    dot.setAttribute('fill', stroke);\n    dot.setAttribute('stroke', '#fff');\n    dot.setAttribute('stroke-width', '1');\n    this.svg.appendChild(dot);\n  }\n\n  private buildRegionEl(region: Region, isSelected: boolean): SVGElement | null {\n    const b = region.bounds;\n    if (!b) return null;\n    const stroke = region.color || this.store.getShapeColor() || '#00ffff';\n    if ('width' in b && 'x' in b) {\n      const r = b as Rectangle;\n      const [lx, ly] = this.toLocal(r.x, r.y);\n      const [rx, ry] = this.toLocal(r.x + r.width, r.y + r.height);\n      const el = document.createElementNS(SVG_NS, 'rect');\n      el.setAttribute('x', `${Math.min(lx, rx)}`);\n      el.setAttribute('y', `${Math.min(ly, ry)}`);\n      el.setAttribute('width', `${Math.abs(rx - lx)}`);\n      el.setAttribute('height', `${Math.abs(ry - ly)}`);\n      this.style(el, stroke, isSelected);\n      return el;\n    }\n    if ('npoints' in b) {\n      const p = b as Polygon;\n      const isBezier =\n        !!p.bezier && p.handlesIn?.length === p.npoints && p.handlesOut?.length === p.npoints;\n      const hasHoles = !!(p.holes && p.holes.length);\n      // Bezier or donut (holes) → a single <path>; holes use even-odd fill so they punch through.\n      if (isBezier || hasHoles) {\n        const el = document.createElementNS(SVG_NS, 'path');\n        el.setAttribute('d', this.polygonPathData(p, isBezier));\n        if (hasHoles) el.setAttribute('fill-rule', 'evenodd');\n        this.style(el, stroke, isSelected);\n        return el;\n      }\n      const pts = p.xpoints\n        .map((_, i) => this.toLocal(p.xpoints[i], p.ypoints[i]).join(','))\n        .join(' ');\n      const el = document.createElementNS(SVG_NS, p.closed === false ? 'polyline' : 'polygon');\n      el.setAttribute('points', pts);\n      this.style(el, stroke, isSelected);\n      return el;\n    }\n    return null;\n  }\n\n  /** Path data for a polygon: the exterior ring (bezier or straight) plus any holes (bezier when\n   *  the donut carries hole handles, else straight) as sub-paths — even-odd fill cuts them out. */\n  private polygonPathData(p: Polygon, isBezier: boolean): string {\n    let d = isBezier\n      ? this.ringBezierPath(p.xpoints, p.ypoints, p.handlesIn!, p.handlesOut!, p.closed !== false)\n      : this.straightPath(p.xpoints, p.ypoints, p.closed !== false);\n    const holeBezier = !!(p.bezier && p.holeHandlesIn && p.holeHandlesOut);\n    (p.holes ?? []).forEach((ring, hi) => {\n      if (ring.length < 3) return;\n      const xs = ring.map((pt) => pt[0]);\n      const ys = ring.map((pt) => pt[1]);\n      if (holeBezier && p.holeHandlesIn![hi] && p.holeHandlesOut![hi]) {\n        d += ' ' + this.ringBezierPath(xs, ys, p.holeHandlesIn![hi], p.holeHandlesOut![hi], true);\n      } else {\n        d += ' ' + this.straightPath(xs, ys, true);\n      }\n    });\n    return d;\n  }\n\n  /** SVG path data for a straight ring/polyline in image coords (closed appends `Z`). */\n  private straightPath(xs: number[], ys: number[], closed: boolean): string {\n    let d = '';\n    for (let i = 0; i < xs.length; i++) {\n      const [lx, ly] = this.toLocal(xs[i], ys[i]);\n      d += (i === 0 ? 'M' : ' L') + ` ${lx},${ly}`;\n    }\n    return closed ? d + ' Z' : d;\n  }\n\n  /** SVG cubic-bezier path data for any ring (exterior or hole): anchors joined by cubic segments\n   *  whose control points are `anchor + handleOut` (leaving) and `nextAnchor + handleIn` (arriving),\n   *  in image space. Used for both the exterior and (donut) hole rings. */\n  private ringBezierPath(\n    xs: number[],\n    ys: number[],\n    hIn: number[][],\n    hOut: number[][],\n    closed: boolean,\n  ): string {\n    const n = xs.length;\n    const anchor = (i: number): [number, number] => this.toLocal(xs[i], ys[i]);\n    const ctrlOut = (i: number): [number, number] =>\n      this.toLocal(xs[i] + (hOut[i]?.[0] ?? 0), ys[i] + (hOut[i]?.[1] ?? 0));\n    const ctrlIn = (i: number): [number, number] =>\n      this.toLocal(xs[i] + (hIn[i]?.[0] ?? 0), ys[i] + (hIn[i]?.[1] ?? 0));\n    const [sx, sy] = anchor(0);\n    let d = `M ${sx},${sy}`;\n    const segments = closed ? n : n - 1;\n    for (let s = 0; s < segments; s++) {\n      const i = s;\n      const j = (s + 1) % n;\n      const [c1x, c1y] = ctrlOut(i);\n      const [c2x, c2y] = ctrlIn(j);\n      const [ex, ey] = anchor(j);\n      d += ` C ${c1x},${c1y} ${c2x},${c2y} ${ex},${ey}`;\n    }\n    if (closed) d += ' Z';\n    return d;\n  }\n\n  private style(el: SVGElement, stroke: string, isSelected: boolean): void {\n    el.setAttribute('stroke', stroke);\n    el.setAttribute('stroke-width', isSelected ? '4' : '2');\n    el.setAttribute('fill', isSelected ? stroke : 'none');\n    el.setAttribute('fill-opacity', isSelected ? '0.35' : '0');\n    el.setAttribute('vector-effect', 'non-scaling-stroke');\n  }\n\n  /** Draw the in-progress rectangle / path preview. */\n  private drawDraft(): void {\n    if (this.draftRect) {\n      const { x0, y0, x1, y1 } = this.draftRect;\n      const [lx, ly] = this.toLocal(Math.min(x0, x1), Math.min(y0, y1));\n      const [rx, ry] = this.toLocal(Math.max(x0, x1), Math.max(y0, y1));\n      const el = document.createElementNS(SVG_NS, 'rect');\n      el.setAttribute('x', `${lx}`);\n      el.setAttribute('y', `${ly}`);\n      el.setAttribute('width', `${Math.abs(rx - lx)}`);\n      el.setAttribute('height', `${Math.abs(ry - ly)}`);\n      this.styleDraft(el);\n      this.svg.appendChild(el);\n    }\n    if (this.draftPath && this.draftPath.length) {\n      const pts = this.draftPath.map(([x, y]) => this.toLocal(x, y).join(',')).join(' ');\n      const el = document.createElementNS(SVG_NS, 'polyline');\n      el.setAttribute('points', pts);\n      this.styleDraft(el);\n      this.svg.appendChild(el);\n    }\n  }\n\n  private styleDraft(el: SVGElement): void {\n    el.setAttribute('stroke', this.store.getShapeColor() || '#00ffff');\n    el.setAttribute('stroke-width', '2');\n    el.setAttribute('stroke-dasharray', '4 3');\n    el.setAttribute('fill', 'none');\n    el.setAttribute('vector-effect', 'non-scaling-stroke');\n  }\n}\n"]}