copper3d 3.6.8 → 3.6.10

package/dist/bundle.umd.js

@@ -59654,6 +59654,25 @@ void main() {
 	    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;
 	}
 
 	/**
@@ -61281,6 +61300,60 @@ void main() {
 	        }
 	        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)
@@ -61332,7 +61405,52 @@ void main() {
 	            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,
+	        }));
 	    }
 	}
 
@@ -61417,6 +61535,10 @@ void main() {
 	            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";
@@ -61434,16 +61556,23 @@ void main() {
 	            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;
+	            }),
 	        };
 	    }
 	}
@@ -61470,11 +61599,20 @@ void main() {
 	        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;
@@ -61491,10 +61629,50 @@ void main() {
 	                (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.
@@ -61534,19 +61712,8 @@ void main() {
 	                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;
@@ -61555,11 +61722,20 @@ void main() {
 	                }
 	                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;
@@ -61591,6 +61767,15 @@ void main() {
 	            }
 	        };
 	        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;
@@ -61632,6 +61817,18 @@ void main() {
 	                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;
@@ -61647,8 +61844,11 @@ void main() {
 	                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();
@@ -61701,6 +61901,10 @@ void main() {
 	        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() {
@@ -61721,14 +61925,22 @@ void main() {
 	    }
 	    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);
 	    }
@@ -61740,21 +61952,23 @@ void main() {
 	        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) {
@@ -61767,13 +61981,49 @@ void main() {
 	        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) {
@@ -61804,17 +62054,11 @@ void main() {
 	        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);
@@ -61855,6 +62099,7 @@ void main() {
 	                    closed: a.closed,
 	                    visible: (_d = a.visible) !== null && _d !== void 0 ? _d : true,
 	                    vertices: verts,
+	                    anchors,
 	                    object3D: line,
 	                });
 	                const m = id.match(/^a(\d+)$/);
@@ -61873,10 +62118,19 @@ void main() {
 	        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() {
@@ -61919,18 +62173,33 @@ void main() {
 	        }
 	    }
 	    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);
 	    }
@@ -61945,6 +62214,55 @@ void main() {
 	        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.
@@ -61981,71 +62299,30 @@ void main() {
 	        }
 	        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) {
@@ -62056,18 +62333,20 @@ void main() {
 	        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;
@@ -62075,11 +62354,20 @@ void main() {
 	            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. */
@@ -62096,6 +62384,7 @@ void main() {
 	        }
 	        this.activeGeoMarkers = [];
 	        this.activeGeo = undefined;
+	        this.emitInteraction();
 	    }
 	    /** Remove all anchor spheres of the in-progress geodesic (called after committing: only the line remains). */
 	    removeGeoMarkers() {
@@ -62142,6 +62431,7 @@ void main() {
 	                closed,
 	                visible: true,
 	                vertices: verts,
+	                anchors: this.activeGeo.getAnchorLocals(),
 	                object3D: this.activeGeoLine,
 	            };
 	            this.store.add(ann);
@@ -62154,6 +62444,61 @@ void main() {
 	        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;
@@ -62163,16 +62508,14 @@ void main() {
 	        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;
@@ -62443,6 +62786,12 @@ void main() {
 	            tex.setFrame(0);
 	            if (opts.window)
 	                tex.setWindow(opts.window.center, opts.window.width);
+	            // All meshes sit at the origin (world coords live in the geometry), so their
+	            // transparent-sort distances tie. three <=0.150 broke the tie by insertion
+	            // order; >=0.170 resolves it per-camera, which makes the draw order flip while
+	            // rotating (flicker / vanishing surfaces). Pin an explicit, deterministic
+	            // order: MRI plane first (backdrop), then the surfaces in definition order.
+	            tex.mesh.renderOrder = 0;
 	            const surfaceMeshes = {};
 	            const seqs = [];
 	            surfaceDefs.forEach((def, i) => {
@@ -62451,6 +62800,7 @@ void main() {
 	                const { vtkmaterial } = copperMultipleVtk(def.opts);
 	                const mesh = new Mesh(geometries[0], vtkmaterial);
 	                mesh.name = def.name;
+	                mesh.renderOrder = i + 1;
 	                this.scene.add(mesh);
 	                surfaceMeshes[def.name] = mesh;
 	                seqs.push({ mesh, geometries, offset: (_a = def.offset) !== null && _a !== void 0 ? _a : 0 });
@@ -83598,15 +83948,15 @@ void main() {
 	}
 
 	// import * as kiwrious from "copper3d_plugin_heart_k";
-	// "v3.6.8" 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.8";
+	    _revision = "v3.6.10";
 	}
 	catch (_a) {
-	    /* "v3.6.8" 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__