copper3d 3.6.9 → 3.6.10

package/dist/bundle.esm.js

@@ -59646,6 +59646,25 @@ function makePointMarker(v, mesh, color, radius) {
     m.position.copy(p.addScaledVector(n, radius * 0.5));
     m.renderOrder = 999;
     return m;
+}
+/**
+ * Create a draggable ANCHOR HANDLE (for the geodesic editor): a white outer rim around a
+ * tool-colored core, so the handle stands out against both the (same-colored) contour line and the
+ * grey surface. Returned as a Group; scale it to show hover/selection feedback. depthTest stays ON
+ * (occluded by the model on the far side) and it's lifted a touch more than a plain marker so it
+ * sits above the thickened line rather than sinking into it.
+ */
+function makeAnchorHandle(v, mesh, coreColor, radius) {
+    const g = new Group();
+    const rim = new Mesh(new SphereGeometry(radius, 16, 16), new MeshBasicMaterial({ color: "#ffffff" }));
+    rim.renderOrder = 1000;
+    const core = new Mesh(new SphereGeometry(radius * 0.6, 16, 16), new MeshBasicMaterial({ color: coreColor }));
+    core.renderOrder = 1001;
+    g.add(rim);
+    g.add(core);
+    const { p, n } = localVertexToWorld(v, mesh);
+    g.position.copy(p.addScaledVector(n, radius * 0.7));
+    return g;
 }
 
 /**
@@ -61273,6 +61292,60 @@ class GeodesicContour {
         }
         this.anchors.push(v);
     }
+    /** Move the anchor at `index` to the vertex nearest `localHitPoint`, rebuilding adjacent segments live. */
+    moveAnchorTo(index, localHitPoint) {
+        if (index < 0 || index >= this.anchors.length)
+            return;
+        this.snapshot();
+        this.anchors[index] = this.graph.nearestVertex(localHitPoint);
+        this.rebuildSegments();
+    }
+    /** Anchor vertex indices (persisted on a committed geodesic so it can be re-opened for editing). */
+    getAnchorIndices() {
+        return this.anchors.slice();
+    }
+    /** Rebuild an editable contour from stored anchor vertex indices (re-opening a committed geodesic). */
+    static fromAnchors(graph, mesh, indices) {
+        const gc = new GeodesicContour(graph, mesh);
+        gc.anchors = indices.slice();
+        gc.rebuildSegments();
+        return gc;
+    }
+    /** Insert a new anchor (snapped to the nearest vertex) at position `index`, rebuilding segments. */
+    insertAnchorAt(index, localHitPoint) {
+        const v = this.graph.nearestVertex(localHitPoint);
+        this.snapshot();
+        const i = Math.max(0, Math.min(index, this.anchors.length));
+        this.anchors.splice(i, 0, v);
+        this.rebuildSegments();
+    }
+    /**
+     * Which anchor interval's surface path passes closest to `worldPoint` — i.e. the edge the user
+     * clicked on, so a new anchor can be inserted there. Returns the interval index (insert after that
+     * anchor, i.e. at index+1), or -1 when there are fewer than 2 anchors or the click is farther than
+     * `maxDist` (world units) from every edge. For a closed contour the trailing closing edge
+     * (last→first) is considered and maps to appending at the end.
+     */
+    nearestInsertIndex(worldPoint, matrixWorld, closed, maxDist) {
+        if (this.anchors.length < 2)
+            return -1;
+        const segs = this.segments.slice();
+        if (closed && this.anchors.length > 2) {
+            segs.push(this.graph.shortestPath(this.anchors[this.anchors.length - 1], this.anchors[0]));
+        }
+        let best = -1;
+        let bestD = maxDist;
+        for (let si = 0; si < segs.length; si++) {
+            for (const vi of segs[si]) {
+                const d = this.graph.vertexWorld(vi, matrixWorld).distanceTo(worldPoint);
+                if (d < bestD) {
+                    bestD = d;
+                    best = si;
+                }
+            }
+        }
+        return best;
+    }
     /** Remove the anchor at the given index and recompute adjacent segments (allows canceling any middle point). */
     removeAnchorAt(index) {
         if (index < 0 || index >= this.anchors.length)
@@ -61324,7 +61397,52 @@ class GeodesicContour {
             idxPath.push(this.anchors[0]);
         }
         // The graph geometry is already local space, so emit local vertices directly (world is derived at render time).
-        return idxPath.map((i) => this.graph.vertexLocal(i));
+        return this.smoothPath(idxPath, closed);
+    }
+    /**
+     * Relax the stitched shortest-path polyline so it reads as a smooth curve instead of the raw
+     * voxel staircase, WITHOUT changing the point count (keeps editing/index mapping simple) and
+     * WITHOUT moving the anchors (they stay exact control points). A few Laplacian passes pull each
+     * interior point toward the midpoint of its neighbours; anchors and (for open paths) the two
+     * endpoints are pinned. Normals are carried over from each point's original graph vertex — the
+     * points only shift slightly and the line already floats above the surface by `epsilon`, so the
+     * approximation is invisible and avoids an O(V) nearest-vertex scan per point on every redraw.
+     */
+    smoothPath(idxPath, closed) {
+        const base = idxPath.map((i) => this.graph.vertexLocal(i));
+        const n = base.length;
+        if (n <= 2)
+            return base;
+        const anchorSet = new Set(this.anchors);
+        const pinned = idxPath.map((i) => anchorSet.has(i));
+        const P = base.map((v) => new Vector3(v.x, v.y, v.z));
+        const ITER = 2;
+        const LAMBDA = 0.5;
+        const mid = new Vector3();
+        for (let it = 0; it < ITER; it++) {
+            const next = P.map((p) => p.clone());
+            for (let k = 0; k < n; k++) {
+                if (pinned[k])
+                    continue;
+                if (!closed && (k === 0 || k === n - 1))
+                    continue;
+                const a = P[(k - 1 + n) % n];
+                const b = P[(k + 1) % n];
+                mid.addVectors(a, b).multiplyScalar(0.5).sub(P[k]);
+                next[k].copy(P[k]).addScaledVector(mid, LAMBDA);
+            }
+            for (let k = 0; k < n; k++)
+                P[k].copy(next[k]);
+        }
+        return P.map((p, k) => ({
+            x: p.x,
+            y: p.y,
+            z: p.z,
+            nx: base[k].nx,
+            ny: base[k].ny,
+            nz: base[k].nz,
+            faceIndex: -1,
+        }));
     }
 }
 
@@ -61409,6 +61527,10 @@ class AnnotationStore {
             this.notify();
         }
     }
+    /** Notify subscribers after an in-place mutation of an existing annotation (e.g. geodesic edit re-commit). */
+    touch() {
+        this.notify();
+    }
     toJSON(modelName, mesh, opts = {}) {
         var _a;
         const space = (_a = opts.space) !== null && _a !== void 0 ? _a : "local";
@@ -61426,16 +61548,23 @@ class AnnotationStore {
             model: modelName,
             exportedAt: new Date().toISOString(),
             space,
-            annotations: this.items.map((a) => ({
-                id: a.id,
-                type: a.type,
-                mode: a.mode,
-                label: a.label,
-                color: a.color,
-                closed: a.closed,
-                visible: a.visible,
-                points: a.vertices.map(toPt),
-            })),
+            annotations: this.items.map((a) => {
+                const out = {
+                    id: a.id,
+                    type: a.type,
+                    mode: a.mode,
+                    label: a.label,
+                    color: a.color,
+                    closed: a.closed,
+                    visible: a.visible,
+                    points: a.vertices.map(toPt),
+                };
+                // Geodesic contours also carry their control points so a round-tripped import stays editable.
+                if (a.mode === "geodesic" && a.anchors && a.anchors.length) {
+                    out.anchors = a.anchors.map(toPt);
+                }
+                return out;
+            }),
         };
     }
 }
@@ -61462,11 +61591,20 @@ class SurfaceAnnotator {
         this.managed = new Set();
         this.seq = 0;
         this.selectedId = null;
-        this.activeGeoMarkers = []; // visible anchors of the in-progress geodesic
+        this.activeGeoMarkers = []; // visible anchor handles of the active geodesic
         this.geoRay = new Raycaster();
         this.geoNdc = new Vector2();
         this.hoveredGeoMarker = -1;
+        this.draggingAnchor = -1; // anchor index currently being dragged (-1 = none)
+        this.geoRedrawScheduled = false; // rAF coalescing flag for live drag redraw
+        this.editingId = null; // committed geodesic re-opened for editing (Task 1.5)
+        this.geoClosed = false; // whether the active/edited geodesic is a closed loop
         this._projV = new Vector3();
+        /** Block the OS right-click menu when the pointer is over the WebGL canvas (not the HTML panels). */
+        this.onContextMenu = (e) => {
+            if (this.insideContainer(e))
+                e.preventDefault();
+        };
         /** Update the pixel resolution of all fat lines on window resize, otherwise line width distorts. */
         this.onResize = () => {
             const w = this.o.container.clientWidth;
@@ -61483,10 +61621,50 @@ class SurfaceAnnotator {
                 (this.activeGeoLine.material.resolution.set(w, h));
         };
         this.onPointerDown = (e) => {
-            if (e.button !== 0)
-                return; // left button only
             if (!this.insideContainer(e))
                 return;
+            // Geodesic anchor editing (drag to move / right-click to delete) is available whenever an
+            // editable geodesic exists — even outside draw-lock — because it requires precisely hitting an
+            // existing anchor. This lets the user rotate the model freely and still grab a point. Handled
+            // BEFORE the button/drawing gates below.
+            if (this.armed === "geodesic" && this.activeGeo) {
+                if (e.button === 2) {
+                    const pick = this.pickGeoMarker(e);
+                    if (pick >= 0) {
+                        e.preventDefault();
+                        this.activeGeo.removeAnchorAt(pick);
+                        this.afterGeoEdit();
+                        return;
+                    }
+                }
+                else if (e.button === 0) {
+                    const pick = this.pickGeoMarker(e);
+                    if (pick >= 0) {
+                        e.preventDefault();
+                        this.draggingAnchor = pick;
+                        this.pointerDown = true;
+                        this.o.controls.enabled = false; // suppress camera while dragging the anchor
+                        this.o.container.style.cursor = "grabbing";
+                        return;
+                    }
+                    // Missed every anchor → if the click lands on the line body, insert a new anchor there
+                    // (works in an edit session or an in-progress geodesic, regardless of draw-lock).
+                    if (this.activeGeo.anchorCount >= 2) {
+                        const h = this.hit(e);
+                        if (h) {
+                            const insertAt = this.activeGeo.nearestInsertIndex(h.point, this.o.mesh.matrixWorld, this.geoClosed, this.minGap * 4);
+                            if (insertAt >= 0) {
+                                e.preventDefault();
+                                this.activeGeo.insertAnchorAt(insertAt + 1, this.o.mesh.worldToLocal(h.point.clone()));
+                                this.afterGeoEdit();
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+            if (e.button !== 0)
+                return; // the remaining tools are left-button only
             this.pointerDown = true;
             // Only act with the armed tool when in drawing mode (drawLock or spaceHeld).
             // When not drawing, navigation is the default — pointer events go to camera controls.
@@ -61526,19 +61704,8 @@ class SurfaceAnnotator {
                 return;
             }
             if (activeTool === "geodesic") {
-                // First check whether an existing anchor was clicked → cancel that point (any point can be canceled).
-                const pick = this.pickGeoMarker(e);
-                if (pick >= 0 && this.activeGeo) {
-                    this.activeGeo.removeAnchorAt(pick);
-                    if (this.activeGeo.anchorCount === 0)
-                        this.clearActiveGeo();
-                    else {
-                        this.rebuildGeoMarkers();
-                        this.redrawGeoLine();
-                    }
-                    return;
-                }
-                // Otherwise drop a new anchor on the surface.
+                // Anchor grab/delete was already handled above; here we only drop a NEW anchor on the surface
+                // (clicks on an existing anchor never reach this point).
                 const h = this.hit(e);
                 if (!h)
                     return;
@@ -61547,11 +61714,20 @@ class SurfaceAnnotator {
                 }
                 const local = this.o.mesh.worldToLocal(h.point.clone());
                 this.activeGeo.addAnchor(local);
-                this.rebuildGeoMarkers();
-                this.redrawGeoLine();
+                this.afterGeoEdit();
             }
         };
         this.onPointerMove = (e) => {
+            // Live anchor drag: move the grabbed anchor to the surface point under the cursor and redraw
+            // (both adjacent segments recompute inside moveAnchorTo). Takes priority over everything else.
+            if (this.draggingAnchor >= 0) {
+                const h = this.hit(e);
+                if (h && this.activeGeo) {
+                    this.activeGeo.moveAnchorTo(this.draggingAnchor, this.o.mesh.worldToLocal(h.point.clone()));
+                    this.scheduleGeoRedraw();
+                }
+                return;
+            }
             // Track if user dragged while space was held (so a hold-drag is not treated as a tap).
             if (this.spaceHeld && this.pointerDown) {
                 this.spaceDragged = true;
@@ -61583,6 +61759,15 @@ class SurfaceAnnotator {
             }
         };
         this.onPointerUp = () => {
+            // Finish an anchor drag: restore camera gating + cursor. (Re-commit of an edited committed
+            // contour is wired in Task 1.5.)
+            if (this.draggingAnchor >= 0) {
+                this.draggingAnchor = -1;
+                this.pointerDown = false;
+                this.o.container.style.cursor = this.hoveredGeoMarker >= 0 ? "grab" : "";
+                this.applyCameraGating();
+                return;
+            }
             if (!this.pointerDown)
                 return;
             this.pointerDown = false;
@@ -61624,6 +61809,18 @@ class SurfaceAnnotator {
                 return;
             }
             if (e.key === "Escape") {
+                // First Esc clears an active selection / in-progress geodesic while staying in the current
+                // tool; a second Esc (nothing selected) returns to Navigate.
+                if (this.selectedId || this.activeGeo) {
+                    if (this.editingId)
+                        this.recommitGeodesic();
+                    else if (this.activeGeo)
+                        this.clearActiveGeo();
+                    this.setSelected(null);
+                    this.drawLock = false;
+                    this.applyCameraGating();
+                    return;
+                }
                 this.drawLock = false;
                 this.setMode("navigate");
                 return;
@@ -61639,8 +61836,11 @@ class SurfaceAnnotator {
                 return;
             }
             if (e.key === "Enter") {
-                // Geodesic in progress → finish and close it; otherwise close the most recent freehand line.
-                if (this.activeGeo)
+                // Editing a committed geodesic → finalize the edit; a fresh geodesic in progress → finish and
+                // close it; otherwise close the most recent freehand line.
+                if (this.editingId)
+                    this.recommitGeodesic();
+                else if (this.activeGeo)
                     this.finishGeodesic();
                 else
                     this.closeLastContour();
@@ -61693,6 +61893,10 @@ class SurfaceAnnotator {
         window.addEventListener("keydown", this.onKeyDown);
         window.addEventListener("keyup", this.onKeyUp);
         window.addEventListener("resize", this.onResize);
+        // Suppress the browser's native context menu over the WebGL canvas in EVERY mode: right-click
+        // there is used for camera pan (and, in geodesic mode, delete-anchor), so the OS menu must
+        // never appear. Guarded by insideContainer → right-clicking the HTML panels keeps its menu.
+        window.addEventListener("contextmenu", this.onContextMenu, true);
         this.applyCameraGating();
     }
     get freehandColor() {
@@ -61713,14 +61917,22 @@ class SurfaceAnnotator {
     }
     setMode(m) {
         var _a, _b;
-        // When leaving geodesic mode, discard the in-progress geodesic not yet committed with Enter (clear leftover anchors and line).
-        if (m !== "geodesic" && this.activeGeo)
-            this.clearActiveGeo();
+        // When leaving geodesic mode: commit an in-progress EDIT of a committed contour, or discard a
+        // not-yet-committed new geodesic (clear leftover anchors and line).
+        if (m !== "geodesic") {
+            if (this.editingId)
+                this.recommitGeodesic();
+            else if (this.activeGeo)
+                this.clearActiveGeo();
+        }
         this.mode = m;
         // Record armed tool when choosing a drawing mode (not navigate).
         // Camera gating is NOT changed here — the user must use Space to enter drawing.
         if (m !== "navigate")
             this.armed = m;
+        // Returning to Navigate clears the selection too (put everything away).
+        if (m === "navigate")
+            this.setSelected(null);
         this.applyCameraGating();
         (_b = (_a = this.o).onModeChange) === null || _b === void 0 ? void 0 : _b.call(_a, m);
     }
@@ -61732,21 +61944,23 @@ class SurfaceAnnotator {
         return this.store.list();
     }
     undo() {
-        // Geodesic in progress → undo the most recent anchor edit (both adding and canceling a point can be rolled back);
-        // otherwise undo the most recently committed annotation.
+        // A geodesic being drawn/edited → undo the most recent anchor edit. afterGeoEdit() handles both
+        // the in-progress and committed-edit cases uniformly, including degenerate cleanup (so undo can't
+        // dispose a committed line or leave a stale edit session).
         if (this.activeGeo && this.activeGeo.canUndo()) {
             this.activeGeo.undoEdit();
-            if (this.activeGeo.anchorCount === 0)
-                this.clearActiveGeo();
-            else {
-                this.rebuildGeoMarkers();
-                this.redrawGeoLine();
-            }
+            this.afterGeoEdit();
             return;
         }
         this.store.undo();
     }
     clearAll() {
+        // Drop any edit session first; the edited line is owned by the store and disposed by clear() below.
+        if (this.editingId) {
+            this.activeGeoLine = undefined;
+            this.editingId = null;
+            this.geoClosed = false;
+        }
         const removed = this.store.clear();
         removed.forEach((a) => {
             if (a.object3D) {
@@ -61759,13 +61973,49 @@ class SurfaceAnnotator {
         this.clearActiveGeo();
     }
     deleteAnnotation(id) {
+        // If we're deleting the geodesic currently being edited, tear the edit session down first so
+        // its anchor handles aren't orphaned in the scene (the line itself is removed by reconcile).
+        if (this.editingId === id) {
+            this.removeGeoMarkers();
+            this.activeGeo = undefined;
+            this.activeGeoLine = undefined;
+            this.editingId = null;
+            this.geoClosed = false;
+        }
         if (this.selectedId === id)
-            this.selectedId = null;
+            this.setSelected(null);
         this.store.remove(id);
+        this.emitInteraction();
     }
     selectAnnotation(id) {
+        var _a;
+        // Commit any open geodesic edit before the selection changes.
+        if (this.editingId && this.editingId !== id)
+            this.recommitGeodesic();
         this.selectedId = id;
         this.applySelection();
+        if (!id)
+            return;
+        const a = this.store.get(id);
+        if (!a)
+            return;
+        // Selecting an annotation switches to the tool that drew it, so you can carry on editing it
+        // (and a geodesic opens its anchor handles). points → Place point; contour → its draw mode.
+        const tool = a.type === "points" ? "point" : (_a = a.mode) !== null && _a !== void 0 ? _a : "freehand";
+        if (this.mode !== tool)
+            this.setMode(tool);
+        // With Geodesic now active, re-open the contour's anchors for editing.
+        if (this.mode === "geodesic")
+            this.tryOpenGeoEdit(id);
+    }
+    /** Change the selection from inside the engine (delete / deselect-on-navigate) and mirror it to the UI. */
+    setSelected(id) {
+        var _a, _b;
+        if (this.selectedId === id)
+            return;
+        this.selectedId = id;
+        this.applySelection();
+        (_b = (_a = this.o).onSelectionChange) === null || _b === void 0 ? void 0 : _b.call(_a, id);
     }
     /** Redraw the corresponding three object after a color change. */
     refreshAnnotation(id) {
@@ -61796,17 +62046,11 @@ class SurfaceAnnotator {
         let count = 0;
         let maxImported = this.seq;
         for (const a of (_a = payload.annotations) !== null && _a !== void 0 ? _a : []) {
-            const verts = a.points.map((p) => {
-                const [x, y, z] = p;
-                let nx = p[3], ny = p[4], nz = p[5];
-                if (nx === undefined || ny === undefined || nz === undefined) {
-                    const nrm = this.graph.nearestNormalLocal(new Vector3(x, y, z));
-                    nx = nrm.x;
-                    ny = nrm.y;
-                    nz = nrm.z;
-                }
-                return { x, y, z, nx, ny, nz, faceIndex: 0 };
-            });
+            const verts = a.points.map((p) => this.rawToVertex(p));
+            // Geodesic control points, if the payload carries them → keep the contour editable.
+            const anchors = a.mode === "geodesic" && a.anchors && a.anchors.length
+                ? a.anchors.map((p) => this.rawToVertex(p))
+                : undefined;
             if (a.type === "points") {
                 for (const v of verts) {
                     // Only reuse the provided id for a single-point entry (the round-trip case);
@@ -61847,6 +62091,7 @@ class SurfaceAnnotator {
                     closed: a.closed,
                     visible: (_d = a.visible) !== null && _d !== void 0 ? _d : true,
                     vertices: verts,
+                    anchors,
                     object3D: line,
                 });
                 const m = id.match(/^a(\d+)$/);
@@ -61865,10 +62110,19 @@ class SurfaceAnnotator {
         return this.drawLock || this.spaceHeld;
     }
     applyCameraGating() {
-        var _a, _b;
         // Default is navigate (camera enabled). Drawing only when drawLock or spaceHeld.
         this.o.controls.enabled = !this.drawing;
-        (_b = (_a = this.o).onInteractionChange) === null || _b === void 0 ? void 0 : _b.call(_a, { drawing: this.drawing, armed: this.armed, locked: this.drawLock });
+        this.emitInteraction();
+    }
+    /** Emit the current interaction state (camera gating + whether a geodesic is editable). */
+    emitInteraction() {
+        var _a, _b;
+        (_b = (_a = this.o).onInteractionChange) === null || _b === void 0 ? void 0 : _b.call(_a, {
+            drawing: this.drawing,
+            armed: this.armed,
+            locked: this.drawLock,
+            editing: !!this.activeGeo,
+        });
     }
     /** Reconcile the scene against store.list(): add missing objects, remove deleted ones (no dispose, kept for undo restore). */
     reconcile() {
@@ -61911,18 +62165,33 @@ class SurfaceAnnotator {
         }
     }
     disposeObject(o) {
-        var _a, _b, _c;
-        const any = o;
-        (_b = (_a = any.geometry) === null || _a === void 0 ? void 0 : _a.dispose) === null || _b === void 0 ? void 0 : _b.call(_a);
-        const mat = any.material;
-        if (Array.isArray(mat))
-            mat.forEach((m) => m.dispose());
-        else
-            (_c = mat === null || mat === void 0 ? void 0 : mat.dispose) === null || _c === void 0 ? void 0 : _c.call(mat);
+        // Traverse so composite handles (Group of rim + core meshes) are fully freed, not just the root.
+        o.traverse((c) => {
+            var _a, _b, _c;
+            const any = c;
+            (_b = (_a = any.geometry) === null || _a === void 0 ? void 0 : _a.dispose) === null || _b === void 0 ? void 0 : _b.call(_a);
+            const mat = any.material;
+            if (Array.isArray(mat))
+                mat.forEach((m) => m.dispose());
+            else
+                (_c = mat === null || mat === void 0 ? void 0 : mat.dispose) === null || _c === void 0 ? void 0 : _c.call(mat);
+        });
     }
     nextId() {
         return "a" + ++this.seq;
     }
+    /** Parse a raw exported point ([x,y,z] or [x,y,z,nx,ny,nz], local space) into an AnnotationVertex, recovering the normal from the nearest graph vertex when absent. */
+    rawToVertex(p) {
+        const [x, y, z] = p;
+        let nx = p[3], ny = p[4], nz = p[5];
+        if (nx === undefined || ny === undefined || nz === undefined) {
+            const nrm = this.graph.nearestNormalLocal(new Vector3(x, y, z));
+            nx = nrm.x;
+            ny = nrm.y;
+            nz = nrm.z;
+        }
+        return { x, y, z, nx, ny, nz, faceIndex: 0 };
+    }
     hit(e) {
         return raycastSurface(this.o.camera, this.o.container, this.o.mesh, e.clientX, e.clientY);
     }
@@ -61937,6 +62206,55 @@ class SurfaceAnnotator {
         const t = e.target;
         return !!t && t.tagName === "CANVAS" && this.o.container.contains(t);
     }
+    /** After any anchor edit: refresh markers + line; drop/delete the contour when it becomes degenerate. */
+    afterGeoEdit() {
+        if (!this.activeGeo)
+            return;
+        if (this.editingId) {
+            // Editing a committed contour: fewer than 2 anchors → delete the whole annotation.
+            if (this.activeGeo.anchorCount < 2) {
+                const id = this.editingId;
+                this.removeGeoMarkers();
+                this.activeGeo = undefined;
+                this.activeGeoLine = undefined; // owned by the annotation; deleteAnnotation disposes it
+                this.editingId = null;
+                this.geoClosed = false;
+                this.deleteAnnotation(id);
+                this.emitInteraction();
+                return;
+            }
+            this.rebuildGeoMarkers();
+            this.redrawGeoLine();
+            this.emitInteraction();
+            return;
+        }
+        // In-progress new geodesic.
+        if (this.activeGeo.anchorCount === 0) {
+            this.clearActiveGeo();
+        }
+        else {
+            this.rebuildGeoMarkers();
+            this.redrawGeoLine();
+        }
+        this.emitInteraction();
+    }
+    /** Coalesce live drag redraws to one per animation frame (moveAnchorTo runs Dijkstra per move). */
+    scheduleGeoRedraw() {
+        if (this.geoRedrawScheduled)
+            return;
+        this.geoRedrawScheduled = true;
+        requestAnimationFrame(() => {
+            var _a;
+            this.geoRedrawScheduled = false;
+            this.rebuildGeoMarkers();
+            this.redrawGeoLine();
+            if (this.draggingAnchor >= 0) {
+                this.o.container.style.cursor = "grabbing";
+                // keep the grabbed handle emphasized through the live rebuilds
+                (_a = this.activeGeoMarkers[this.draggingAnchor]) === null || _a === void 0 ? void 0 : _a.scale.setScalar(1.4);
+            }
+        });
+    }
     /**
      * Pick an in-progress anchor: return the index of the nearest anchor (screen pixel distance <
      * tolerance), or -1 on a miss.
@@ -61973,71 +62291,30 @@ class SurfaceAnnotator {
         }
         return best;
     }
-    /** Set the currently hovered anchor (-1 = none): update highlight scale, cursor, and the "✕ (cancel)" floating badge. */
+    /**
+     * Set the currently hovered anchor (-1 = none): scale it up as a highlight and show a "grab"
+     * cursor to signal it's draggable. Delete is now a right-click (no floating ✕ affordance).
+     */
     setGeoHover(idx) {
-        if (idx === this.hoveredGeoMarker) {
-            if (idx >= 0)
-                this.positionGeoBadge(this.activeGeoMarkers[idx]);
+        if (idx === this.hoveredGeoMarker)
             return;
-        }
         const prev = this.activeGeoMarkers[this.hoveredGeoMarker];
         if (prev)
             prev.scale.setScalar(1);
         this.hoveredGeoMarker = idx;
         const cur = this.activeGeoMarkers[idx];
+        // Don't fight the "grabbing" cursor set during an active drag.
+        if (this.draggingAnchor >= 0)
+            return;
         if (cur) {
-            cur.scale.setScalar(1.3);
-            this.ensureGeoBadge().style.display = "flex";
-            this.positionGeoBadge(cur);
-            this.o.container.style.cursor = "pointer";
+            cur.scale.setScalar(1.35);
+            this.o.container.style.cursor = "grab";
         }
         else {
-            if (this.geoHoverBadge)
-                this.geoHoverBadge.style.display = "none";
             this.o.container.style.cursor = "";
         }
     }
-    /** Lazily create the floating ✕ badge (appended inside the container, pointer-events:none so it doesn't block clicks). */
-    ensureGeoBadge() {
-        if (this.geoHoverBadge)
-            return this.geoHoverBadge;
-        const b = document.createElement("div");
-        b.textContent = "✕";
-        Object.assign(b.style, {
-            position: "absolute",
-            width: "16px",
-            height: "16px",
-            borderRadius: "50%",
-            background: "#ff5d6c",
-            color: "#fff",
-            font: "700 10px/1 system-ui, sans-serif",
-            display: "none",
-            alignItems: "center",
-            justifyContent: "center",
-            pointerEvents: "none",
-            zIndex: "15",
-            boxShadow: "0 2px 6px rgba(0,0,0,.45)",
-            transform: "translate(-50%, -50%)",
-            left: "0px",
-            top: "0px",
-        });
-        this.o.container.appendChild(b);
-        this.geoHoverBadge = b;
-        return b;
-    }
-    /** Position the ✕ badge at the anchor's screen projection (dead center, i.e. where the cursor hovers, to avoid ambiguity). */
-    positionGeoBadge(marker) {
-        if (!marker)
-            return;
-        const b = this.ensureGeoBadge();
-        this._projV.copy(marker.position).project(this.o.camera);
-        const rect = this.o.container.getBoundingClientRect();
-        const x = (this._projV.x * 0.5 + 0.5) * rect.width;
-        const y = (-this._projV.y * 0.5 + 0.5) * rect.height;
-        b.style.left = `${x}px`;
-        b.style.top = `${y}px`;
-    }
-    /** Rebuild the visible anchor spheres from the current anchors (slightly larger than placed points, so they're easy to see and click to cancel). */
+    /** Rebuild the visible anchor spheres from the current anchors (slightly larger than placed points, so they're easy to see and grab). */
     rebuildGeoMarkers() {
         this.setGeoHover(-1);
         for (const m of this.activeGeoMarkers) {
@@ -62048,18 +62325,20 @@ class SurfaceAnnotator {
         if (!this.activeGeo)
             return;
         for (const v of this.activeGeo.getAnchorLocals()) {
-            const marker = makePointMarker(v, this.o.mesh, this.geodesicColor, this.markerRadius * 1.15);
+            const marker = makeAnchorHandle(v, this.o.mesh, this.geodesicColor, this.markerRadius * 1.7);
             this.o.scene.add(marker);
             this.activeGeoMarkers.push(marker);
         }
     }
-    /** Redraw the in-progress geodesic from the current anchors (not closed); remove the line when fewer than two points. */
+    /** Redraw the active geodesic from its current anchors (honoring the closed state); when editing a committed contour, also keep the stored annotation data in sync so export stays correct. */
     redrawGeoLine() {
         if (!this.activeGeo)
             return;
-        const verts = this.activeGeo.buildVertices(false);
+        const closed = this.geoClosed;
+        const verts = this.activeGeo.buildVertices(closed);
         if (verts.length < 2) {
-            if (this.activeGeoLine) {
+            // Only dispose the line for an in-progress geodesic; when editing, the line belongs to the annotation.
+            if (this.activeGeoLine && !this.editingId) {
                 this.o.scene.remove(this.activeGeoLine);
                 this.disposeObject(this.activeGeoLine);
                 this.activeGeoLine = undefined;
@@ -62067,11 +62346,20 @@ class SurfaceAnnotator {
             return;
         }
         if (!this.activeGeoLine) {
-            this.activeGeoLine = makeContourLine(verts, this.geodesicColor, false, this.o.container, this.epsilon, this.o.mesh);
+            this.activeGeoLine = makeContourLine(verts, this.geodesicColor, closed, this.o.container, this.epsilon, this.o.mesh);
             this.o.scene.add(this.activeGeoLine);
         }
         else {
-            updateContourLine(this.activeGeoLine, verts, false, this.epsilon, this.o.mesh);
+            updateContourLine(this.activeGeoLine, verts, closed, this.epsilon, this.o.mesh);
+        }
+        // Live-sync the committed annotation's data while it is being edited.
+        if (this.editingId) {
+            const a = this.store.get(this.editingId);
+            if (a) {
+                a.vertices = verts;
+                a.closed = closed;
+                a.anchors = this.activeGeo.getAnchorLocals();
+            }
         }
     }
     /** Discard the in-progress geodesic: remove and dispose the line and all anchors. */
@@ -62088,6 +62376,7 @@ class SurfaceAnnotator {
         }
         this.activeGeoMarkers = [];
         this.activeGeo = undefined;
+        this.emitInteraction();
     }
     /** Remove all anchor spheres of the in-progress geodesic (called after committing: only the line remains). */
     removeGeoMarkers() {
@@ -62134,6 +62423,7 @@ class SurfaceAnnotator {
                 closed,
                 visible: true,
                 vertices: verts,
+                anchors: this.activeGeo.getAnchorLocals(),
                 object3D: this.activeGeoLine,
             };
             this.store.add(ann);
@@ -62146,6 +62436,61 @@ class SurfaceAnnotator {
         this.removeGeoMarkers();
         this.activeGeo = undefined;
         this.activeGeoLine = undefined;
+        this.geoClosed = false;
+        this.emitInteraction();
+    }
+    /**
+     * Re-open a committed geodesic contour for editing: rebuild its anchors (from the stored positions)
+     * as draggable markers and reuse its line for live updates. No-op for non-geodesic / anchorless
+     * annotations. The edit session ends on Enter / mode-switch / selecting another / Esc.
+     */
+    tryOpenGeoEdit(id) {
+        var _a;
+        if (this.editingId === id)
+            return;
+        const a = this.store.get(id);
+        if (!a || a.type !== "contour" || a.mode !== "geodesic" || !a.anchors || a.anchors.length < 2) {
+            return;
+        }
+        // Discard a half-drawn (uncommitted) geodesic before entering the edit session.
+        if (this.activeGeo && !this.editingId)
+            this.clearActiveGeo();
+        const indices = a.anchors.map((v) => this.graph.nearestVertex(new Vector3(v.x, v.y, v.z)));
+        this.activeGeo = GeodesicContour.fromAnchors(this.graph, this.o.mesh, indices);
+        this.activeGeoLine = (_a = a.object3D) !== null && _a !== void 0 ? _a : undefined;
+        this.editingId = id;
+        this.geoClosed = a.closed;
+        this.rebuildGeoMarkers();
+        this.redrawGeoLine();
+        this.emitInteraction();
+    }
+    /**
+     * Finalize an edit session on a committed geodesic: the annotation data was kept in sync live
+     * (redrawGeoLine), so here we just remove the edit markers, notify subscribers, and end the
+     * session — or delete the annotation if it was reduced below 2 anchors.
+     */
+    recommitGeodesic() {
+        const id = this.editingId;
+        if (!id)
+            return;
+        if (!this.activeGeo || this.activeGeo.anchorCount < 2) {
+            this.removeGeoMarkers();
+            this.activeGeo = undefined;
+            this.activeGeoLine = undefined; // owned by the annotation
+            this.editingId = null;
+            this.geoClosed = false;
+            this.deleteAnnotation(id);
+            this.emitInteraction();
+            return;
+        }
+        this.redrawGeoLine(); // final data sync
+        this.removeGeoMarkers();
+        this.activeGeo = undefined;
+        this.activeGeoLine = undefined; // owned by the annotation, do not dispose
+        this.editingId = null;
+        this.geoClosed = false;
+        this.store.touch();
+        this.emitInteraction();
     }
     isTypingTarget(e) {
         const t = e.target;
@@ -62155,16 +62500,14 @@ class SurfaceAnnotator {
         return tag === "INPUT" || tag === "TEXTAREA" || t.isContentEditable;
     }
     dispose() {
-        var _a;
         this.clearActiveGeo();
-        (_a = this.geoHoverBadge) === null || _a === void 0 ? void 0 : _a.remove();
-        this.geoHoverBadge = undefined;
         window.removeEventListener("pointerdown", this.onPointerDown, true);
         window.removeEventListener("pointermove", this.onPointerMove, true);
         window.removeEventListener("pointerup", this.onPointerUp, true);
         window.removeEventListener("keydown", this.onKeyDown);
         window.removeEventListener("keyup", this.onKeyUp);
         window.removeEventListener("resize", this.onResize);
+        window.removeEventListener("contextmenu", this.onContextMenu, true);
     }
 }
 SurfaceAnnotator.TAP_MS = 250;
@@ -83597,15 +83940,15 @@ function evaluateElement(element, weights) {
 }
 
 // import * as kiwrious from "copper3d_plugin_heart_k";
-// "v3.6.9" is injected at build time by rollup @rollup/plugin-replace, sourced from package.json version.
+// "v3.6.10" is injected at build time by rollup @rollup/plugin-replace, sourced from package.json version.
 // When copper3d is consumed from local source (no rollup replace step), the identifier is undefined and
 // referencing it throws a ReferenceError — guard it so local loading still works.
 let _revision = "unknown";
 try {
-    _revision = "v3.6.9";
+    _revision = "v3.6.10";
 }
 catch (_a) {
-    /* "v3.6.9" not injected (local source build) */
+    /* "v3.6.10" not injected (local source build) */
 }
 const REVISION = _revision;
 // Expose on global so the version can be read in a production browser console via window.__COPPER3D_VERSION__