copper3d 3.6.4 → 3.6.6

package/dist/bundle.umd.js

@@ -79124,14 +79124,29 @@ void main() {
 	        this.committedVol = null;
 	        this.promptTool = "point";
 	        this.polarity = 1; // 1 = foreground (positive), 0 = background
-	        /** Target channel/label (1-8) the AI paints into — the "AI layer" channel. */
-	        this.channel = 1;
+	        /** The label value (1-255) the AI currently paints into = the active Segmentation.
+	         *  Each Segmentation is a label value in the single-channel scratch volume; its
+	         *  colour lives in the volume's colorMap (set via setSegmentColor). */
+	        this.activeLabel = 1;
 	        /** Scribble brush radius (px), user-adjustable via slider. */
 	        this.scribbleSize = 5;
 	        /** Accumulated prompts for the CURRENT slice; reset on slice/axis change. */
 	        this.points = [];
 	        this.scribble = [];
+	        /** Lasso contour sent to the backend (densified along the curve at finish). */
+	        this.lasso = [];
 	        this.activeSlice = -1;
+	        // ── Lasso v2 editing state (discrete clicked vertices → smooth closed curve) ──
+	        /** Placed lasso vertices (voxel + screen + polarity). Empty = not editing. */
+	        this.lassoVerts = [];
+	        /** Undo / redo snapshot stacks of the vertex list (for Ctrl+Z / Ctrl+Y). */
+	        this.lassoUndo = [];
+	        this.lassoRedo = [];
+	        /** Index of the vertex currently hovered (shows a red ✕; click removes it). −1 = none. */
+	        this.lassoHoverIdx = -1;
+	        /** Double-click detection (a dbl-click finishes the lasso). */
+	        this.lastLassoDownTime = 0;
+	        this.lastLassoDownPos = { x: 0, y: 0 };
 	        // Drag state (box / scribble) — voxel coords for the prompt
 	        this.dragging = false;
 	        this.dragStart = null;
@@ -79142,8 +79157,14 @@ void main() {
 	        // Live cursor position (screen px) for the scribble brush-size preview ring —
 	        // updated on every hover move so the ring follows the mouse like the paint brush.
 	        this.hoverScreen = null;
+	        /** Hide the point seed markers once a prediction has painted (only the mask
+	         *  should remain). A new point click re-shows them until its mask returns. */
+	        this.hidePointMarkers = false;
 	        /** Fired when a prompt gesture completes — app calls backend, then applyMask(). */
 	        this.onPrompt = null;
+	        /** Fired whenever the lasso vertex set changes (add/delete/undo/redo/finish/cancel),
+	         *  so the panel can reactively show the Finish button + vertex count. */
+	        this.onLassoChange = null;
 	        this.host = host;
 	    }
 	    // ── Configuration (driven from the panel via NrrdTools) ────────────────────
@@ -79161,16 +79182,51 @@ void main() {
 	    setScribbleSize(size) {
 	        this.scribbleSize = Math.max(1, Math.min(40, Math.round(size)));
 	    }
-	    setChannel(channel) {
-	        const c = Math.max(1, Math.min(8, Math.round(channel)));
-	        // Changing channel starts a NEW region in the new colour — otherwise the
-	        // accumulated points would be re-predicted and repainted in the new label,
-	        // recolouring the previous channel's region.
-	        if (c !== this.channel)
+	    /** Select the active Segmentation by its label value (1-255). Switching starts a
+	     *  fresh prompt set — otherwise accumulated prompts would be re-predicted and
+	     *  repainted into the new label, recolouring the previous segmentation's region. */
+	    setActiveSegment(label) {
+	        const c = Math.max(1, Math.min(255, Math.round(label)));
+	        if (c !== this.activeLabel)
 	            this.resetPrompts();
-	        this.channel = c;
+	        this.activeLabel = c;
+	    }
+	    getActiveLabel() { return this.activeLabel; }
+	    /** Set a Segmentation's colour (its label's entry in the scratch volume colorMap).
+	     *  The 2D overlay repaints next frame (copper3d's render loop re-reads the map). */
+	    setSegmentColor(label, color) {
+	        var _a;
+	        (_a = this.scratchVol) === null || _a === void 0 ? void 0 : _a.setChannelColor(Math.round(label), color);
+	    }
+	    /** "New segmentation": freeze the current regions (so they persist) and switch to
+	     *  a fresh label, exactly like the old "New region" but targeting a new label. */
+	    newSegment(label) {
+	        this.commitRegion();
+	        this.setActiveSegment(label);
+	    }
+	    /** Delete a Segmentation: erase every voxel painted with its label from BOTH the
+	     *  live scratch and the frozen (committed) volume, so the region disappears from
+	     *  the view (otherwise orphaned label voxels would render with the wrong colour).
+	     *  Goes via setRawData so the volume's version counter bumps (overlay repaints). */
+	    clearSegment(label) {
+	        const lbl = Math.round(label);
+	        const zeroOut = (v) => {
+	            if (!v)
+	                return;
+	            const raw = v.getRawData().slice();
+	            let changed = false;
+	            for (let i = 0; i < raw.length; i++) {
+	                if (raw[i] === lbl) {
+	                    raw[i] = 0;
+	                    changed = true;
+	                }
+	            }
+	            if (changed)
+	                v.setRawData(raw);
+	        };
+	        zeroOut(this.scratchVol);
+	        zeroOut(this.committedVol);
 	    }
-	    getChannel() { return this.channel; }
 	    getScratchVolume() { return this.scratchVol; }
 	    /** Serialize the scratch volume as per-z-slice RLE (only NON-empty slices),
 	     *  for persisting to ai_generated_nii_LPS on the backend. Binary (any channel →
@@ -79212,6 +79268,50 @@ void main() {
 	        }
 	        return { axis: "z", width, height, slices: out };
 	    }
+	    /** Per-SEGMENTATION serialization for the 3D build: one binary RLE per non-empty
+	     *  z-slice PER label (no binarize-merge), so the backend writes a multi-label
+	     *  NIfTI and colours the GLB per segmentation. Includes both live and frozen
+	     *  regions (both live in scratchVol). */
+	    getScratchSegments() {
+	        if (!this.scratchVol)
+	            return null;
+	        const { depth } = this.scratchVol.getDimensions();
+	        const byLabel = new Map();
+	        let width = 0;
+	        let height = 0;
+	        for (let z = 0; z < depth; z++) {
+	            const { data, width: w, height: h } = this.scratchVol.getSliceUint8(z, "z");
+	            width = w;
+	            height = h;
+	            const labels = new Set();
+	            for (let i = 0; i < data.length; i++) {
+	                if (data[i])
+	                    labels.add(data[i]);
+	            }
+	            for (const label of labels) {
+	                const runs = [];
+	                let value = 0; // always begin with a 0-run (matches backend rle_decode)
+	                let count = 0;
+	                for (let i = 0; i < data.length; i++) {
+	                    const v = data[i] === label ? 1 : 0;
+	                    if (v === value) {
+	                        count++;
+	                    }
+	                    else {
+	                        runs.push(count);
+	                        value = v;
+	                        count = 1;
+	                    }
+	                }
+	                runs.push(count);
+	                if (!byLabel.has(label))
+	                    byLabel.set(label, []);
+	                byLabel.get(label).push({ sliceIndex: z, rle: runs });
+	            }
+	        }
+	        const segments = [...byLabel.entries()].map(([label, slices]) => ({ label, slices }));
+	        return { axis: "z", width, height, segments };
+	    }
 	    // ── Sandbox lifecycle ──────────────────────────────────────────────────────
 	    /** Create (or reuse) the scratch volume sized to the layer grid and register
 	     *  it under maskData.volumes['aiScratch']. Snapshots the empty buffer. */
@@ -79232,14 +79332,10 @@ void main() {
 	            this.scratchVol.clear();
 	        }
 	        volumes[AI_SCRATCH_LAYER] = this.scratchVol;
-	        // Paint the AI scratch with the AI-Assist palette (channel 1 = cyan) so the 2D
-	        // overlay matches the cyan ai_generated GLB. Scoped to THIS volume only — the
-	        // global palette / clinician mask colours are untouched.
-	        for (let ch = 1; ch <= 8; ch++) {
-	            const c = AI_MASK_CHANNEL_COLORS[ch];
-	            if (c)
-	                this.scratchVol.setChannelColor(ch, { r: c.r, g: c.g, b: c.b, a: c.a });
-	        }
+	        // Segmentation colours are now driven per-label from the app (store → useAiAssist
+	        // → setSegmentColor) right after enter, so the scratch can carry an arbitrary
+	        // number of independently-coloured segmentations. No fixed palette is applied
+	        // here. Scoped to THIS volume only — global/clinician palettes are untouched.
 	        this.snapshotData = this.scratchVol.getRawData().slice();
 	        this.committedVol = null; // nothing frozen at session start
 	        this.resetPrompts();
@@ -79285,10 +79381,26 @@ void main() {
 	    resetPrompts() {
 	        this.points = [];
 	        this.scribble = [];
+	        this.lasso = [];
 	        this.box = undefined;
 	        this.dragScreenStart = null;
 	        this.dragScreen = null;
 	        this.screenScribble = [];
+	        this.clearLassoEditing();
+	    }
+	    /** Drop the in-progress lasso vertices + undo/redo history (does not touch a
+	     *  prediction already painted from a finished lasso). */
+	    clearLassoEditing() {
+	        this.lassoVerts = [];
+	        this.lassoUndo = [];
+	        this.lassoRedo = [];
+	        this.lassoHoverIdx = -1;
+	        this.notifyLasso();
+	    }
+	    /** Tell the app layer the lasso vertex set changed (drives the Finish button). */
+	    notifyLasso() {
+	        var _a;
+	        (_a = this.onLassoChange) === null || _a === void 0 ? void 0 : _a.call(this, this.lassoVerts.length, this.lassoVerts.length > 0);
 	    }
 	    // ── Coordinate mapping (all three views) ───────────────────────────────────
 	    //
@@ -79349,14 +79461,53 @@ void main() {
 	            return null;
 	        return { vx, vy, w: sd.w, h: sd.h };
 	    }
+	    /** Voxel-slice (vx,vy) → screen offset (px). Exact inverse of toVoxel, so
+	     *  markers / lasso curves drawn from voxel coords track pan AND zoom each frame
+	     *  (the freehand previews store screen px directly; persistent overlays don't). */
+	    voxelToScreen(vx, vy) {
+	        const sd = this.sliceDims();
+	        if (!sd)
+	            return null;
+	        const nrrd = this.ctx.nrrd_states;
+	        const img = nrrd.image;
+	        let hMM, vMM, flipV;
+	        switch (this.ctx.protectedData.axis) {
+	            case "z":
+	                hMM = img.nrrd_x_mm;
+	                vMM = img.nrrd_y_mm;
+	                flipV = false;
+	                break;
+	            case "y":
+	                hMM = img.nrrd_x_mm;
+	                vMM = img.nrrd_z_mm;
+	                flipV = true;
+	                break;
+	            case "x":
+	                hMM = img.nrrd_z_mm;
+	                vMM = img.nrrd_y_mm;
+	                flipV = false;
+	                break;
+	            default: return null;
+	        }
+	        const vyRaw = flipV ? sd.h - 1 - vy : vy;
+	        const x = (vx * hMM / sd.w) * nrrd.view.sizeFactor;
+	        const y = (vyRaw * vMM / sd.h) * nrrd.view.sizeFactor;
+	        return { x, y };
+	    }
 	    // ── Pointer handlers (left button; right stays pan in EventRouter) ──────────
 	    onPointerDown(e) {
 	        const hit = this.toVoxel(e);
 	        if (!hit)
 	            return;
 	        this.syncSlice();
+	        // Lasso is click-to-place vertices (NOT a drag) — own handler.
+	        if (this.promptTool === "lasso") {
+	            this.onLassoPointerDown(e, hit.vx, hit.vy);
+	            return;
+	        }
 	        if (this.promptTool === "point") {
 	            this.points.push({ x: hit.vx, y: hit.vy, label: this.polarity });
+	            this.hidePointMarkers = false; // show the new seed until its mask returns
 	            this.emit();
 	        }
 	        else {
@@ -79372,9 +79523,43 @@ void main() {
 	            }
 	        }
 	    }
+	    /** Lasso click: double-click finishes; click on a vertex deletes it; otherwise
+	     *  add a vertex. Nothing is sent to the backend until finishLasso(). */
+	    onLassoPointerDown(e, vx, vy) {
+	        const now = Date.now();
+	        const dxl = e.offsetX - this.lastLassoDownPos.x;
+	        const dyl = e.offsetY - this.lastLassoDownPos.y;
+	        const isDbl = now - this.lastLassoDownTime < 300 &&
+	            dxl * dxl + dyl * dyl <= 36; // ~6px
+	        this.lastLassoDownTime = now;
+	        this.lastLassoDownPos = { x: e.offsetX, y: e.offsetY };
+	        // Double-click → finish (the 1st click of the pair already placed the vertex).
+	        if (isDbl && this.lassoVerts.length >= 3) {
+	            this.finishLasso();
+	            return;
+	        }
+	        // Click on an existing vertex → delete it (recompute the curve).
+	        const idx = this.lassoVertAt(e.offsetX, e.offsetY);
+	        if (idx >= 0) {
+	            this.pushLassoUndo();
+	            this.lassoVerts.splice(idx, 1);
+	            this.lassoHoverIdx = -1;
+	            this.notifyLasso();
+	            return;
+	        }
+	        // Otherwise add a new vertex.
+	        this.pushLassoUndo();
+	        this.lassoVerts.push({ vx, vy, sx: e.offsetX, sy: e.offsetY, label: this.polarity });
+	        this.notifyLasso();
+	    }
 	    onPointerMove(e) {
-	        // Track hover for the scribble preview ring even when not drawing.
+	        // Track hover for the scribble preview ring / point crosshair even when idle.
 	        this.hoverScreen = { x: e.offsetX, y: e.offsetY };
+	        // Lasso: update which vertex (if any) is hovered, for the red ✕ delete affordance.
+	        if (this.promptTool === "lasso") {
+	            this.lassoHoverIdx = this.lassoVertAt(e.offsetX, e.offsetY);
+	            return; // lasso is click-based; no drag accumulation
+	        }
 	        if (!this.dragging)
 	            return;
 	        // Track screen pos first so the live preview follows even slightly out of bounds.
@@ -79427,12 +79612,116 @@ void main() {
 	            box: this.box,
 	            scribble: this.scribble.length ? [...this.scribble] : undefined,
 	            scribbleRadius: this.scribbleSize,
+	            lasso: this.lasso.length ? [...this.lasso] : undefined,
 	        });
 	    }
+	    // ── Lasso v2 (discrete vertices → smooth closed curve) ──────────────────────
+	    /** Index of the lasso vertex under (sx,sy) within the hit radius, else −1.
+	     *  Uses live voxel→screen so it tracks pan/zoom. Topmost (latest) wins. */
+	    lassoVertAt(sx, sy) {
+	        var _a;
+	        const r2 = AiAssistTool.LASSO_HIT_R * AiAssistTool.LASSO_HIT_R;
+	        for (let i = this.lassoVerts.length - 1; i >= 0; i--) {
+	            const v = this.lassoVerts[i];
+	            const s = (_a = this.voxelToScreen(v.vx, v.vy)) !== null && _a !== void 0 ? _a : { x: v.sx, y: v.sy };
+	            const dx = sx - s.x, dy = sy - s.y;
+	            if (dx * dx + dy * dy <= r2)
+	                return i;
+	        }
+	        return -1;
+	    }
+	    /** Snapshot the vertex list for undo (clears redo). */
+	    pushLassoUndo() {
+	        this.lassoUndo.push(this.lassoVerts.map((v) => (Object.assign({}, v))));
+	        this.lassoRedo = [];
+	        if (this.lassoUndo.length > 100)
+	            this.lassoUndo.shift();
+	    }
+	    /** Public: undo the last add/delete of a lasso vertex (Ctrl+Z while editing). */
+	    lassoUndoAction() {
+	        if (!this.lassoUndo.length)
+	            return;
+	        this.lassoRedo.push(this.lassoVerts.map((v) => (Object.assign({}, v))));
+	        this.lassoVerts = this.lassoUndo.pop();
+	        this.lassoHoverIdx = -1;
+	        this.notifyLasso();
+	    }
+	    /** Public: redo (Ctrl+Y / Ctrl+Shift+Z while editing). */
+	    lassoRedoAction() {
+	        if (!this.lassoRedo.length)
+	            return;
+	        this.lassoUndo.push(this.lassoVerts.map((v) => (Object.assign({}, v))));
+	        this.lassoVerts = this.lassoRedo.pop();
+	        this.lassoHoverIdx = -1;
+	        this.notifyLasso();
+	    }
+	    /** Public: abandon the in-progress lasso (Esc). */
+	    cancelLasso() { this.clearLassoEditing(); }
+	    /** Public: true while the user is placing lasso vertices (≥1 vertex). */
+	    isLassoEditing() { return this.lassoVerts.length > 0; }
+	    /** Public: number of placed lasso vertices (drives the Finish button label/enable). */
+	    getLassoVertCount() { return this.lassoVerts.length; }
+	    /** Vertices ordered by polar angle around their centroid, so the closed curve is
+	     *  a SIMPLE (non-self-intersecting) loop regardless of click order — otherwise
+	     *  connecting points in click order + closing easily produces a bow-tie crossing.
+	     *  Trade-off: deep concavities collapse to their star-shaped hull, which is fine
+	     *  for a "rough loop around a blob". */
+	    orderedLassoVerts() {
+	        const n = this.lassoVerts.length;
+	        if (n < 3)
+	            return this.lassoVerts.slice();
+	        let cx = 0, cy = 0;
+	        for (const v of this.lassoVerts) {
+	            cx += v.vx;
+	            cy += v.vy;
+	        }
+	        cx /= n;
+	        cy /= n;
+	        return this.lassoVerts.slice().sort((a, b) => Math.atan2(a.vy - cy, a.vx - cx) - Math.atan2(b.vy - cy, b.vx - cx));
+	    }
+	    /** Public: close the curve, densify it, and send it to the backend as the lasso
+	     *  contour. Needs ≥3 vertices (a real area). Then clears the editing state. */
+	    finishLasso() {
+	        if (this.lassoVerts.length < 3)
+	            return;
+	        // Order by angle (no self-crossing), then sample the SAME closed curve the user
+	        // saw → contour points (so the mask matches the curve, not a straight polygon).
+	        const contour = this.sampleClosedSpline(this.orderedLassoVerts().map((v) => ({ x: v.vx, y: v.vy })), 16);
+	        const label = this.lassoVerts[0].label; // a lasso carries one polarity (set at start)
+	        this.lasso = contour.map((p) => ({ x: Math.round(p.x), y: Math.round(p.y), label }));
+	        this.clearLassoEditing();
+	        this.emit();
+	    }
+	    /** Sample a smooth CLOSED Catmull-Rom spline through `pts` → denser polyline.
+	     *  `segs` samples per control-point span. <3 pts → returns a copy unchanged. */
+	    sampleClosedSpline(pts, segs) {
+	        const n = pts.length;
+	        if (n < 3)
+	            return pts.slice();
+	        const at = (i) => pts[((i % n) + n) % n];
+	        const out = [];
+	        for (let i = 0; i < n; i++) {
+	            const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
+	            for (let s = 0; s < segs; s++) {
+	                const t = s / segs, t2 = t * t, t3 = t2 * t;
+	                out.push({
+	                    x: 0.5 * (2 * p1.x + (-p0.x + p2.x) * t +
+	                        (2 * p0.x - 5 * p1.x + 4 * p2.x - p3.x) * t2 +
+	                        (-p0.x + 3 * p1.x - 3 * p2.x + p3.x) * t3),
+	                    y: 0.5 * (2 * p1.y + (-p0.y + p2.y) * t +
+	                        (2 * p0.y - 5 * p1.y + 4 * p2.y - p3.y) * t2 +
+	                        (-p0.y + 3 * p1.y - 3 * p2.y + p3.y) * t3),
+	                });
+	            }
+	        }
+	        return out;
+	    }
 	    // ── Apply backend result → scratch volume ──────────────────────────────────
 	    applyMask(result) {
 	        if (!this.scratchVol)
 	            return;
+	        // A prediction landed → hide the point seed markers; only the mask should show.
+	        this.hidePointMarkers = true;
 	        // 3D result (engine B): write each slice across the covered span.
 	        if (result.slices && result.sliceRange) {
 	            const [lo] = result.sliceRange;
@@ -79462,7 +79751,7 @@ void main() {
 	            pos += run;
 	            value ^= 1;
 	        }
-	        const ch = this.channel;
+	        const ch = this.activeLabel;
 	        try {
 	            const out = this.scratchVol.getSliceUint8(sliceIndex, axis).data; // copy
 	            // Frozen same-channel pixels for this slice (if any region was committed).
@@ -79535,10 +79824,7 @@ void main() {
 	            }
 	            targetCtx.restore();
 	        }
-	        // Scribble brush-size preview ring (when NOT dragging) — a circle centred on
-	        // the cursor whose radius = scribbleSize, so the user sees the brush size and
-	        // how the slider changes it (mirrors the paint brush's preview ring). Drawn
-	        // every frame from the live hover position by copper3d's render loop.
+	        // Scribble brush-size preview ring (when NOT dragging).
 	        if (this.promptTool === "scribble" && !this.dragging && this.hoverScreen) {
 	            targetCtx.save();
 	            const fg = this.polarity === 1;
@@ -79551,8 +79837,105 @@ void main() {
 	            targetCtx.stroke();
 	            targetCtx.restore();
 	        }
+	        // Point markers + hover crosshair so the clinician sees exactly where each seed
+	        // lands (and where the next click will go) before/while the prediction returns.
+	        if (this.promptTool === "point") {
+	            if (!this.hidePointMarkers) {
+	                for (const p of this.points) {
+	                    const s = this.voxelToScreen(p.x, p.y);
+	                    if (s)
+	                        this.drawSeedMarker(targetCtx, s.x, s.y, p.label === 1);
+	                }
+	            }
+	            if (!this.dragging && this.hoverScreen) {
+	                targetCtx.save();
+	                targetCtx.strokeStyle = this.polarity === 1
+	                    ? "rgba(120,255,180,0.55)" : "rgba(255,120,120,0.55)";
+	                targetCtx.lineWidth = 1;
+	                const { x, y } = this.hoverScreen;
+	                targetCtx.beginPath();
+	                targetCtx.moveTo(x - 7, y);
+	                targetCtx.lineTo(x + 7, y);
+	                targetCtx.moveTo(x, y - 7);
+	                targetCtx.lineTo(x, y + 7);
+	                targetCtx.stroke();
+	                targetCtx.restore();
+	            }
+	        }
+	        // Lasso v2: smooth closed curve through the placed vertices (closed + filled
+	        // from ≥2 vertices), vertex dots, and a red ✕ on the hovered vertex.
+	        if (this.promptTool === "lasso" && this.lassoVerts.length > 0) {
+	            this.renderLassoOverlay(targetCtx);
+	        }
 	    }
-	}
+	    /** A seed marker (small filled dot + ring) for point prompts. */
+	    drawSeedMarker(ctx, x, y, fg) {
+	        ctx.save();
+	        const col = fg ? "rgba(120,255,180,0.95)" : "rgba(255,120,120,0.95)";
+	        ctx.fillStyle = col;
+	        ctx.strokeStyle = "rgba(0,0,0,0.55)";
+	        ctx.lineWidth = 1.5;
+	        ctx.beginPath();
+	        ctx.arc(x, y, 3.5, 0, Math.PI * 2);
+	        ctx.fill();
+	        ctx.stroke();
+	        ctx.restore();
+	    }
+	    /** Render the lasso editing overlay (curve + fill + vertices + hover ✕). */
+	    renderLassoOverlay(ctx) {
+	        var _a;
+	        const fg = this.lassoVerts[0].label === 1;
+	        const stroke = fg ? "rgba(120,255,180,0.95)" : "rgba(255,120,120,0.95)";
+	        const fill = fg ? "rgba(120,255,180,0.14)" : "rgba(255,120,120,0.14)";
+	        // PATH: angularly-ordered vertices (simple, non-crossing loop) in screen space.
+	        const ov = this.orderedLassoVerts().map((v) => { var _a; return (_a = this.voxelToScreen(v.vx, v.vy)) !== null && _a !== void 0 ? _a : { x: v.sx, y: v.sy }; });
+	        const path = ov.length >= 3 ? this.sampleClosedSpline(ov, 16) : ov;
+	        ctx.save();
+	        if (path.length >= 2) {
+	            ctx.beginPath();
+	            ctx.moveTo(path[0].x, path[0].y);
+	            for (let i = 1; i < path.length; i++)
+	                ctx.lineTo(path[i].x, path[i].y);
+	            ctx.closePath();
+	            ctx.fillStyle = fill;
+	            ctx.fill();
+	            ctx.lineCap = "round";
+	            ctx.lineJoin = "round";
+	            ctx.lineWidth = 1.75;
+	            ctx.strokeStyle = stroke;
+	            ctx.stroke();
+	        }
+	        // Vertex handles — drawn from the ORIGINAL vertex order so lassoHoverIdx (an
+	        // index into lassoVerts from the hit-test) marks the correct one for the ✕.
+	        for (let i = 0; i < this.lassoVerts.length; i++) {
+	            const v = this.lassoVerts[i];
+	            const p = (_a = this.voxelToScreen(v.vx, v.vy)) !== null && _a !== void 0 ? _a : { x: v.sx, y: v.sy };
+	            if (i === this.lassoHoverIdx) {
+	                // Red ✕ — click to delete this vertex.
+	                ctx.strokeStyle = "rgba(255,90,90,0.98)";
+	                ctx.lineWidth = 2;
+	                ctx.beginPath();
+	                ctx.moveTo(p.x - 5, p.y - 5);
+	                ctx.lineTo(p.x + 5, p.y + 5);
+	                ctx.moveTo(p.x + 5, p.y - 5);
+	                ctx.lineTo(p.x - 5, p.y + 5);
+	                ctx.stroke();
+	            }
+	            else {
+	                ctx.fillStyle = stroke;
+	                ctx.strokeStyle = "rgba(0,0,0,0.55)";
+	                ctx.lineWidth = 1.25;
+	                ctx.beginPath();
+	                ctx.arc(p.x, p.y, 3, 0, Math.PI * 2);
+	                ctx.fill();
+	                ctx.stroke();
+	            }
+	        }
+	        ctx.restore();
+	    }
+	}
+	/** Screen-pixel radius for hit-testing a hovered vertex. */
+	AiAssistTool.LASSO_HIT_R = 8;
 
 	/**
 	 * DrawToolCore — Tool orchestration and event routing.
@@ -82587,16 +82970,39 @@ void main() {
 	    // — Driver methods called by the app-layer composable —
 	    aiSetPromptTool(tool) { this.drawCore.aiAssistTool.setPromptTool(tool); }
 	    aiSetPolarity(label) { this.drawCore.aiAssistTool.setPolarity(label); }
-	    /** Set the AI-layer channel (1-8) the predictions paint into. */
-	    aiSetChannel(channel) { this.drawCore.aiAssistTool.setChannel(channel); }
+	    /** Select the active Segmentation by its label value (the AI paints into it). */
+	    aiSetActiveSegment(label) { this.drawCore.aiAssistTool.setActiveSegment(label); }
+	    /** Set a Segmentation's colour (its label's colorMap entry; 2D overlay repaints). */
+	    aiSetSegmentColor(label, color) {
+	        this.drawCore.aiAssistTool.setSegmentColor(label, color);
+	    }
+	    /** "New segmentation": freeze current regions + switch to a new label. */
+	    aiNewSegment(label) { this.drawCore.aiAssistTool.newSegment(label); }
+	    /** Delete a Segmentation: erase all its label's voxels from scratch + committed. */
+	    aiClearSegment(label) { this.drawCore.aiAssistTool.clearSegment(label); }
 	    /** Set the scribble brush radius (px). */
 	    aiSetScribbleSize(size) { this.drawCore.aiAssistTool.setScribbleSize(size); }
 	    /** Register the callback invoked when a prompt gesture completes (app → backend). */
 	    aiOnPrompt(cb) { this.drawCore.aiAssistTool.onPrompt = cb; }
+	    /** Register the callback fired when the lasso vertex set changes (drives the Finish button). */
+	    aiOnLassoChange(cb) { this.drawCore.aiAssistTool.onLassoChange = cb; }
 	    /** Apply a backend mask result into the scratch volume (overlay repaints next frame). */
 	    aiApplyMask(result) { this.drawCore.aiAssistTool.applyMask(result); }
 	    /** Clear the in-progress prompt set (e.g. slice change). */
 	    aiClearPrompts() { this.drawCore.aiAssistTool.resetPrompts(); }
+	    // — Lasso v2 (discrete-vertex closed-curve) controls —
+	    /** Close + send the in-progress lasso to the backend (needs ≥3 vertices). */
+	    aiFinishLasso() { this.drawCore.aiAssistTool.finishLasso(); }
+	    /** Undo the last lasso vertex add/delete. */
+	    aiLassoUndo() { this.drawCore.aiAssistTool.lassoUndoAction(); }
+	    /** Redo the last undone lasso vertex change. */
+	    aiLassoRedo() { this.drawCore.aiAssistTool.lassoRedoAction(); }
+	    /** Abandon the in-progress lasso (Esc). */
+	    aiCancelLasso() { this.drawCore.aiAssistTool.cancelLasso(); }
+	    /** True while the user is placing lasso vertices. */
+	    aiIsLassoEditing() { return this.drawCore.aiAssistTool.isLassoEditing(); }
+	    /** Number of placed lasso vertices (drives the Finish button). */
+	    aiLassoVertCount() { return this.drawCore.aiAssistTool.getLassoVertCount(); }
 	    /** "New region": freeze current regions (they persist) + start a fresh prompt set. */
 	    aiCommitRegion() { this.drawCore.aiAssistTool.commitRegion(); }
 	    /** Discard all AI scratch painting since enter (sandbox discard). */
@@ -82607,13 +83013,26 @@ void main() {
 	    aiGetScratchSlices() {
 	        return this.drawCore.aiAssistTool.getScratchSlices();
 	    }
+	    /** Per-segmentation serialization (one binary RLE per label per z-slice) for the
+	     *  multi-label / per-colour 3D build. */
+	    aiGetScratchSegments() {
+	        return this.drawCore.aiAssistTool.getScratchSegments();
+	    }
 	    /**
-	     * Merge the AI scratch into a target layer as a single undoable group (sandbox
-	     * merge — best-practice: non-destructive + one Ctrl+Z). The scratch's channel
-	     * labels are PRESERVED (each AI channel maps onto the same channel of the
-	     * target layer). Scans all z-slices, so voxels painted from any view are caught.
+	     * Merge the AI scratch into a target layer with an explicit per-segmentation
+	     * mapping, as a single undoable group (sandbox merge — non-destructive + one
+	     * Ctrl+Z). `mapping` is `{ AI scratch label -> target channel(1-8) }`; any label
+	     * absent from the mapping (or mapped to 0) is DISCARDED (not merged). Several AI
+	     * labels MAY map to the SAME channel — after merge the channel is the identity
+	     * (CLAUDE.md decision M2), so the merged voxels take that channel's fixed colour.
+	     *
+	     * UNION semantics (M4): an AI voxel only fills a target voxel that is currently
+	     * EMPTY (0) — existing manual annotation is NEVER erased. Where two AI labels map
+	     * to different channels and overlap the same voxel, the first one written wins
+	     * (iteration order), an accepted edge case for a single-value-per-voxel mask.
+	     * Scans all z-slices, so voxels painted from any view are caught.
 	     */
-	    aiCommitToLayer(targetLayer = "layer1") {
+	    aiCommitToLayerMapped(targetLayer, mapping) {
 	        const scratch = this.drawCore.aiAssistTool.getScratchVolume();
 	        if (!scratch)
 	            return;
@@ -82635,10 +83054,21 @@ void main() {
 	                continue;
 	            const oldSlice = target.getSliceUint8(z, "z").data; // copy
 	            const newSlice = oldSlice.slice();
+	            let changed = false;
 	            for (let i = 0; i < newSlice.length; i++) {
-	                if (sc[i] !== 0)
-	                    newSlice[i] = sc[i]; // preserve the AI channel label
+	                const label = sc[i];
+	                if (label === 0)
+	                    continue;
+	                const ch = mapping[label];
+	                if (!ch)
+	                    continue; // unmapped / discarded segmentation
+	                if (newSlice[i] === 0) { // union: fill only EMPTY voxels (M4)
+	                    newSlice[i] = ch;
+	                    changed = true;
+	                }
 	            }
+	            if (!changed)
+	                continue; // nothing landed on this slice → no delta
 	            target.setSliceUint8(z, newSlice, "z");
 	            deltas.push({ layerId: targetLayer, axis: "z", sliceIndex: z, oldSlice, newSlice: newSlice.slice() });
 	        }
@@ -82646,6 +83076,19 @@ void main() {
 	            this.drawCore.undoManager.pushGroup(deltas);
 	        this.reloadMasksFromVolume();
 	    }
+	    /**
+	     * Back-compat shim: merge with an IDENTITY mapping (each AI label → the same
+	     * channel number) via the mapped path above. Newer callers should use
+	     * `aiCommitToLayerMapped` with an explicit per-segmentation mapping.
+	     */
+	    aiCommitToLayer(targetLayer = "layer1") {
+	        var _a;
+	        const segs = this.drawCore.aiAssistTool.getScratchSegments();
+	        const mapping = {};
+	        for (const s of (_a = segs === null || segs === void 0 ? void 0 : segs.segments) !== null && _a !== void 0 ? _a : [])
+	            mapping[s.label] = s.label;
+	        this.aiCommitToLayerMapped(targetLayer, mapping);
+	    }
 	    // ═══════════════════════════════════════════════════════════════════════════
 	    // 11. Clear / Reset
 	    // ═══════════════════════════════════════════════════════════════════════════
@@ -83009,8 +83452,24 @@ void main() {
 	}
 
 	// import * as kiwrious from "copper3d_plugin_heart_k";
-	const REVISION = "v3.6.4-beta";
-	console.log(`%cCopper3D Visualisation %cBeta:${REVISION}`, "padding: 3px;color:white; background:#023047", "padding: 3px;color:white; background:#f50a25");
+	// "v3.6.6" 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.6";
+	}
+	catch (_a) {
+	    /* "v3.6.6" 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__
+	if (typeof window !== "undefined") {
+	    window.__COPPER3D_VERSION__ = REVISION;
+	}
+	if (typeof console !== "undefined") {
+	    console.log(`%cCopper3D Visualisation %c${REVISION}`, "padding: 3px;color:white; background:#023047", "padding: 3px;color:white; background:#f50a25");
+	}
 
 	exports.AI_CHANNEL_HEX_COLORS = AI_CHANNEL_HEX_COLORS;
 	exports.AI_MASK_CHANNEL_COLORS = AI_MASK_CHANNEL_COLORS;