copper3d 3.6.2 → 3.6.5

package/dist/bundle.umd.js

@@ -40873,9 +40873,9 @@ void main() {
 	    }
 	}
 
-	var vert = "#define GLSLIFY 1\nattribute vec3 position;uniform mat4 modelViewMatrix;uniform mat4 projectionMatrix;varying vec2 vUv;void main(){gl_Position=vec4(position,1.0);vUv=vec2(position.x,position.y)*0.5+0.5;}"; // eslint-disable-line
+	var vert = "attribute vec3 position;\nuniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\nvarying vec2 vUv;\nvoid main() {\n  gl_Position = vec4(position, 1.0);\n  vUv = vec2(position.x, position.y) * 0.5 + 0.5;\n}\n";
 
-	var frag = "precision mediump float;\n#define GLSLIFY 1\nvec3 mod289_0(vec3 x){return x-floor(x*(1.0/289.0))*289.0;}vec4 mod289_0(vec4 x){return x-floor(x*(1.0/289.0))*289.0;}vec4 permute_0(vec4 x){return mod289_0(((x*34.0)+1.0)*x);}vec4 taylorInvSqrt_0(vec4 r){return 1.79284291400159-0.85373472095314*r;}vec3 fade(vec3 t){return t*t*t*(t*(t*6.0-15.0)+10.0);}float pnoise(vec3 P,vec3 rep){vec3 Pi0=mod(floor(P),rep);vec3 Pi1=mod(Pi0+vec3(1.0),rep);Pi0=mod289_0(Pi0);Pi1=mod289_0(Pi1);vec3 Pf0=fract(P);vec3 Pf1=Pf0-vec3(1.0);vec4 ix=vec4(Pi0.x,Pi1.x,Pi0.x,Pi1.x);vec4 iy=vec4(Pi0.yy,Pi1.yy);vec4 iz0=Pi0.zzzz;vec4 iz1=Pi1.zzzz;vec4 ixy=permute_0(permute_0(ix)+iy);vec4 ixy0=permute_0(ixy+iz0);vec4 ixy1=permute_0(ixy+iz1);vec4 gx0=ixy0*(1.0/7.0);vec4 gy0=fract(floor(gx0)*(1.0/7.0))-0.5;gx0=fract(gx0);vec4 gz0=vec4(0.5)-abs(gx0)-abs(gy0);vec4 sz0=step(gz0,vec4(0.0));gx0-=sz0*(step(0.0,gx0)-0.5);gy0-=sz0*(step(0.0,gy0)-0.5);vec4 gx1=ixy1*(1.0/7.0);vec4 gy1=fract(floor(gx1)*(1.0/7.0))-0.5;gx1=fract(gx1);vec4 gz1=vec4(0.5)-abs(gx1)-abs(gy1);vec4 sz1=step(gz1,vec4(0.0));gx1-=sz1*(step(0.0,gx1)-0.5);gy1-=sz1*(step(0.0,gy1)-0.5);vec3 g000=vec3(gx0.x,gy0.x,gz0.x);vec3 g100=vec3(gx0.y,gy0.y,gz0.y);vec3 g010=vec3(gx0.z,gy0.z,gz0.z);vec3 g110=vec3(gx0.w,gy0.w,gz0.w);vec3 g001=vec3(gx1.x,gy1.x,gz1.x);vec3 g101=vec3(gx1.y,gy1.y,gz1.y);vec3 g011=vec3(gx1.z,gy1.z,gz1.z);vec3 g111=vec3(gx1.w,gy1.w,gz1.w);vec4 norm0=taylorInvSqrt_0(vec4(dot(g000,g000),dot(g010,g010),dot(g100,g100),dot(g110,g110)));g000*=norm0.x;g010*=norm0.y;g100*=norm0.z;g110*=norm0.w;vec4 norm1=taylorInvSqrt_0(vec4(dot(g001,g001),dot(g011,g011),dot(g101,g101),dot(g111,g111)));g001*=norm1.x;g011*=norm1.y;g101*=norm1.z;g111*=norm1.w;float n000=dot(g000,Pf0);float n100=dot(g100,vec3(Pf1.x,Pf0.yz));float n010=dot(g010,vec3(Pf0.x,Pf1.y,Pf0.z));float n110=dot(g110,vec3(Pf1.xy,Pf0.z));float n001=dot(g001,vec3(Pf0.xy,Pf1.z));float n101=dot(g101,vec3(Pf1.x,Pf0.y,Pf1.z));float n011=dot(g011,vec3(Pf0.x,Pf1.yz));float n111=dot(g111,Pf1);vec3 fade_xyz=fade(Pf0);vec4 n_z=mix(vec4(n000,n100,n010,n110),vec4(n001,n101,n011,n111),fade_xyz.z);vec2 n_yz=mix(n_z.xy,n_z.zw,fade_xyz.y);float n_xyz=mix(n_yz.x,n_yz.y,fade_xyz.x);return 2.2*n_xyz;}vec3 mod289_1(vec3 x){return x-floor(x*(1.0/289.0))*289.0;}vec4 mod289_1(vec4 x){return x-floor(x*(1.0/289.0))*289.0;}vec4 permute_1(vec4 x){return mod289_1(((x*34.0)+1.0)*x);}vec4 taylorInvSqrt_1(vec4 r){return 1.79284291400159-0.85373472095314*r;}float snoise(vec3 v){const vec2 C=vec2(1.0/6.0,1.0/3.0);const vec4 D=vec4(0.0,0.5,1.0,2.0);vec3 i=floor(v+dot(v,C.yyy));vec3 x0=v-i+dot(i,C.xxx);vec3 g_0=step(x0.yzx,x0.xyz);vec3 l=1.0-g_0;vec3 i1=min(g_0.xyz,l.zxy);vec3 i2=max(g_0.xyz,l.zxy);vec3 x1=x0-i1+C.xxx;vec3 x2=x0-i2+C.yyy;vec3 x3=x0-D.yyy;i=mod289_1(i);vec4 p=permute_1(permute_1(permute_1(i.z+vec4(0.0,i1.z,i2.z,1.0))+i.y+vec4(0.0,i1.y,i2.y,1.0))+i.x+vec4(0.0,i1.x,i2.x,1.0));float n_=0.142857142857;vec3 ns=n_*D.wyz-D.xzx;vec4 j=p-49.0*floor(p*ns.z*ns.z);vec4 x_=floor(j*ns.z);vec4 y_=floor(j-7.0*x_);vec4 x=x_*ns.x+ns.yyyy;vec4 y=y_*ns.x+ns.yyyy;vec4 h=1.0-abs(x)-abs(y);vec4 b0=vec4(x.xy,y.xy);vec4 b1=vec4(x.zw,y.zw);vec4 s0=floor(b0)*2.0+1.0;vec4 s1=floor(b1)*2.0+1.0;vec4 sh=-step(h,vec4(0.0));vec4 a0=b0.xzyw+s0.xzyw*sh.xxyy;vec4 a1=b1.xzyw+s1.xzyw*sh.zzww;vec3 p0=vec3(a0.xy,h.x);vec3 p1=vec3(a0.zw,h.y);vec3 p2=vec3(a1.xy,h.z);vec3 p3=vec3(a1.zw,h.w);vec4 norm=taylorInvSqrt_1(vec4(dot(p0,p0),dot(p1,p1),dot(p2,p2),dot(p3,p3)));p0*=norm.x;p1*=norm.y;p2*=norm.z;p3*=norm.w;vec4 m=max(0.6-vec4(dot(x0,x0),dot(x1,x1),dot(x2,x2),dot(x3,x3)),0.0);m=m*m;return 42.0*dot(m*m,vec4(dot(p0,x0),dot(p1,x1),dot(p2,x2),dot(p3,x3)));}float grain(vec2 texCoord,vec2 resolution,float frame,float multiplier){vec2 mult=texCoord*resolution;float offset=snoise(vec3(mult/multiplier,frame));float n1=pnoise(vec3(mult,offset),vec3(1.0/texCoord*resolution,1.0));return n1/2.0+0.5;}float grain(vec2 texCoord,vec2 resolution,float frame){return grain(texCoord,resolution,frame,2.5);}float grain(vec2 texCoord,vec2 resolution){return grain(texCoord,resolution,0.0);}vec3 blendSoftLight(vec3 base,vec3 blend){return mix(sqrt(base)*(2.0*blend-1.0)+2.0*base*(1.0-blend),2.0*base*blend+base*base*(1.0-2.0*blend),step(base,vec3(0.5)));}uniform vec3 color1;uniform vec3 color2;uniform float aspect;uniform vec2 offset;uniform vec2 scale;uniform float noiseAlpha;uniform bool aspectCorrection;uniform float grainScale;uniform float grainTime;uniform vec2 smooth;varying vec2 vUv;void main(){vec2 q=vec2(vUv-0.5);if(aspectCorrection){q.x*=aspect;}q/=scale;q-=offset;float dst=length(q);dst=smoothstep(smooth.x,smooth.y,dst);vec3 color=mix(color1,color2,dst);if(noiseAlpha>0.0&&grainScale>0.0){float gSize=1.0/grainScale;float g=grain(vUv,vec2(gSize*aspect,gSize),grainTime);vec3 noiseColor=blendSoftLight(color,vec3(g));gl_FragColor.rgb=mix(color,noiseColor,noiseAlpha);}else{gl_FragColor.rgb=color;}gl_FragColor.a=1.0;}"; // eslint-disable-line
+	var frag = "precision mediump float;\n#pragma glslify: grain = require('glsl-film-grain')\n#pragma glslify: blend = require('glsl-blend-soft-light')\n\nuniform vec3 color1;\nuniform vec3 color2;\nuniform float aspect;\nuniform vec2 offset;\nuniform vec2 scale;\nuniform float noiseAlpha;\nuniform bool aspectCorrection;\nuniform float grainScale;\nuniform float grainTime;\nuniform vec2 smooth;\n\nvarying vec2 vUv;\n\nvoid main() {\n  vec2 q = vec2(vUv - 0.5);\n  if (aspectCorrection) {\n    q.x *= aspect;\n  }\n  q /= scale;\n  q -= offset;\n  float dst = length(q);\n  dst = smoothstep(smooth.x, smooth.y, dst);\n  vec3 color = mix(color1, color2, dst);\n\n  if (noiseAlpha > 0.0 && grainScale > 0.0) {\n    float gSize = 1.0 / grainScale;\n    float g = grain(vUv, vec2(gSize * aspect, gSize), grainTime);\n    vec3 noiseColor = blend(color, vec3(g));\n    gl_FragColor.rgb = mix(color, noiseColor, noiseAlpha);\n  } else {\n    gl_FragColor.rgb = color;\n  }\n  gl_FragColor.a = 1.0;\n}\n";
 
 	function createBackground(opt) {
 	    opt = opt || {};
@@ -41403,9 +41403,9 @@ void main() {
 	    };
 	}
 
-	var vert_2d = "#define GLSLIFY 1\nout vec2 vUv;void main(){gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.0);vUv=vec2(uv.x,1.0-uv.y);}"; // eslint-disable-line
+	var vert_2d = "out vec2 vUv;\n\nvoid main() {\n\n    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n    // Use the geometry's own UVs; DICOM rows are top-down so flip v.\n    vUv = vec2( uv.x, 1.0 - uv.y );\n\n}\n";
 
-	var frag_2d = "precision highp float;precision highp int;precision highp sampler2DArray;\n#define GLSLIFY 1\nuniform sampler2DArray diffuse;in vec2 vUv;uniform int depth;uniform float uOpacity;out vec4 outColor;void main(){vec4 color=texture(diffuse,vec3(vUv,depth));outColor=vec4(color.rrr*1.5,uOpacity);}"; // eslint-disable-line
+	var frag_2d = "precision highp float;\nprecision highp int;\nprecision highp sampler2DArray;\n\nuniform sampler2DArray diffuse;\nin vec2 vUv;\nuniform int depth;\nuniform float uOpacity;\n\nout vec4 outColor;\n\nvoid main() {\n\n    vec4 color = texture( diffuse, vec3( vUv, depth ) );\n\n    // lighten a bit\n    outColor = vec4( color.rrr * 1.5, uOpacity );\n\n}";
 
 	let planeWidth = 80;
 	let planeHeight = 80;
@@ -46336,7 +46336,7 @@ void main() {
 	        mesh.position.y += mesh.position.y - center.y;
 	        mesh.position.z += mesh.position.z - center.z;
 	        const boundingBox = new Box3().setFromObject(mesh);
-	        // 获取边界框的尺寸
+	        // Get the size of the bounding box
 	        const size_ = new Vector3();
 	        boundingBox.getSize(size_);
 	        scene.add(mesh);
@@ -58686,7 +58686,7 @@ void main() {
 	const _EPS = 0.000001;
 	const _STATE = { NONE: - 1, ROTATE: 0, ZOOM: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_ZOOM_PAN: 4 };
 
-	const _v2 = new Vector2();
+	const _v2$1 = new Vector2();
 	const _mouseChange = new Vector2();
 	const _objectUp = new Vector3();
 	const _pan = new Vector3();
@@ -59082,23 +59082,23 @@ void main() {
 
 		_getMouseOnScreen( pageX, pageY ) {
 
-			_v2.set(
+			_v2$1.set(
 				( pageX - this.screen.left ) / this.screen.width,
 				( pageY - this.screen.top ) / this.screen.height
 			);
 
-			return _v2;
+			return _v2$1;
 
 		}
 
 		_getMouseOnCircle( pageX, pageY ) {
 
-			_v2.set(
+			_v2$1.set(
 				( ( pageX - this.screen.width * 0.5 - this.screen.left ) / ( this.screen.width * 0.5 ) ),
 				( ( this.screen.height + 2 * ( this.screen.top - pageY ) ) / this.screen.width ) // screen.width intentional
 			);
 
-			return _v2;
+			return _v2$1;
 
 		}
 
@@ -59519,7 +59519,7 @@ void main() {
 	}
 
 	const _inv = new Matrix4();
-	/** 世界系命中点 → local 顶点(位置 worldToLocal,法线用逆变换)。 */
+	/** World-space hit point → local vertex (position via worldToLocal, normal via inverse transform). */
 	function worldHitToLocalVertex(h, mesh) {
 	    const lp = mesh.worldToLocal(h.point.clone());
 	    _inv.copy(mesh.matrixWorld).invert();
@@ -59534,20 +59534,80 @@ void main() {
 	        faceIndex: h.faceIndex,
 	    };
 	}
-	const _nm = new Matrix3();
-	/** local 顶点 → world 位置 + world 法线(供渲染)。 */
+	const _nm$1 = new Matrix3();
+	/** Local vertex → world position + world normal (for rendering). */
 	function localVertexToWorld(v, mesh) {
 	    const p = new Vector3(v.x, v.y, v.z).applyMatrix4(mesh.matrixWorld);
-	    _nm.getNormalMatrix(mesh.matrixWorld);
-	    const n = new Vector3(v.nx, v.ny, v.nz).applyMatrix3(_nm).normalize();
+	    _nm$1.getNormalMatrix(mesh.matrixWorld);
+	    const n = new Vector3(v.nx, v.ny, v.nz).applyMatrix3(_nm$1).normalize();
 	    return { p, n };
 	}
 
 	const ray = new Raycaster();
 	const ndc = new Vector2();
+	// scratch objects for the smooth-normal interpolation (avoid per-call allocation)
+	const _nm = new Matrix3();
+	const _lp = new Vector3();
+	const _pa = new Vector3();
+	const _pb = new Vector3();
+	const _pc = new Vector3();
+	const _na = new Vector3();
+	const _nb = new Vector3();
+	const _nc = new Vector3();
+	const _v0 = new Vector3();
+	const _v1 = new Vector3();
+	const _v2 = new Vector3();
+	/**
+	 * Interpolate a "smooth per-vertex normal" across the hit triangle using barycentric coordinates,
+	 * instead of using the per-face normal.
+	 *
+	 * Per-face normals on voxel / marching-cubes meshes are axis-aligned stair directions (±x/±y/±z);
+	 * using them to push the annotation line outward along the normal shoves points toward neighboring
+	 * stairs rather than cleanly "outward", making the line dip in and out on bumpy surfaces and get
+	 * occluded by the steps. A smooth normal varies continuously along the surface, so the outward
+	 * direction is stable and consistent and the line can float smoothly above the relief. Returns false
+	 * when interpolation isn't possible (caller falls back to the face normal).
+	 */
+	function interpolateLocalNormal(geom, face, localPoint, out) {
+	    const posAttr = geom.getAttribute("position");
+	    const norAttr = geom.getAttribute("normal");
+	    if (!posAttr || !norAttr)
+	        return false;
+	    _pa.fromBufferAttribute(posAttr, face.a);
+	    _pb.fromBufferAttribute(posAttr, face.b);
+	    _pc.fromBufferAttribute(posAttr, face.c);
+	    // Barycentric coordinates (local space): u/v/w
+	    _v0.subVectors(_pb, _pa);
+	    _v1.subVectors(_pc, _pa);
+	    _v2.subVectors(localPoint, _pa);
+	    const d00 = _v0.dot(_v0);
+	    const d01 = _v0.dot(_v1);
+	    const d11 = _v1.dot(_v1);
+	    const d20 = _v2.dot(_v0);
+	    const d21 = _v2.dot(_v1);
+	    const denom = d00 * d11 - d01 * d01;
+	    if (Math.abs(denom) < 1e-12)
+	        return false;
+	    const v = (d11 * d20 - d01 * d21) / denom;
+	    const w = (d00 * d21 - d01 * d20) / denom;
+	    const u = 1 - v - w;
+	    _na.fromBufferAttribute(norAttr, face.a);
+	    _nb.fromBufferAttribute(norAttr, face.b);
+	    _nc.fromBufferAttribute(norAttr, face.c);
+	    out
+	        .set(0, 0, 0)
+	        .addScaledVector(_na, u)
+	        .addScaledVector(_nb, v)
+	        .addScaledVector(_nc, w);
+	    if (out.lengthSq() < 1e-12)
+	        return false;
+	    out.normalize();
+	    return true;
+	}
 	/**
-	 * 把屏幕坐标(clientX/Y)投射到 mesh 表面,返回命中点、world-space 法线与 faceIndex。
-	 * 未命中返回 null。本地实现,不依赖 Copper3D 未导出的 raycast 内部函数。
+	 * Project screen coordinates (clientX/Y) onto the mesh surface, returning the hit point,
+	 * world-space normal, and faceIndex. Returns null on a miss. Local implementation that does not
+	 * depend on Copper3D's unexported raycast internals.
 	 */
 	function raycastSurface(camera, container, mesh, clientX, clientY) {
 	    var _a;
@@ -59562,19 +59622,29 @@ void main() {
 	    const point = h.point.clone();
 	    const normal = new Vector3(0, 0, 1);
 	    if (h.face) {
-	        normal.copy(h.face.normal);
-	        const nm = new Matrix3().getNormalMatrix(mesh.matrixWorld);
-	        normal.applyMatrix3(nm).normalize();
+	        // Prefer a smooth interpolated normal (stable outward direction on bumpy/voxel meshes);
+	        // fall back to the flat face normal if the geometry has no normal attribute.
+	        _lp.copy(h.point);
+	        mesh.worldToLocal(_lp);
+	        if (!interpolateLocalNormal(mesh.geometry, h.face, _lp, normal)) {
+	            normal.copy(h.face.normal);
+	        }
+	        _nm.getNormalMatrix(mesh.matrixWorld);
+	        normal.applyMatrix3(_nm).normalize();
 	    }
 	    return { point, normal, faceIndex: (_a = h.faceIndex) !== null && _a !== void 0 ? _a : -1 };
 	}
 
 	/**
-	 * 在 local 顶点处生成一个标记小球(fiducial)。local→world 后沿 world 法线略外移,
-	 * 避免一半埋进表面。radius 由调用方按模型 bbox 缩放传入。
+	 * Create a marker sphere (fiducial) at a local vertex. After local→world, nudge it
+	 * outward along the world normal so it doesn't sink halfway into the surface.
+	 * radius is passed in by the caller, scaled to the model bbox.
 	 */
 	function makePointMarker(v, mesh, color, radius) {
 	    const geo = new SphereGeometry(radius, 16, 16);
+	    // depthTest ON so markers are occluded by the model when they are on the far side (no
+	    // see-through), consistent with the contour lines. Markers are volumetric spheres lifted off
+	    // the surface, so they still show on the visible side without z-fighting.
 	    const mat = new MeshBasicMaterial({ color });
 	    const m = new Mesh(geo, mat);
 	    const { p, n } = localVertexToWorld(v, mesh);
@@ -59584,15 +59654,18 @@ void main() {
 	}
 
 	/**
-	 * 模式 A(自由手绘)一笔的状态机。
-	 * pointermove 时不断 addSample;与上一采样点世界距离 < minGap 的样本丢弃,避免过密。
-	 * 顶点以 local 存(由 mesh 把世界命中点转 local)。
+	 * State machine for one stroke in mode A (freehand).
+	 * On pointermove it keeps calling addSample; samples whose world distance from the previous
+	 * sample is < minGap are dropped to avoid over-density.
+	 * Vertices are stored in local space (the mesh converts the world hit point to local).
 	 */
 	class StrokeContour {
 	    /**
-	     * @param minGap  采样最小间距(世界系),去抖
-	     * @param maxJump 跳变阈值(世界系):距离 > maxJump 且法线大幅翻转时丢弃该样本,
-	     *                避免笔触掠过沟缝/轮廓边时相邻点落在不同深度、直线段横穿模型。
+	     * @param minGap  minimum sample spacing (world space), debounce
+	     * @param maxJump jump threshold (world space): drop the sample when distance > maxJump and the
+	     *                normal flips sharply, to prevent adjacent points landing at different depths
+	     *                (and the straight segment cutting through the model) when the stroke grazes a
+	     *                groove or contour edge.
 	     */
 	    constructor(minGap, maxJump, mesh) {
 	        this.minGap = minGap;
@@ -59611,10 +59684,12 @@ void main() {
 	        if (this.has) {
 	            const d = hit.point.distanceTo(this.last);
 	            if (d < this.minGap)
-	                return; // 太近,去抖
-	            // 跳变剔除:距离突然很大「且」法线大幅翻转(>~75°)→ 多半跳到了背面/远面,丢弃,
-	            // 否则相邻两点之间的直线段会横穿模型内部。两个条件同时满足才剔除:
-	            // 快速画(距离大、法线相近)不误删;画过尖锐棱边(法线变、距离近)也不误删。
+	                return; // too close, debounce
+	            // Jump rejection: distance suddenly large AND normal flips sharply (>~75°) → likely jumped to
+	            // the back/far side, so drop it, otherwise the straight segment between adjacent points cuts
+	            // through the model interior. Only reject when both conditions hold:
+	            // fast drawing (large distance, similar normals) isn't falsely dropped, and drawing over a
+	            // sharp edge (normal changes, distance small) isn't falsely dropped either.
 	            if (d > this.maxJump && hit.normal.dot(this.lastNormal) < 0.25)
 	                return;
 	        }
@@ -60912,9 +60987,10 @@ void main() {
 	}
 
 	/**
-	 * 把标注顶点(local)序列展平成 Line2 需要的 world [x,y,z, ...]。
-	 * 每个点 local→world,再沿 world 法线外移 epsilon,避免与模型表面 z-fighting。
-	 * closed 时把首点追加到末尾形成环。
+	 * Flatten a sequence of annotation vertices (local) into the world [x,y,z, ...] that Line2 needs.
+	 * Each point goes local→world, then is pushed outward along the world normal by epsilon to avoid
+	 * z-fighting with the model surface.
+	 * When closed, the first point is appended to the end to form a ring.
 	 */
 	function flatten(verts, closed, epsilon, mesh) {
 	    const pts = [];
@@ -60930,27 +61006,31 @@ void main() {
 	function makeContourLine(verts, color, closed, container, epsilon, mesh) {
 	    const geo = new LineGeometry();
 	    const pos = flatten(verts, closed, epsilon, mesh);
-	    // Line2 至少需要 2 个点;不足时给一个退化占位,后续 update 会补上。
+	    // Line2 needs at least 2 points; when there aren't enough, give a degenerate placeholder that a later update fills in.
 	    geo.setPositions(pos.length >= 6 ? pos : [0, 0, 0, 0, 0, 0]);
 	    const mat = new LineMaterial({
 	        color: new Color$1(color).getHex(),
-	        linewidth: 3, // 像素宽(需 resolution 配合)
+	        linewidth: 3, // width in pixels (requires resolution to be set)
+	        // depthTest stays ON so the model correctly occludes the line when it is on the far side
+	        // (no see-through). The host applies polygonOffset to the SURFACE material so the line still
+	        // wins where it lies coplanar with the surface (no z-fighting / sinking on bumpy meshes).
 	    });
 	    mat.resolution.set(container.clientWidth, container.clientHeight);
 	    const line = new Line2(geo, mat);
 	    line.computeLineDistances();
 	    line.renderOrder = 998;
-	    // 关键:Line2 的包围球停留在初始点,拖拽生长后真实几何会被错误剔除。
-	    // 关闭视锥剔除,保证线始终渲染。
+	    // Important: Line2's bounding sphere stays at the initial point, so once the geometry grows by
+	    // dragging, the real geometry gets wrongly culled. Disable frustum culling so the line always renders.
 	    line.frustumCulled = false;
 	    return line;
 	}
 	function updateContourLine(line, verts, closed, epsilon, mesh) {
 	    const pos = flatten(verts, closed, epsilon, mesh);
 	    if (pos.length < 6)
-	        return; // Line2 需要 >=2 点
-	    // 关键:Line2 在原 geometry 上 setPositions 扩容后只渲染首段(已知坑)。
-	    // 改为每次重建一个新 LineGeometry 并替换,保证实例数正确、全段渲染。
+	        return; // Line2 needs >=2 points
+	    // Important: calling setPositions on the existing geometry to grow it only renders the first
+	    // segment (a known pitfall). Instead, rebuild and swap in a new LineGeometry each time so the
+	    // instance count is correct and every segment renders.
 	    const geo = new LineGeometry();
 	    geo.setPositions(pos);
 	    const old = line.geometry;
@@ -60958,20 +61038,22 @@ void main() {
 	    old.dispose();
 	    line.computeLineDistances();
 	}
-	/** 改变已有 contour 线的颜色。 */
+	/** Change the color of an existing contour line. */
 	function setContourColor(line, color) {
 	    line.material.color.set(color);
 	}
 
 	/**
-	 * 从 BufferGeometry 的索引构建顶点邻接图,用于模式 B(测地线)的最短路径。
-	 * 顶点坐标按 local 存;传入的查询点需先转为 local(mesh.worldToLocal)。
+	 * Build a vertex adjacency graph from a BufferGeometry's index, used for the shortest path in
+	 * mode B (geodesic). Vertex coordinates are stored in local space; query points must be converted
+	 * to local first (mesh.worldToLocal).
 	 *
-	 * 说明:几何须为已索引(indexed)。modelLoader 用 mergeVertices 焊接重复顶点,
-	 * 保证同一表面位置共享顶点,邻接图才连通。
+	 * Note: the geometry must be indexed. modelLoader welds duplicate vertices with mergeVertices so
+	 * that vertices at the same surface position are shared, otherwise the adjacency graph won't be connected.
 	 *
-	 * 性能:O(V²) Dijkstra + O(V) 最近顶点查找。对几万顶点单次点击可接受;
-	 * 若过大可后续换二叉堆 + 空间网格加速(留作升级)。
+	 * Performance: O(V²) Dijkstra + O(V) nearest-vertex lookup. Acceptable for a single click on tens
+	 * of thousands of vertices; if too large it can later be sped up with a binary heap + spatial grid
+	 * (left as a future upgrade).
 	 */
 	class MeshGraph {
 	    constructor(geometry) {
@@ -60999,7 +61081,7 @@ void main() {
 	            }
 	        }
 	        else {
-	            // 非索引兜底(连通性差,仅避免崩溃)。
+	            // Non-indexed fallback (poor connectivity, only to avoid crashing).
 	            for (let i = 0; i + 2 < this.vertexCount; i += 3) {
 	                addEdge(i, i + 1);
 	                addEdge(i + 1, i + 2);
@@ -61016,7 +61098,7 @@ void main() {
 	    pz(i) {
 	        return this.positions[i * 3 + 2];
 	    }
-	    /** 最近顶点(传入 local 坐标)。 */
+	    /** Nearest vertex (pass in local coordinates). */
 	    nearestVertex(localPoint) {
 	        let best = -1;
 	        let bestD = Infinity;
@@ -61033,8 +61115,8 @@ void main() {
 	        return best;
 	    }
 	    /**
-	     * 两顶点间最短路径(含端点的顶点索引序列)。二叉堆 Dijkstra,O(E log V)。
-	     * 不连通时返回 [start,end] 兜底。
+	     * Shortest path between two vertices (sequence of vertex indices including endpoints).
+	     * Binary-heap Dijkstra, O(E log V). Falls back to [start,end] when disconnected.
 	     */
 	    shortestPath(startV, endV) {
 	        if (startV === endV)
@@ -61091,7 +61173,7 @@ void main() {
 	        const nm = new Matrix3().getNormalMatrix(mesh.matrixWorld);
 	        return n.applyMatrix3(nm).normalize();
 	    }
-	    /** 顶点的 local 坐标 + local 法线(图几何即 local 空间)。 */
+	    /** Vertex local coordinates + local normal (the graph geometry is already local space). */
 	    vertexLocal(i) {
 	        return {
 	            x: this.px(i),
@@ -61104,7 +61186,7 @@ void main() {
 	        };
 	    }
 	}
-	/** 极简二叉最小堆(按 priority 排序,存顶点索引)。用于 Dijkstra。 */
+	/** Minimal binary min-heap (ordered by priority, stores vertex indices). Used for Dijkstra. */
 	class MinHeap {
 	    constructor() {
 	        this.ids = [];
@@ -61161,22 +61243,23 @@ void main() {
 	}
 
 	/**
-	 * 模式 B(测地线)状态机:逐次点击锚点,相邻锚点之间用 MeshGraph 求最短路径,
-	 * 拼成一条贴合表面的折线。Enter 结束并可闭合(首尾再求一段)。
+	 * State machine for mode B (geodesic): click anchors one by one, find the shortest path between
+	 * adjacent anchors with MeshGraph, and stitch them into a polyline that hugs the surface.
+	 * Enter finishes and can close the loop (computing one more segment between first and last).
 	 */
 	class GeodesicContour {
 	    constructor(graph, mesh) {
 	        this.graph = graph;
 	        this.mesh = mesh;
-	        this.anchors = []; // 顶点索引
-	        this.segments = []; // 相邻锚点间路径(含端点)
-	        this.history = []; // 每次增删前的锚点快照,用于撤销
+	        this.anchors = []; // vertex indices
+	        this.segments = []; // path between adjacent anchors (endpoints included)
+	        this.history = []; // anchor snapshot before each add/remove, for undo
 	    }
-	    /** 任何改动锚点前先存一份快照(顶点索引数组很小,快照成本可忽略)。 */
+	    /** Save a snapshot before any anchor change (the vertex-index array is tiny, so snapshot cost is negligible). */
 	    snapshot() {
 	        this.history.push(this.anchors.slice());
 	    }
-	    /** 传入 local 命中点,snap 到最近顶点并对上一锚点求路径。 */
+	    /** Given a local hit point, snap to the nearest vertex and compute the path to the previous anchor. */
 	    addAnchor(localHitPoint) {
 	        const v = this.graph.nearestVertex(localHitPoint);
 	        this.snapshot();
@@ -61186,7 +61269,7 @@ void main() {
 	        }
 	        this.anchors.push(v);
 	    }
-	    /** 删除指定下标的锚点,重算相邻段(支持取消中间任意一点)。 */
+	    /** 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)
 	            return;
@@ -61194,11 +61277,11 @@ void main() {
 	        this.anchors.splice(index, 1);
 	        this.rebuildSegments();
 	    }
-	    /** 是否还有可撤销的编辑(加点/删点)。 */
+	    /** Whether there is still an editable change to undo (add/remove point). */
 	    canUndo() {
 	        return this.history.length > 0;
 	    }
-	    /** 撤销上一次锚点编辑(加点 → 删回去;删点 → 恢复)。无历史返回 false。 */
+	    /** Undo the last anchor edit (add → remove it; remove → restore it). Returns false when no history. */
 	    undoEdit() {
 	        const prev = this.history.pop();
 	        if (!prev)
@@ -61207,21 +61290,21 @@ void main() {
 	        this.rebuildSegments();
 	        return true;
 	    }
-	    /** 据当前锚点序列整体重算所有相邻段路径。 */
+	    /** Recompute all adjacent-segment paths from the current anchor sequence. */
 	    rebuildSegments() {
 	        this.segments = [];
 	        for (let i = 1; i < this.anchors.length; i++) {
 	            this.segments.push(this.graph.shortestPath(this.anchors[i - 1], this.anchors[i]));
 	        }
 	    }
-	    /** 各锚点的 local 顶点(用于绘制可见的锚点标记)。 */
+	    /** Local vertex of each anchor (used to draw visible anchor markers). */
 	    getAnchorLocals() {
 	        return this.anchors.map((i) => this.graph.vertexLocal(i));
 	    }
 	    get anchorCount() {
 	        return this.anchors.length;
 	    }
-	    /** 把所有路径顶点(world)+ 法线 拼成折线;closed 时补一段首尾路径。 */
+	    /** Stitch all path vertices (world) + normals into a polyline; when closed, add one first-to-last segment. */
 	    buildVertices(closed) {
 	        const segs = this.segments.slice();
 	        if (closed && this.anchors.length > 2) {
@@ -61229,22 +61312,22 @@ void main() {
 	        }
 	        const idxPath = [];
 	        segs.forEach((s, si) => {
-	            const start = si === 0 ? 0 : 1; // 去重相邻段共享端点
+	            const start = si === 0 ? 0 : 1; // dedupe the endpoint shared between adjacent segments
 	            for (let k = start; k < s.length; k++)
 	                idxPath.push(s[k]);
 	        });
 	        if (idxPath.length === 0 && this.anchors.length === 1) {
 	            idxPath.push(this.anchors[0]);
 	        }
-	        // 图几何即 local 空间,直接产出 local 顶点(渲染时再派生 world)。
+	        // 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));
 	    }
 	}
 
 	/**
-	 * 标注数据模型 + 撤销栈 + 导出。纯数据,无 three / DOM 依赖。
-	 * 撤销只记录 add / remove 两类原子操作(满足"撤销最近添加 / 恢复删除")。
-	 * 通过 subscribe 通知 UI 与渲染层(后者据 list() 做场景对账)。
+	 * Annotation data model + undo stack + export. Pure data, no three / DOM dependencies.
+	 * Undo only records two atomic operations, add / remove (enough for "undo last add / restore delete").
+	 * Notifies the UI and render layer via subscribe (the latter reconciles the scene against list()).
 	 */
 	class AnnotationStore {
 	    constructor() {
@@ -61287,7 +61370,7 @@ void main() {
 	        }
 	        this.notify();
 	    }
-	    /** 清空,返回被清掉的项(供渲染层 dispose three 对象)。 */
+	    /** Clear all, returning the removed items (so the render layer can dispose three objects). */
 	    clear() {
 	        const old = this.items;
 	        this.items = [];
@@ -61348,13 +61431,14 @@ void main() {
 	const LINE_W = 3;
 	const LINE_W_SEL = 6;
 	/**
-	 * 表面标注主控制器(Phase 4):navigate / freehand / geodesic / point 四模式,
-	 * Enter 闭合,数据交给 AnnotationStore 管理(多条带颜色标签、撤销/删除/清空、导出)。
-	 * 渲染层据 store.list() 做场景对账(reconcile),撤销/删除自动加/移 three 对象。
+	 * Main surface-annotation controller (Phase 4): four modes navigate / freehand / geodesic / point,
+	 * Enter closes the loop, and data is managed by AnnotationStore (multiple color-labeled strips,
+	 * undo/delete/clear, export).
+	 * The render layer reconciles the scene against store.list(); undo/delete automatically add/remove three objects.
 	 */
 	class SurfaceAnnotator {
 	    constructor(opts) {
-	        var _a, _b;
+	        var _a, _b, _c;
 	        this.mode = "navigate";
 	        this.spaceHeld = false;
 	        this.pointerDown = false;
@@ -61362,12 +61446,12 @@ void main() {
 	        this.managed = new Set();
 	        this.seq = 0;
 	        this.selectedId = null;
-	        this.activeGeoMarkers = []; // 进行中测地线的可见锚点
+	        this.activeGeoMarkers = []; // visible anchors of the in-progress geodesic
 	        this.geoRay = new Raycaster();
 	        this.geoNdc = new Vector2();
 	        this.hoveredGeoMarker = -1;
 	        this._projV = new Vector3();
-	        /** 窗口尺寸变化时更新所有 fat line 的像素分辨率,否则线宽会失真。 */
+	        /** Update the pixel resolution of all fat lines on window resize, otherwise line width distorts. */
 	        this.onResize = () => {
 	            const w = this.o.container.clientWidth;
 	            const h = this.o.container.clientHeight;
@@ -61386,7 +61470,7 @@ void main() {
 	            if (this.spaceHeld)
 	                return;
 	            if (e.button !== 0)
-	                return; // 仅左键
+	                return; // left button only
 	            if (!this.insideContainer(e))
 	                return;
 	            this.pointerDown = true;
@@ -61421,7 +61505,7 @@ void main() {
 	                return;
 	            }
 	            if (this.mode === "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);
@@ -61433,7 +61517,7 @@ void main() {
 	                    }
 	                    return;
 	                }
-	                // 否则在表面落一个新锚点。
+	                // Otherwise drop a new anchor on the surface.
 	                const h = this.hit(e);
 	                if (!h)
 	                    return;
@@ -61451,7 +61535,7 @@ void main() {
 	                this.setGeoHover(-1);
 	                return;
 	            }
-	            // 测地线模式下,悬停到锚点小球时显示"✕"提示(该点可被点击取消)。
+	            // In geodesic mode, show the "✕" hint when hovering an anchor sphere (that point can be clicked to cancel).
 	            if (this.mode === "geodesic" && !this.pointerDown) {
 	                this.setGeoHover(this.insideContainer(e) ? this.pickGeoMarker(e) : -1);
 	            }
@@ -61516,7 +61600,7 @@ void main() {
 	                return;
 	            }
 	            if (e.key === "Enter") {
-	                // 测地线进行中 → 结束并闭合;否则闭合最近一条自由手绘线。
+	                // Geodesic in progress → finish and close it; otherwise close the most recent freehand line.
 	                if (this.activeGeo)
 	                    this.finishGeodesic();
 	                else
@@ -61541,24 +61625,25 @@ void main() {
 	        this.o = opts;
 	        const meshGeo = opts.mesh.geometry;
 	        if (!meshGeo.getAttribute("normal"))
-	            meshGeo.computeVertexNormals(); // 渲染需要法线
+	            meshGeo.computeVertexNormals(); // rendering needs normals
 	        meshGeo.computeBoundingBox();
 	        const diag = (_a = opts.bboxDiagonal) !== null && _a !== void 0 ? _a : meshGeo.boundingBox.getSize(new Vector3()).length();
 	        this.markerRadius = (_b = opts.markerRadius) !== null && _b !== void 0 ? _b : diag * 0.0032;
-	        this.epsilon = diag * 0.002;
+	        this.epsilon = (_c = opts.epsilon) !== null && _c !== void 0 ? _c : diag * 0.002;
 	        this.minGap = diag * 0.004;
 	        this.maxJump = diag * 0.05;
-	        // 测地线连通性:单独焊接一份"仅位置"的几何给 MeshGraph 用——
-	        // 不动被渲染的 mesh(保留其法线/UV/纹理)。仅位置可保证同表面位置的顶点
-	        // 被 mergeVertices 合并(否则逐面法线/UV 会阻止合并,图断裂 → 闭合穿模)。
+	        // Geodesic connectivity: weld a separate "position-only" geometry for MeshGraph to use —
+	        // leaving the rendered mesh untouched (keeping its normals/UV/texture). Position-only ensures
+	        // vertices at the same surface position get merged by mergeVertices (otherwise per-face
+	        // normals/UV would block the merge, breaking the graph → the closed loop cuts through the model).
 	        const posOnly = new BufferGeometry();
 	        posOnly.setAttribute("position", meshGeo.getAttribute("position").clone());
 	        const graphGeo = mergeVertices(posOnly);
 	        graphGeo.computeVertexNormals();
 	        this.graph = new MeshGraph(graphGeo);
 	        this.store.subscribe(() => this.reconcile());
-	        // 监听挂到 window 的捕获阶段(capture=true):在 copper 的 TrackballControls
-	        // 之前拿到每一个指针事件,避免它的 setPointerCapture / 事件路由导致拖拽中途丢 move。
+	        // Listen on window in the capture phase (capture=true): receive every pointer event before
+	        // copper's TrackballControls, so its setPointerCapture / event routing doesn't drop moves mid-drag.
 	        window.addEventListener("pointerdown", this.onPointerDown, true);
 	        window.addEventListener("pointermove", this.onPointerMove, true);
 	        window.addEventListener("pointerup", this.onPointerUp, true);
@@ -61579,13 +61664,13 @@ void main() {
 	        var _a;
 	        return (_a = this.o.pointColor) !== null && _a !== void 0 ? _a : "#ffd166";
 	    }
-	    // ---- 对外 API(供 Vue 调用) ----
+	    // ---- Public API (called from Vue) ----
 	    getMode() {
 	        return this.mode;
 	    }
 	    setMode(m) {
 	        var _a, _b;
-	        // 离开测地线模式时丢弃尚未 Enter 落定的进行中测地线(清掉残留的锚点与线)。
+	        // 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();
 	        this.mode = m;
@@ -61595,13 +61680,13 @@ void main() {
 	    getStore() {
 	        return this.store;
 	    }
-	    /** 当前标注列表快照。 */
+	    /** Snapshot of the current annotation list. */
 	    getAnnotations() {
 	        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.
 	        if (this.activeGeo && this.activeGeo.canUndo()) {
 	            this.activeGeo.undoEdit();
 	            if (this.activeGeo.anchorCount === 0)
@@ -61635,7 +61720,7 @@ void main() {
 	        this.selectedId = id;
 	        this.applySelection();
 	    }
-	    /** 颜色变更后重画对应 three 对象。 */
+	    /** Redraw the corresponding three object after a color change. */
 	    refreshAnnotation(id) {
 	        const a = this.store.get(id);
 	        if (!a || !a.object3D)
@@ -61651,12 +61736,12 @@ void main() {
 	    exportJSON(modelName, opts) {
 	        return this.store.toJSON(modelName, this.o.mesh, opts);
 	    }
-	    // ---- 内部 ----
+	    // ---- Internal ----
 	    applyCameraGating() {
-	        // 按住 Space 临时旋转优先;否则仅 navigate 模式开相机。
+	        // Holding Space for temporary rotation takes priority; otherwise enable the camera only in navigate mode.
 	        this.o.controls.enabled = this.spaceHeld || this.mode === "navigate";
 	    }
-	    /** 据 store.list() 对账场景:补齐缺失对象、移除已删对象(不 dispose,留给撤销恢复)。 */
+	    /** Reconcile the scene against store.list(): add missing objects, remove deleted ones (no dispose, kept for undo restore). */
 	    reconcile() {
 	        var _a, _b;
 	        const present = new Set();
@@ -61706,29 +61791,53 @@ void main() {
 	        return raycastSurface(this.o.camera, this.o.container, this.o.mesh, e.clientX, e.clientY);
 	    }
 	    /**
-	     * 事件目标是否是容器内的 WebGL canvas。
-	     * 仅认 canvas:面板(GUIDE / 控制面板 / 标注列表的 ✕ 按钮)都是 container 的子元素,
-	     * 若只判断 contains 会把面板上的点击也当成在模型上作画 —— 这会"穿透"删除按钮、
-	     * 让 ✕ 难以点中。只响应 canvas 上的指针事件即可彻底隔离 UI 与画布。
+	     * Whether the event target is the WebGL canvas inside the container.
+	     * Only accept the canvas: panels (GUIDE / control panel / the ✕ buttons in the annotation list)
+	     * are all children of the container, so checking contains alone would treat clicks on the panels
+	     * as drawing on the model — which "leaks through" the delete buttons and makes ✕ hard to click.
+	     * Responding only to pointer events on the canvas fully isolates the UI from the drawing surface.
 	     */
 	    insideContainer(e) {
 	        const t = e.target;
 	        return !!t && t.tagName === "CANVAS" && this.o.container.contains(t);
 	    }
-	    /** 射线拾取进行中的锚点小球,返回锚点下标;未命中返回 -1。 */
+	    /**
+	     * Pick an in-progress anchor: return the index of the nearest anchor (screen pixel distance <
+	     * tolerance), or -1 on a miss.
+	     *
+	     * Uses "screen-space pixel distance" instead of ray/sphere intersection: the anchor spheres are
+	     * tiny, so strict ray/sphere hits require pixel-perfect aiming and most clicks miss — and a miss
+	     * falls through to the "add anchor" branch, so trying to delete a point ends up adding one. That
+	     * was the root cause of the old "deleting a point takes several clicks, must hit the sphere dead
+	     * center" problem. Projecting each anchor to the screen and taking the nearest within tolerance
+	     * makes deletion stable and reliable. The tolerance is enlarged relative to the sphere's screen
+	     * radius to make it easy to hit.
+	     */
 	    pickGeoMarker(e) {
 	        if (!this.activeGeoMarkers.length)
 	            return -1;
 	        const rect = this.o.container.getBoundingClientRect();
-	        this.geoNdc.x = ((e.clientX - rect.left) / rect.width) * 2 - 1;
-	        this.geoNdc.y = -((e.clientY - rect.top) / rect.height) * 2 + 1;
-	        this.geoRay.setFromCamera(this.geoNdc, this.o.camera);
-	        const hits = this.geoRay.intersectObjects(this.activeGeoMarkers, false);
-	        if (!hits.length)
-	            return -1;
-	        return this.activeGeoMarkers.indexOf(hits[0].object);
+	        const px = e.clientX - rect.left;
+	        const py = e.clientY - rect.top;
+	        const TOL = 16; // hit tolerance (pixels), larger than the sphere itself for forgiving clicks
+	        let best = -1;
+	        let bestDist = TOL;
+	        const v = this._projV;
+	        for (let i = 0; i < this.activeGeoMarkers.length; i++) {
+	            v.copy(this.activeGeoMarkers[i].position).project(this.o.camera);
+	            if (v.z > 1)
+	                continue; // projects behind the camera, skip
+	            const sx = (v.x * 0.5 + 0.5) * rect.width;
+	            const sy = (-v.y * 0.5 + 0.5) * rect.height;
+	            const d = Math.hypot(sx - px, sy - py);
+	            if (d < bestDist) {
+	                bestDist = d;
+	                best = i;
+	            }
+	        }
+	        return best;
 	    }
-	    /** 设置当前悬停的锚点(-1 = 无):更新高亮缩放、光标与"✕(可取消)"悬浮标。 */
+	    /** Set the currently hovered anchor (-1 = none): update highlight scale, cursor, and the "✕ (cancel)" floating badge. */
 	    setGeoHover(idx) {
 	        if (idx === this.hoveredGeoMarker) {
 	            if (idx >= 0)
@@ -61752,7 +61861,7 @@ void main() {
 	            this.o.container.style.cursor = "";
 	        }
 	    }
-	    /** 懒创建悬浮 ✕ 标(挂在 container 内,pointer-events:none 不挡点击)。 */
+	    /** 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;
@@ -61780,7 +61889,7 @@ void main() {
 	        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;
@@ -61792,7 +61901,7 @@ void main() {
 	        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). */
 	    rebuildGeoMarkers() {
 	        this.setGeoHover(-1);
 	        for (const m of this.activeGeoMarkers) {
@@ -61808,7 +61917,7 @@ void main() {
 	            this.activeGeoMarkers.push(marker);
 	        }
 	    }
-	    /** 据当前锚点重画进行中的测地线(不闭合);不足两点时移除线。 */
+	    /** Redraw the in-progress geodesic from the current anchors (not closed); remove the line when fewer than two points. */
 	    redrawGeoLine() {
 	        if (!this.activeGeo)
 	            return;
@@ -61829,7 +61938,7 @@ void main() {
 	            updateContourLine(this.activeGeoLine, verts, false, this.epsilon, this.o.mesh);
 	        }
 	    }
-	    /** 丢弃进行中的测地线:移除并 dispose 线与全部锚点。 */
+	    /** Discard the in-progress geodesic: remove and dispose the line and all anchors. */
 	    clearActiveGeo() {
 	        this.setGeoHover(-1);
 	        if (this.activeGeoLine) {
@@ -61844,7 +61953,7 @@ void main() {
 	        this.activeGeoMarkers = [];
 	        this.activeGeo = undefined;
 	    }
-	    /** 移除进行中测地线的全部锚点小球(落定后调用:只留下线)。 */
+	    /** Remove all anchor spheres of the in-progress geodesic (called after committing: only the line remains). */
 	    removeGeoMarkers() {
 	        this.setGeoHover(-1);
 	        for (const m of this.activeGeoMarkers) {
@@ -61857,7 +61966,7 @@ void main() {
 	        const last = this.lastFreehand;
 	        if (!last || last.closed || last.vertices.length < 3 || !last.object3D)
 	            return;
-	        // 用测地线沿表面把末点连回首点,避免直线弦从模型内部"抄近路"被遮挡。
+	        // Use a geodesic along the surface to connect the last point back to the first, so a straight chord doesn't "shortcut" through the model interior and get occluded.
 	        const tail = last.vertices[last.vertices.length - 1];
 	        const head = last.vertices[0];
 	        const closing = this.surfacePathBetween(tail, head);
@@ -61865,14 +61974,14 @@ void main() {
 	        last.closed = true;
 	        updateContourLine(last.object3D, last.vertices, true, this.epsilon, this.o.mesh);
 	    }
-	    /** 沿网格表面求 a→b 的测地路径(local 顶点),去掉与 a 重合的首点。a/b 已是 local。 */
+	    /** Compute the geodesic path a→b along the mesh surface (local vertices), dropping the first point that coincides with a. a/b are already local. */
 	    surfacePathBetween(a, b) {
 	        const va = this.graph.nearestVertex(new Vector3(a.x, a.y, a.z));
 	        const vb = this.graph.nearestVertex(new Vector3(b.x, b.y, b.z));
 	        const path = this.graph.shortestPath(va, vb);
 	        return path.slice(1).map((i) => this.graph.vertexLocal(i));
 	    }
-	    /** 结束当前测地线:闭合成环并落定为一条 contour。 */
+	    /** Finish the current geodesic: close it into a ring and commit it as one contour. */
 	    finishGeodesic() {
 	        if (!this.activeGeo || !this.activeGeoLine)
 	            return;
@@ -61896,7 +62005,7 @@ void main() {
 	            this.o.scene.remove(this.activeGeoLine);
 	            this.disposeObject(this.activeGeoLine);
 	        }
-	        // 落定后清掉可见锚点,只留下贴合表面的线。
+	        // After committing, clear the visible anchors and leave only the surface-hugging line.
 	        this.removeGeoMarkers();
 	        this.activeGeo = undefined;
 	        this.activeGeoLine = undefined;
@@ -62011,9 +62120,9 @@ void main() {
 	        copperVtkLoader(url, this.scene, this.content);
 	    }
 	    /**
-	     * 在给定模型表面创建标注器(画 contour / 放点 / 导出坐标)。
-	     * target 可为单个 Mesh,或 Group/Object3D(自动选顶点数最多的 mesh)。
-	     * 复用本 scene 的 camera / container / controls;几何非索引时内部自动焊接索引化。
+	     * Create an annotator on the surface of a given model (draw contours / place points / export coordinates).
+	     * target can be a single Mesh, or a Group/Object3D (the mesh with the most vertices is chosen automatically).
+	     * Reuses this scene's camera / container / controls; non-indexed geometry is welded and indexed automatically.
 	     */
 	    createSurfaceAnnotator(target, opts) {
 	        const mesh = this.pickAnnotatableMesh(target);
@@ -62041,7 +62150,7 @@ void main() {
 	        });
 	        return best;
 	    }
-	    /** 释放本 scene 创建的所有标注器(移除事件监听与标注对象)。 */
+	    /** Dispose all annotators created on this scene (removes event listeners and annotation objects). */
 	    disposeSurfaceAnnotators() {
 	        this.surfaceAnnotators.forEach((a) => a.dispose());
 	        this.surfaceAnnotators = [];
@@ -79015,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;
@@ -79033,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) ────────────────────
@@ -79052,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 →
@@ -79103,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. */
@@ -79123,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();
@@ -79176,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) ───────────────────────────────────
 	    //
@@ -79240,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 {
@@ -79263,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.
@@ -79318,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;
@@ -79353,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).
@@ -79426,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;
@@ -79442,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.
@@ -82478,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). */
@@ -82498,6 +83013,11 @@ 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
@@ -82900,8 +83420,15 @@ void main() {
 	}
 
 	// import * as kiwrious from "copper3d_plugin_heart_k";
-	const REVISION = "v3.6.2-beta";
-	console.log(`%cCopper3D Visualisation %cBeta:${REVISION}`, "padding: 3px;color:white; background:#023047", "padding: 3px;color:white; background:#f50a25");
+	// "v3.6.5" is injected at build time by rollup @rollup/plugin-replace, sourced from package.json version
+	const REVISION = "v3.6.5";
+	// 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;