copper3d 3.6.8 → 3.6.10

package/dist/Utils/surfaceAnnotation/SurfaceAnnotator.js

@@ -1,7 +1,7 @@
 import * as THREE from "three";
 import { worldHitToLocalVertex } from "./types";
 import { raycastSurface } from "./raycastSurface";
-import { makePointMarker } from "./pointMarkers";
+import { makePointMarker, makeAnchorHandle } from "./pointMarkers";
 import { StrokeContour } from "./strokeContour";
 import { makeContourLine, updateContourLine, setContourColor } from "./contourRender";
 import { MeshGraph } from "./MeshGraph";
@@ -30,11 +30,20 @@ export 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 THREE.Raycaster();
         this.geoNdc = new THREE.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 THREE.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;
@@ -51,10 +60,50 @@ export 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.
@@ -94,19 +143,8 @@ export 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;
@@ -115,11 +153,20 @@ export 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;
@@ -151,6 +198,15 @@ export 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;
@@ -192,6 +248,18 @@ export 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;
@@ -207,8 +275,11 @@ export 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();
@@ -261,6 +332,10 @@ export 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() {
@@ -281,14 +356,22 @@ export 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);
     }
@@ -300,21 +383,23 @@ export 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) {
@@ -327,13 +412,49 @@ export 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) {
@@ -364,17 +485,11 @@ export 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 THREE.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);
@@ -415,6 +530,7 @@ export 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+)$/);
@@ -433,10 +549,19 @@ export 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() {
@@ -479,18 +604,33 @@ export 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 THREE.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);
     }
@@ -505,6 +645,55 @@ export 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.
@@ -541,71 +730,30 @@ export 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) {
@@ -616,18 +764,20 @@ export 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;
@@ -635,11 +785,20 @@ export 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. */
@@ -656,6 +815,7 @@ export 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() {
@@ -702,6 +862,7 @@ export class SurfaceAnnotator {
                 closed,
                 visible: true,
                 vertices: verts,
+                anchors: this.activeGeo.getAnchorLocals(),
                 object3D: this.activeGeoLine,
             };
             this.store.add(ann);
@@ -714,6 +875,61 @@ export 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 THREE.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;
@@ -723,16 +939,14 @@ export 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;