brepjs 18.62.1 → 18.64.0

package/dist/{shapeTypes-DsbDmdSa.js → shapeTypes-B2tufXyI.js}

@@ -1055,7 +1055,7 @@ function at(arr, i) {
 	if (v === void 0) throw new Error(`Index ${i} out of bounds`);
 	return v;
 }
-function extractVertices(oc, shapes, tolerance) {
+function extractVertices$1(oc, shapes, tolerance) {
 	const vertices = [];
 	const meshDeflection = Math.max(tolerance, 1);
 	for (const shape of shapes) {
@@ -1152,7 +1152,7 @@ function reconstructBrep(oc, hullResult, tolerance) {
 */
 function hull$1(oc, shapes, tolerance) {
 	if (shapes.length === 0) throw new Error("hull: no shapes provided");
-	const vertices = extractVertices(oc, shapes, tolerance);
+	const vertices = extractVertices$1(oc, shapes, tolerance);
 	if (vertices.length < 4) throw new Error("hull: fewer than 4 vertices extracted from input shapes");
 	const hullResult = quickHull(vertices, tolerance);
 	if (hullResult.faces.length < 4) throw new Error("hull: degenerate hull (fewer than 4 faces)");
@@ -2167,7 +2167,7 @@ function transformBatch$2(oc, entries) {
 /**
 * Applies a transformation matrix to a shape.
 */
-function transform$2(oc, shape, trsf) {
+function transform$3(oc, shape, trsf) {
 	const transformer = new oc.BRepBuilderAPI_Transform_2(shape, trsf, true, false);
 	const result = transformer.ModifiedShape(shape);
 	transformer.delete();
@@ -2180,7 +2180,7 @@ function translate$2(oc, shape, x, y, z) {
 	const trsf = new oc.gp_Trsf_1();
 	const vec = new oc.gp_Vec_4(x, y, z);
 	trsf.SetTranslation_1(vec);
-	const result = transform$2(oc, shape, trsf);
+	const result = transform$3(oc, shape, trsf);
 	trsf.delete();
 	vec.delete();
 	return result;
@@ -2202,7 +2202,7 @@ function rotate$2(oc, shape, angle, axis = [
 	const dir = new oc.gp_Dir_5(...axis);
 	const ax1 = new oc.gp_Ax1_2(origin, dir);
 	trsf.SetRotation_1(ax1, angle * Math.PI / 180);
-	const result = transform$2(oc, shape, trsf);
+	const result = transform$3(oc, shape, trsf);
 	trsf.delete();
 	ax1.delete();
 	origin.delete();
@@ -2218,7 +2218,7 @@ function mirror$2(oc, shape, origin, normal) {
 	const dir = new oc.gp_Dir_5(...normal);
 	const ax2 = new oc.gp_Ax2_4(pnt, dir);
 	trsf.SetMirror_3(ax2);
-	const result = transform$2(oc, shape, trsf);
+	const result = transform$3(oc, shape, trsf);
 	trsf.delete();
 	ax2.delete();
 	pnt.delete();
@@ -2232,7 +2232,7 @@ function scale$2(oc, shape, center, factor) {
 	const trsf = new oc.gp_Trsf_1();
 	const pnt = new oc.gp_Pnt_3(...center);
 	trsf.SetScale(pnt, factor);
-	const result = transform$2(oc, shape, trsf);
+	const result = transform$3(oc, shape, trsf);
 	trsf.delete();
 	pnt.delete();
 	return result;
@@ -2280,7 +2280,7 @@ function simplify$2(oc, shape) {
 /** Co-located factory: returns the transform slice of {@link KernelAdapter} bound to `oc`. */
 function makeTransformOps$2(oc) {
 	return {
-		transform: (shape, trsf) => transform$2(oc, shape, trsf),
+		transform: (shape, trsf) => transform$3(oc, shape, trsf),
 		translate: (shape, x, y, z) => translate$2(oc, shape, x, y, z),
 		rotate: (shape, angle, axis, center) => rotate$2(oc, shape, angle, axis, center),
 		mirror: (shape, origin, normal) => mirror$2(oc, shape, origin, normal),
@@ -6065,7 +6065,7 @@ function makeGeometryOps$1(bk) {
 }
 //#endregion
 //#region src/kernel/brepkit/transformOps.ts
-function transform$1(bk, shape, trsf) {
+function transform$2(bk, shape, trsf) {
 	if (Array.isArray(trsf) && trsf.length === 16) return applyMatrix$1(bk, shape, trsf);
 	throw new Error("brepkit: transform expects a 16-element matrix array");
 }
@@ -6143,7 +6143,7 @@ function transformBatch$1(bk, entries) {
 /** Co-located factory: returns the transform slice of {@link KernelAdapter} bound to `bk`. */
 function makeTransformOps$1(bk) {
 	return {
-		transform: (shape, trsf) => transform$1(bk, shape, trsf),
+		transform: (shape, trsf) => transform$2(bk, shape, trsf),
 		translate: (shape, x, y, z) => translate$1(bk, shape, x, y, z),
 		rotate: (shape, angle, axis, center) => rotate$1(bk, shape, angle, axis, center),
 		mirror: (shape, origin, normal) => mirror$1(bk, shape, origin, normal),
@@ -9679,7 +9679,10 @@ var REPLAYABLE_OPS = new Set([
 	"reverseShape",
 	"hull",
 	"hullFromPoints",
-	"sewAndSolidify"
+	"sewAndSolidify",
+	"profileEdge",
+	"profileWire",
+	"profileFace"
 ]);
 function opIsReplayable(op) {
 	return REPLAYABLE_OPS.has(op);
@@ -10180,7 +10183,7 @@ function scale(shape, center, factor) {
 		factor
 	}, nodeOf(s));
 }
-function transform(shape, trsf) {
+function transform$1(shape, trsf) {
 	if (!Array.isArray(trsf) || trsf.length !== 16) throw new Error("manifold: transform expects a 16-element column-major matrix");
 	const s = asShape$3(shape);
 	return applyMatrix(unwrap(s), trsf, "transformShape", { matrix: [...trsf] }, nodeOf(s));
@@ -10262,7 +10265,7 @@ function transformBatch(entries) {
 function makeTransformOps(module) {
 	return {
 		composeTransform,
-		transform,
+		transform: transform$1,
 		translate,
 		rotate,
 		mirror,
@@ -10290,65 +10293,170 @@ function multiplyMatrix(a, b) {
 	return out;
 }
 //#endregion
-//#region src/kernel/manifold/builderOps.ts
-function makeBuilderOps(module) {
-	const Manifold = module.Manifold;
-	function hullFromPoints(points, tolerance) {
-		const coords = points.map((p) => [
-			p.x,
-			p.y,
-			p.z
-		]);
-		return wrap(Manifold.hull(coords), makeNode("hullFromPoints", {
-			points: coords,
-			tolerance
-		}, []));
-	}
-	function hull(shapes, tolerance) {
-		const operands = shapes.map((s) => unwrap(s));
-		return wrap(Manifold.hull(operands), makeNode("hull", { tolerance }, shapes.map((s) => nodeOf(s))));
-	}
-	function sewAndSolidify(faces, tolerance) {
-		const first = faces[0];
-		if (!first) notImplemented("sewAndSolidify (no input faces on manifold kernel)");
-		return wrap(unwrap(first), makeNode("sewAndSolidify", { tolerance }, faces.map((f) => nodeOf(f))));
+//#region src/kernel/manifold/curveDesc.ts
+var TAU = 2 * Math.PI;
+var hypot3 = (a) => Math.hypot(a[0], a[1], a[2]);
+var sub3 = (a, b) => [
+	a[0] - b[0],
+	a[1] - b[1],
+	a[2] - b[2]
+];
+function lineLen(d) {
+	return hypot3(sub3(d.p2, d.p1));
+}
+function bezierAt$1(points, t) {
+	const tmp = points.map((p) => [
+		p[0],
+		p[1],
+		p[2]
+	]);
+	for (let k = 1; k < tmp.length; k++) for (let i = 0; i < tmp.length - k; i++) {
+		const a = tmp[i] ?? [
+			0,
+			0,
+			0
+		];
+		const b = tmp[i + 1] ?? [
+			0,
+			0,
+			0
+		];
+		tmp[i] = [
+			a[0] * (1 - t) + b[0] * t,
+			a[1] * (1 - t) + b[1] * t,
+			a[2] * (1 - t) + b[2] * t
+		];
 	}
+	return tmp[0] ?? [
+		0,
+		0,
+		0
+	];
+}
+function descType(d) {
+	if (d.k === "line") return "LINE";
+	if (d.k === "bezier") return "BEZIER";
+	if (d.k === "helix") return "BSPLINE";
+	return Math.abs(d.rx - d.ry) < 1e-9 * Math.max(1, d.rx) ? "CIRCLE" : "ELLIPSE";
+}
+/** Parameter bounds: line → [0, length]; conic → [a0, a1]; helix → [0, 2π·turns]; bezier → [0, 1]. */
+function descBounds(d) {
+	if (d.k === "line") return {
+		first: 0,
+		last: lineLen(d)
+	};
+	if (d.k === "conic") return {
+		first: d.a0,
+		last: d.a1
+	};
+	if (d.k === "helix") return {
+		first: 0,
+		last: TAU * d.turns
+	};
 	return {
-		makeVertex: () => notImplemented("makeVertex"),
-		makeEdge: () => notImplemented("makeEdge"),
-		makeWire: () => notImplemented("makeWire"),
-		makeFace: () => notImplemented("makeFace"),
-		makeLineEdge: () => notImplemented("makeLineEdge"),
-		makeCircleEdge: () => notImplemented("makeCircleEdge"),
-		makeCircleArc: () => notImplemented("makeCircleArc"),
-		makeArcEdge: () => notImplemented("makeArcEdge"),
-		makeEllipseEdge: () => notImplemented("makeEllipseEdge"),
-		makeEllipseArc: () => notImplemented("makeEllipseArc"),
-		makeBezierEdge: () => notImplemented("makeBezierEdge"),
-		makeTangentArc: () => notImplemented("makeTangentArc"),
-		makeHelixWire: () => notImplemented("makeHelixWire"),
-		makeWireFromMixed: () => notImplemented("makeWireFromMixed"),
-		makeCompound: () => notImplemented("makeCompound"),
-		solidFromShell: () => notImplemented("solidFromShell"),
-		hull,
-		hullFromPoints,
-		buildSolidFromFaces: () => notImplemented("buildSolidFromFaces"),
-		makeNonPlanarFace: () => notImplemented("makeNonPlanarFace"),
-		addHolesInFace: () => notImplemented("addHolesInFace"),
-		removeHolesFromFace: () => notImplemented("removeHolesFromFace"),
-		makeFaceOnSurface: () => notImplemented("makeFaceOnSurface"),
-		bsplineSurface: (points, rows, cols) => occtOrThrow("bsplineSurface").bsplineSurface(points, rows, cols),
-		triangulatedSurface: (points, rows, cols) => occtOrThrow("triangulatedSurface").triangulatedSurface(points, rows, cols),
-		buildTriFace: () => notImplemented("buildTriFace"),
-		sewAndSolidify,
-		createPoint3d: () => notImplemented("createPoint3d"),
-		createDirection3d: () => notImplemented("createDirection3d"),
-		createVector3d: () => notImplemented("createVector3d"),
-		createAxis1: () => notImplemented("createAxis1"),
-		createAxis2: () => notImplemented("createAxis2"),
-		createAxis3: () => notImplemented("createAxis3")
+		first: 0,
+		last: 1
 	};
 }
+function descPointAt(d, param) {
+	if (d.k === "line") {
+		const t = param / (lineLen(d) || 1);
+		return [
+			d.p1[0] + (d.p2[0] - d.p1[0]) * t,
+			d.p1[1] + (d.p2[1] - d.p1[1]) * t,
+			d.p1[2] + (d.p2[2] - d.p1[2]) * t
+		];
+	}
+	if (d.k === "bezier") return bezierAt$1(d.points, param);
+	if (d.k === "helix") {
+		const ct = Math.cos(param);
+		const st = Math.sin(param);
+		const z = d.pitch * param / TAU;
+		return [
+			d.center[0] + d.radius * (ct * d.x[0] + st * d.y[0]) + z * d.axis[0],
+			d.center[1] + d.radius * (ct * d.x[1] + st * d.y[1]) + z * d.axis[1],
+			d.center[2] + d.radius * (ct * d.x[2] + st * d.y[2]) + z * d.axis[2]
+		];
+	}
+	const ct = Math.cos(param);
+	const st = Math.sin(param);
+	return [
+		d.center[0] + d.rx * ct * d.x[0] + d.ry * st * d.y[0],
+		d.center[1] + d.rx * ct * d.x[1] + d.ry * st * d.y[1],
+		d.center[2] + d.rx * ct * d.x[2] + d.ry * st * d.y[2]
+	];
+}
+function descTangent(d, param) {
+	let t;
+	if (d.k === "line") t = sub3(d.p2, d.p1);
+	else if (d.k === "bezier") {
+		const a = bezierAt$1(d.points, Math.max(0, param - 1e-4));
+		t = sub3(bezierAt$1(d.points, Math.min(1, param + 1e-4)), a);
+	} else if (d.k === "helix") {
+		const ct = Math.cos(param);
+		const st = Math.sin(param);
+		const k = d.pitch / TAU;
+		t = [
+			d.radius * (-st * d.x[0] + ct * d.y[0]) + k * d.axis[0],
+			d.radius * (-st * d.x[1] + ct * d.y[1]) + k * d.axis[1],
+			d.radius * (-st * d.x[2] + ct * d.y[2]) + k * d.axis[2]
+		];
+	} else {
+		const ct = Math.cos(param);
+		const st = Math.sin(param);
+		t = [
+			-d.rx * st * d.x[0] + d.ry * ct * d.y[0],
+			-d.rx * st * d.x[1] + d.ry * ct * d.y[1],
+			-d.rx * st * d.x[2] + d.ry * ct * d.y[2]
+		];
+	}
+	const l = hypot3(t) || 1;
+	return [
+		t[0] / l,
+		t[1] / l,
+		t[2] / l
+	];
+}
+/** Exact length where closed-form exists; Ramanujan for full ellipses; numeric otherwise. */
+function descLength(d) {
+	if (d.k === "line") return lineLen(d);
+	if (d.k === "helix") {
+		const c = TAU * d.radius;
+		return d.turns * Math.sqrt(c * c + d.pitch * d.pitch);
+	}
+	if (d.k === "conic") {
+		const span = Math.abs(d.a1 - d.a0);
+		if (Math.abs(d.rx - d.ry) < 1e-9 * Math.max(1, d.rx)) return d.rx * span;
+		if (Math.abs(span - TAU) < 1e-9) {
+			const a = d.rx;
+			const b = d.ry;
+			const h = (a - b) * (a - b) / ((a + b) * (a + b));
+			return Math.PI * (a + b) * (1 + 3 * h / (10 + Math.sqrt(4 - 3 * h)));
+		}
+		return numericLength((t) => descPointAt(d, t), d.a0, d.a1, 256);
+	}
+	return numericLength((t) => descPointAt(d, t), 0, 1, 128);
+}
+function descIsClosed(d) {
+	if (d.k === "conic") return Math.abs(Math.abs(d.a1 - d.a0) - TAU) < 1e-9;
+	return false;
+}
+function descIsPeriodic(d) {
+	return descIsClosed(d);
+}
+function descPeriod(d) {
+	return d.k === "conic" ? TAU : 0;
+}
+function numericLength(at, t0, t1, n) {
+	let len = 0;
+	let prev = at(t0);
+	for (let i = 1; i <= n; i++) {
+		const p = at(t0 + (t1 - t0) * i / n);
+		len += hypot3(sub3(p, prev));
+		prev = p;
+	}
+	return len;
+}
 //#endregion
 //#region src/kernel/manifold/approximations.ts
 function asShape$2(shape) {
@@ -10436,6 +10544,10 @@ function signedArea(outline) {
 function ensureCCW(outline) {
 	return signedArea(outline) < 0 ? [...outline].reverse() : outline;
 }
+/** Force CW winding (used for holes, opposite the CCW outline). */
+function ensureCW(outline) {
+	return signedArea(outline) > 0 ? [...outline].reverse() : outline;
+}
 function readNodeParams(shape) {
 	return shape.node?.params;
 }
@@ -10458,8 +10570,10 @@ function profileCrossSection(profile) {
 			0
 		];
 		const outline = ensureCCW(recorded.map((p) => [p[0], p[1]]));
+		const holes = (params?.["holes"])?.filter((h) => h.length >= 3).map((h) => ensureCW(h.map((p) => [p[0], p[1]])));
 		if (params?.["xAxis"] && params["yAxis"]) return {
 			outline,
+			holes,
 			origin,
 			xAxis: params["xAxis"],
 			yAxis: params["yAxis"]
@@ -10471,6 +10585,7 @@ function profileCrossSection(profile) {
 		]);
 		return {
 			outline,
+			holes,
 			origin,
 			xAxis,
 			yAxis
@@ -10546,6 +10661,54 @@ function fanTriangulate(vertexCount) {
 * in correspondence with the section's outline order. `scale` rescales the
 * outline about its frame origin (for tapered/draft sweeps and scale laws).
 */
+/**
+* Upsample a closed 2D outline to exactly `n` points by KEEPING every original
+* vertex and inserting extra points on the longest segments (proportional to
+* length, largest-remainder allotment). Vertex-preserving so corners aren't
+* rounded off — resampling a 4-point rectangle to 4 returns it unchanged. Used
+* to give loft sections a common vertex count so {@link skinRings} can connect
+* them by index; lofting profiles of different point counts (circle ↔ rounded
+* rect) is otherwise impossible on the mesh kernel. `n < k` is not supported
+* (callers pass `n = max` count), so it never downsamples.
+*/
+function resampleClosed(outline, n) {
+	const k = outline.length;
+	if (k < 2 || n <= k) return outline.map((p) => [p[0], p[1]]);
+	const seg = [];
+	let total = 0;
+	for (let i = 0; i < k; i++) {
+		const a = outline[i] ?? [0, 0];
+		const b = outline[(i + 1) % k] ?? [0, 0];
+		const l = Math.hypot(b[0] - a[0], b[1] - a[1]);
+		seg.push(l);
+		total += l;
+	}
+	if (total === 0) return outline.map((p) => [p[0], p[1]]);
+	const extra = n - k;
+	const quota = seg.map((l) => extra * l / total);
+	const add = quota.map((q) => Math.floor(q));
+	let placed = add.reduce((s, v) => s + v, 0);
+	const rema = quota.map((q, i) => ({
+		i,
+		f: q - Math.floor(q)
+	})).sort((x, y) => y.f - x.f);
+	for (let r = 0; placed < extra; r++, placed++) {
+		const idx = rema[r % rema.length]?.i ?? 0;
+		add[idx] = (add[idx] ?? 0) + 1;
+	}
+	const out = [];
+	for (let i = 0; i < k; i++) {
+		const a = outline[i] ?? [0, 0];
+		const b = outline[(i + 1) % k] ?? [0, 0];
+		out.push([a[0], a[1]]);
+		const inner = add[i] ?? 0;
+		for (let j = 1; j <= inner; j++) {
+			const t = j / (inner + 1);
+			out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+		}
+	}
+	return out;
+}
 function placeRing(section, frame, scale = 1) {
 	return section.outline.map((p) => {
 		const lx = p[0] * scale;
@@ -10580,7 +10743,32 @@ function skinRings(module, rings) {
 		vertProperties: Float32Array.from(verts),
 		triVerts: Uint32Array.from(tris)
 	});
-	return new module.Manifold(built);
+	return orientPositive(module, new module.Manifold(built));
+}
+/**
+* Normalize a built solid to outward (positive-volume) orientation. Skinning a
+* profile whose section order or outline winding runs "backwards" yields an
+* inside-out manifold (negative volume) that booleans then mishandle — a cut
+* tool that won't subtract, a fuse operand that cancels volume. If the volume
+* is negative, rebuild with reversed triangle winding so normals face outward.
+*/
+function orientPositive(module, solid) {
+	if (typeof solid.volume !== "function" || solid.volume() >= 0) return solid;
+	const mesh = solid.getMesh();
+	const tv = mesh.triVerts;
+	for (let i = 0; i + 2 < tv.length; i += 3) {
+		const t = tv[i + 1] ?? 0;
+		tv[i + 1] = tv[i + 2] ?? 0;
+		tv[i + 2] = t;
+	}
+	const flipped = new module.Mesh({
+		numProp: mesh.numProp,
+		vertProperties: mesh.vertProperties,
+		triVerts: tv
+	});
+	const result = new module.Manifold(flipped);
+	if (typeof solid.delete === "function") solid.delete();
+	return result;
 }
 /** Build the triangle index list for `ringCount` rings of `m` points each. */
 function skinTriangles(ringCount, m) {
@@ -10670,6 +10858,477 @@ function rotationMinimizingFrames(path, seed) {
 	return frames;
 }
 //#endregion
+//#region src/kernel/manifold/profileOps.ts
+/** Segments used to approximate a full circle; arcs scale by angle span. */
+var FULL_CIRCLE_SEGMENTS = 24;
+/** Bezier sampling segments per edge. */
+var BEZIER_SEGMENTS = 24;
+var ZERO3 = [
+	0,
+	0,
+	0
+];
+var EPS_JOIN = 1e-6;
+var PLACEHOLDER = {
+	delete: () => {},
+	isEmpty: () => false
+};
+function at3(pts, i) {
+	return pts[i] ?? ZERO3;
+}
+function arcSegments(angleSpan) {
+	return Math.max(2, Math.ceil(Math.abs(angleSpan) / (2 * Math.PI) * FULL_CIRCLE_SEGMENTS));
+}
+function pickPerp(n) {
+	return normalize3(cross(n, Math.abs(n[0]) < .9 ? [
+		1,
+		0,
+		0
+	] : [
+		0,
+		1,
+		0
+	]));
+}
+/** Sample a circular arc in the plane framed by `normal` about `center`. */
+function sampleArc(center, normal, radius, startAngle, endAngle, xDir) {
+	const n = normalize3(normal);
+	const x = xDir ? normalize3(xDir) : pickPerp(n);
+	const y = normalize3(cross(n, x));
+	const span = endAngle - startAngle;
+	const segs = arcSegments(span);
+	const pts = [];
+	for (let i = 0; i <= segs; i++) {
+		const a = startAngle + span * i / segs;
+		pts.push(add(center, add(scaleVec(x, radius * Math.cos(a)), scaleVec(y, radius * Math.sin(a)))));
+	}
+	return pts;
+}
+/** Circular arc through three points, sampled as a polyline p1..p2..p3. */
+function circleFrom3(p1, p2, p3) {
+	const v1 = sub(p2, p1);
+	const v2 = sub(p3, p1);
+	const n = cross(v1, v2);
+	if (length3(n) < 1e-12) return [
+		p1,
+		p2,
+		p3
+	];
+	const nn = normalize3(n);
+	const b = dot(v1, v1);
+	const c = dot(v2, v2);
+	const d = dot(v1, v2);
+	const denom = 2 * (b * c - d * d);
+	if (Math.abs(denom) < 1e-18) return [
+		p1,
+		p2,
+		p3
+	];
+	const s = c * (b - d) / denom;
+	const t = b * (c - d) / denom;
+	const center = add(p1, add(scaleVec(v1, s), scaleVec(v2, t)));
+	const radius = length3(sub(p1, center));
+	const x = normalize3(sub(p1, center));
+	const y = normalize3(cross(nn, x));
+	const angleOf = (p) => Math.atan2(dot(sub(p, center), y), dot(sub(p, center), x));
+	let a3 = angleOf(p3);
+	if (a3 < 0) a3 += 2 * Math.PI;
+	return sampleArc(center, nn, radius, 0, a3, x);
+}
+/** De Casteljau sampling of a Bezier of arbitrary degree. */
+function sampleBezier(points) {
+	const out = [];
+	for (let i = 0; i <= BEZIER_SEGMENTS; i++) {
+		const t = i / BEZIER_SEGMENTS;
+		const tmp = points.map((p) => [...p]);
+		for (let k = 1; k < tmp.length; k++) for (let j = 0; j < tmp.length - k; j++) {
+			const a = at3(tmp, j);
+			const bnext = at3(tmp, j + 1);
+			tmp[j] = [
+				a[0] * (1 - t) + bnext[0] * t,
+				a[1] * (1 - t) + bnext[1] * t,
+				a[2] * (1 - t) + bnext[2] * t
+			];
+		}
+		out.push(at3(tmp, 0));
+	}
+	return out;
+}
+/** Newell's method: area-weighted normal of a (possibly non-convex) planar ring. */
+function ringNormal(ring) {
+	let nx = 0;
+	let ny = 0;
+	let nz = 0;
+	for (let i = 0; i < ring.length; i++) {
+		const a = at3(ring, i);
+		const b = at3(ring, (i + 1) % ring.length);
+		nx += (a[1] - b[1]) * (a[2] + b[2]);
+		ny += (a[2] - b[2]) * (a[0] + b[0]);
+		nz += (a[0] - b[0]) * (a[1] + b[1]);
+	}
+	const n = [
+		nx,
+		ny,
+		nz
+	];
+	return length3(n) < 1e-12 ? [
+		0,
+		0,
+		1
+	] : normalize3(n);
+}
+function coincident(a, b) {
+	return length3(sub(a, b)) < EPS_JOIN;
+}
+/** Chain edge polylines head-to-tail into one closed ring (flipping as needed). */
+function chainEdges(edgePts) {
+	const first = edgePts[0];
+	if (!first) return [];
+	const ring = [...first];
+	for (let i = 1; i < edgePts.length; i++) {
+		let pts = edgePts[i] ?? [];
+		if (pts.length === 0) continue;
+		const end = at3(ring, ring.length - 1);
+		const startsAtEnd = coincident(at3(pts, 0), end);
+		const endsAtEnd = coincident(at3(pts, pts.length - 1), end);
+		if (!startsAtEnd && endsAtEnd) pts = [...pts].reverse();
+		const startSame = coincident(at3(pts, 0), end);
+		for (let k = startSame ? 1 : 0; k < pts.length; k++) ring.push(at3(pts, k));
+	}
+	if (ring.length > 1 && coincident(at3(ring, 0), at3(ring, ring.length - 1))) ring.pop();
+	return ring;
+}
+/** Project a planar 3D ring onto its own plane → 2D outline + world frame. */
+function frameFromRing(ring) {
+	const normal = ringNormal(ring);
+	const origin = at3(ring, 0);
+	let xAxis = ring.length > 1 ? normalize3(sub(at3(ring, 1), origin)) : pickPerp(normal);
+	xAxis = normalize3(sub(xAxis, scaleVec(normal, dot(xAxis, normal))));
+	if (length3(xAxis) < 1e-9) xAxis = pickPerp(normal);
+	const yAxis = normalize3(cross(normal, xAxis));
+	return {
+		outline: ensureCCW(ring.map((p) => {
+			const rel = sub(p, origin);
+			return [dot(rel, xAxis), dot(rel, yAxis)];
+		})),
+		origin,
+		xAxis,
+		yAxis
+	};
+}
+var OCCT_CURVE_SEGMENTS = 12;
+/** Sample an OCCT edge into a polyline (line → endpoints, curve → 24 segments). */
+function sampleOcctEdge(occt, edge) {
+	const [t0, t1] = occt.curveParameters(edge);
+	let segs = OCCT_CURVE_SEGMENTS;
+	try {
+		if (occt.curveType(edge) === "line") segs = 1;
+	} catch {}
+	const pts = [];
+	for (let i = 0; i <= segs; i++) pts.push(occt.curvePointAtParam(edge, t0 + (t1 - t0) * i / segs));
+	return pts;
+}
+/** Discretize an OCCT wire (from the 2D-delegated blueprint path) into a ring. */
+function discretizeOcctWire(occt, wire) {
+	return chainEdges(occt.iterShapes(wire, "edge").map((e) => sampleOcctEdge(occt, e)));
+}
+function makeProfileBuilders(_module) {
+	function edge(pts, curve) {
+		return wrap(PLACEHOLDER, makeNode("profileEdge", curve ? {
+			pts,
+			curve
+		} : { pts }, []));
+	}
+	/** In-plane orthonormal frame (x, y) for a conic on a plane with the given normal. */
+	function conicFrame(normal, xDir) {
+		const n = normalize3(normal);
+		const x = xDir ? normalize3(xDir) : pickPerp(n);
+		return {
+			x,
+			y: normalize3(cross(n, x))
+		};
+	}
+	/** Analytic conic descriptor for the circle through three points (or null if collinear). */
+	function conicDescFrom3(p1, p2, p3) {
+		const v1 = sub(p2, p1);
+		const v2 = sub(p3, p1);
+		const n = cross(v1, v2);
+		if (length3(n) < 1e-12) return void 0;
+		const nn = normalize3(n);
+		const b = dot(v1, v1);
+		const c = dot(v2, v2);
+		const dd = dot(v1, v2);
+		const denom = 2 * (b * c - dd * dd);
+		if (Math.abs(denom) < 1e-18) return void 0;
+		const s = c * (b - dd) / denom;
+		const t = b * (c - dd) / denom;
+		const center = add(p1, add(scaleVec(v1, s), scaleVec(v2, t)));
+		const radius = length3(sub(p1, center));
+		const x = normalize3(sub(p1, center));
+		const y = normalize3(cross(nn, x));
+		let a1 = Math.atan2(dot(sub(p3, center), y), dot(sub(p3, center), x));
+		if (a1 < 0) a1 += 2 * Math.PI;
+		return {
+			k: "conic",
+			center,
+			x,
+			y,
+			rx: radius,
+			ry: radius,
+			a0: 0,
+			a1
+		};
+	}
+	function ringOrPts(shape) {
+		const ms = asManifoldShape(shape);
+		if (ms) {
+			const params = ms.node.params;
+			return params?.ring ?? params?.pts ?? [];
+		}
+		const occt = resolveOcct();
+		return occt ? sampleOcctEdge(occt, shape) : [];
+	}
+	function inputNodes(items) {
+		const nodes = [];
+		for (const it of items) {
+			const ms = asManifoldShape(it);
+			if (ms) nodes.push(nodeOf(ms));
+		}
+		return nodes;
+	}
+	function wireFrom(items) {
+		const ring = chainEdges(items.map((e) => ringOrPts(e)));
+		return wrap(PLACEHOLDER, makeNode("profileWire", {
+			ring,
+			...ring.length >= 3 ? frameFromRing(ring) : void 0
+		}, inputNodes(items)));
+	}
+	function faceFromRing(ring, input) {
+		const { outline, origin, xAxis, yAxis } = frameFromRing(ring);
+		return wrap(PLACEHOLDER, makeNode("profileFace", {
+			outline,
+			origin,
+			xAxis,
+			yAxis
+		}, input ? [input] : []));
+	}
+	function makeFace(wire) {
+		const ms = asManifoldShape(wire);
+		if (ms) {
+			const ring = ms.node.params?.ring ?? [];
+			if (ring.length >= 3) return faceFromRing(ring, nodeOf(ms));
+		}
+		const occt = resolveOcct();
+		return faceFromRing(occt ? discretizeOcctWire(occt, wire) : [], ms ? nodeOf(ms) : void 0);
+	}
+	function addHolesInFace(face, holeWires) {
+		const fms = asManifoldShape(face);
+		const fp = (fms?.node)?.params ?? {};
+		const origin = fp.origin ?? ZERO3;
+		const xAxis = fp.xAxis ?? [
+			1,
+			0,
+			0
+		];
+		const yAxis = fp.yAxis ?? [
+			0,
+			1,
+			0
+		];
+		const project = (p) => {
+			const rel = sub(p, origin);
+			return [dot(rel, xAxis), dot(rel, yAxis)];
+		};
+		const newHoles = [];
+		for (const hw of holeWires) {
+			const hms = asManifoldShape(hw);
+			let ring;
+			if (hms) ring = hms.node.params?.ring ?? [];
+			else {
+				const occt = resolveOcct();
+				ring = occt ? discretizeOcctWire(occt, hw) : [];
+			}
+			if (ring.length >= 3) newHoles.push(ring.map(project));
+		}
+		const holes = [...fp.holes ?? [], ...newHoles];
+		const inputs = fms ? [nodeOf(fms), ...inputNodes(holeWires)] : inputNodes(holeWires);
+		return wrap(PLACEHOLDER, makeNode("profileFace", {
+			outline: fp.outline ?? [],
+			holes,
+			origin,
+			xAxis,
+			yAxis
+		}, inputs));
+	}
+	function ellipsePts(center, normal, majorRadius, minorRadius, xDir) {
+		const n = normalize3(normal);
+		const x = xDir ? normalize3(xDir) : pickPerp(n);
+		const y = normalize3(cross(n, x));
+		const pts = [];
+		for (let i = 0; i <= FULL_CIRCLE_SEGMENTS; i++) {
+			const a = 2 * Math.PI * i / FULL_CIRCLE_SEGMENTS;
+			pts.push(add(center, add(scaleVec(x, majorRadius * Math.cos(a)), scaleVec(y, minorRadius * Math.sin(a)))));
+		}
+		return pts;
+	}
+	return {
+		makeVertex: (x, y, z) => edge([[
+			x,
+			y,
+			z
+		]]),
+		makeLineEdge: (p1, p2) => edge([p1, p2], {
+			k: "line",
+			p1,
+			p2
+		}),
+		makeCircleEdge: (center, normal, radius) => {
+			const { x, y } = conicFrame(normal);
+			return edge(sampleArc(center, normal, radius, 0, 2 * Math.PI), {
+				k: "conic",
+				center,
+				x,
+				y,
+				rx: radius,
+				ry: radius,
+				a0: 0,
+				a1: 2 * Math.PI
+			});
+		},
+		makeCircleArc: (center, normal, radius, startAngle, endAngle) => {
+			const { x, y } = conicFrame(normal);
+			return edge(sampleArc(center, normal, radius, startAngle, endAngle), {
+				k: "conic",
+				center,
+				x,
+				y,
+				rx: radius,
+				ry: radius,
+				a0: startAngle,
+				a1: endAngle
+			});
+		},
+		makeArcEdge: (p1, p2, p3) => edge(circleFrom3(p1, p2, p3), conicDescFrom3(p1, p2, p3)),
+		makeEllipseEdge: (center, normal, majorRadius, minorRadius, xDir) => {
+			const { x, y } = conicFrame(normal, xDir);
+			return edge(ellipsePts(center, normal, majorRadius, minorRadius, xDir), {
+				k: "conic",
+				center,
+				x,
+				y,
+				rx: majorRadius,
+				ry: minorRadius,
+				a0: 0,
+				a1: 2 * Math.PI
+			});
+		},
+		makeBezierEdge: (points) => edge(sampleBezier(points), {
+			k: "bezier",
+			points: points.map((p) => [...p])
+		}),
+		makeTangentArc: (startPoint, _startTangent, endPoint) => edge([startPoint, endPoint], {
+			k: "line",
+			p1: startPoint,
+			p2: endPoint
+		}),
+		makeHelixWire: (pitch, height, radius, center = [
+			0,
+			0,
+			0
+		], direction = [
+			0,
+			0,
+			1
+		], leftHanded = false) => {
+			const axis = normalize3(direction);
+			const x = pickPerp(axis);
+			const y0 = normalize3(cross(axis, x));
+			const y = leftHanded ? scaleVec(y0, -1) : y0;
+			const turns = pitch !== 0 ? height / pitch : 0;
+			const desc = {
+				k: "helix",
+				center,
+				axis,
+				x,
+				y,
+				radius,
+				pitch,
+				turns
+			};
+			const segs = Math.max(8, Math.ceil(turns * FULL_CIRCLE_SEGMENTS));
+			const pts = [];
+			for (let i = 0; i <= segs; i++) pts.push(descPointAt(desc, 2 * Math.PI * turns * i / segs));
+			return edge(pts, desc);
+		},
+		makeWire: (edges) => wireFrom(edges),
+		makeWireFromMixed: (items) => wireFrom(items),
+		makeFace,
+		addHolesInFace,
+		makePolygonFace: (points) => faceFromRing(points)
+	};
+}
+//#endregion
+//#region src/kernel/manifold/builderOps.ts
+function makeBuilderOps(module) {
+	const Manifold = module.Manifold;
+	const profile = makeProfileBuilders(module);
+	function hullFromPoints(points, tolerance) {
+		const coords = points.map((p) => [
+			p.x,
+			p.y,
+			p.z
+		]);
+		return wrap(Manifold.hull(coords), makeNode("hullFromPoints", {
+			points: coords,
+			tolerance
+		}, []));
+	}
+	function hull(shapes, tolerance) {
+		const operands = shapes.map((s) => unwrap(s));
+		return wrap(Manifold.hull(operands), makeNode("hull", { tolerance }, shapes.map((s) => nodeOf(s))));
+	}
+	function sewAndSolidify(faces, tolerance) {
+		const first = faces[0];
+		if (!first) notImplemented("sewAndSolidify (no input faces on manifold kernel)");
+		return wrap(unwrap(first), makeNode("sewAndSolidify", { tolerance }, faces.map((f) => nodeOf(f))));
+	}
+	return {
+		makeVertex: (x, y, z) => profile.makeVertex(x, y, z),
+		makeEdge: () => notImplemented("makeEdge"),
+		makeWire: (edges) => profile.makeWire(edges),
+		makeFace: (wire, planar) => profile.makeFace(wire, planar),
+		makeLineEdge: (p1, p2) => profile.makeLineEdge(p1, p2),
+		makeCircleEdge: (center, normal, radius) => profile.makeCircleEdge(center, normal, radius),
+		makeCircleArc: (center, normal, radius, startAngle, endAngle) => profile.makeCircleArc(center, normal, radius, startAngle, endAngle),
+		makeArcEdge: (p1, p2, p3) => profile.makeArcEdge(p1, p2, p3),
+		makeEllipseEdge: (center, normal, majorRadius, minorRadius, xDir) => profile.makeEllipseEdge(center, normal, majorRadius, minorRadius, xDir),
+		makeEllipseArc: () => notImplemented("makeEllipseArc"),
+		makeBezierEdge: (points) => profile.makeBezierEdge(points),
+		makeTangentArc: (startPoint, startTangent, endPoint) => profile.makeTangentArc(startPoint, startTangent, endPoint),
+		makeHelixWire: (pitch, height, radius, center, direction, leftHanded) => profile.makeHelixWire(pitch, height, radius, center, direction, leftHanded),
+		makeWireFromMixed: (items) => profile.makeWireFromMixed(items),
+		makeCompound: () => notImplemented("makeCompound"),
+		solidFromShell: () => notImplemented("solidFromShell"),
+		hull,
+		hullFromPoints,
+		buildSolidFromFaces: () => notImplemented("buildSolidFromFaces"),
+		makeNonPlanarFace: () => notImplemented("makeNonPlanarFace"),
+		addHolesInFace: (face, holeWires) => profile.addHolesInFace(face, holeWires),
+		removeHolesFromFace: () => notImplemented("removeHolesFromFace"),
+		makeFaceOnSurface: () => notImplemented("makeFaceOnSurface"),
+		bsplineSurface: (points, rows, cols) => occtOrThrow("bsplineSurface").bsplineSurface(points, rows, cols),
+		triangulatedSurface: (points, rows, cols) => occtOrThrow("triangulatedSurface").triangulatedSurface(points, rows, cols),
+		buildTriFace: () => notImplemented("buildTriFace"),
+		sewAndSolidify,
+		createPoint3d: () => notImplemented("createPoint3d"),
+		createDirection3d: () => notImplemented("createDirection3d"),
+		createVector3d: () => notImplemented("createVector3d"),
+		createAxis1: () => notImplemented("createAxis1"),
+		createAxis2: () => notImplemented("createAxis2"),
+		createAxis3: () => notImplemented("createAxis3")
+	};
+}
+//#endregion
 //#region src/kernel/manifold/sweepOps.ts
 var RAD_PER_DEG = Math.PI / 180;
 function asShape$1(shape) {
@@ -10884,8 +11543,10 @@ function extrudeOp(module, face, direction, length) {
 		direction[1] * length,
 		direction[2] * length
 	]);
-	return wrap(orientExtrusion(module.Manifold.extrude([toPolygon(section)], height), section, dir), makeNode("extrude", {
+	const polygons = [toPolygon(section), ...(section.holes ?? []).map((h) => h.map((p) => [p[0], p[1]]))];
+	return wrap(orientExtrusion(orientPositive(module, module.Manifold.extrude(polygons, height)), section, dir), makeNode("extrude", {
 		outline: section.outline,
+		holes: section.holes,
 		origin: section.origin,
 		xAxis: section.xAxis,
 		yAxis: section.yAxis,
@@ -10903,14 +11564,59 @@ function revolveOp(module, shape, axisOrigin, axisDirection, angleRad, op, param
 	const radial = profileRadialOutline(section, axisOrigin, axisDirection);
 	return wrap(orientRevolution(module.Manifold.revolve([radial], 0, angleDeg), axisOrigin, axisDirection), makeNode(op, params, [nodeOf(asShape$1(shape))]));
 }
+/**
+* Rotate `ring`'s point order to the cyclic offset that best lines up with
+* `ref` (minimizes Σ‖ring[(j+off)%n] − ref[j]‖²). Both rings must share a
+* vertex count. Keeps loft correspondence from twisting between dissimilar
+* sections.
+*/
+function alignRing(ring, ref) {
+	const n = ring.length;
+	if (n === 0 || ref.length !== n) return ring;
+	let bestOff = 0;
+	let bestCost = Infinity;
+	for (let off = 0; off < n; off++) {
+		let cost = 0;
+		for (let j = 0; j < n && cost < bestCost; j++) {
+			const a = ring[(j + off) % n] ?? [
+				0,
+				0,
+				0
+			];
+			const b = ref[j] ?? [
+				0,
+				0,
+				0
+			];
+			const dx = a[0] - b[0];
+			const dy = a[1] - b[1];
+			const dz = a[2] - b[2];
+			cost += dx * dx + dy * dy + dz * dz;
+		}
+		if (cost < bestCost) {
+			bestCost = cost;
+			bestOff = off;
+		}
+	}
+	if (bestOff === 0) return ring;
+	const out = [];
+	for (let j = 0; j < n; j++) out.push(ring[(j + bestOff) % n] ?? [
+		0,
+		0,
+		0
+	]);
+	return out;
+}
 function loftOp(module, wires, op, extraParams) {
 	if (wires.length < 2) throw new Error("manifold: loft requires at least two profiles");
 	const sections = wires.map(profileCrossSection);
-	const m = sections[0]?.outline.length ?? 0;
-	return wrap(skinRings(module, sections.map((s) => {
-		if (s.outline.length !== m) throw new Error("manifold: loft profiles must share a vertex count for mesh skinning");
-		return placeRing(s, sectionFrame(s));
-	})), makeNode(op, {
+	const target = sections.reduce((mx, s) => Math.max(mx, s.outline.length), 0);
+	const rings = sections.map((s) => placeRing({
+		...s,
+		outline: resampleClosed(s.outline, target)
+	}, sectionFrame(s)));
+	for (let i = 1; i < rings.length; i++) rings[i] = alignRing(rings[i] ?? [], rings[i - 1] ?? []);
+	return wrap(skinRings(module, rings), makeNode(op, {
 		sections: sections.map(serializeSection),
 		...extraParams
 	}, wires.map((w) => nodeOf(asShape$1(w)))));
@@ -11058,7 +11764,7 @@ function makeSweepOps(module) {
 			endFactor
 		}),
 		loftBatch: () => notImplemented("loftBatch"),
-		extrudeBatch: () => notImplemented("extrudeBatch")
+		extrudeBatch: (entries) => entries.map((e) => extrudeOp(module, e.face, e.direction, e.length))
 	};
 }
 //#endregion
@@ -11194,10 +11900,55 @@ function chamferDistAngle(module, shape, edges, distance, angleDeg) {
 		selection
 	}, [nodeOf(input)]));
 }
+/**
+* Hollow an extrude-origin solid with an open top — the gridfinity bin-body case
+* (and what `approxShellMesh` cannot do: manifold-3d exposes no Minkowski inward
+* offset, so the generic shell no-ops and leaves the body solid). Reconstruct the
+* cavity from the extrude op-node's recorded outline: offset it inward by
+* `thickness` (Clipper2 2D), extrude full height so it punches through the top
+* (open), lifted by `thickness` along the extrude dir so a floor remains, then
+* subtract. Returns undefined for non-extrude solids (caller falls back).
+*/
+function extrudeOpenTopShell(module, input, thickness) {
+	const node = input.node;
+	if (node?.op !== "extrude") return void 0;
+	const p = node.params ?? {};
+	const outline = p["outline"];
+	const origin = p["origin"];
+	const dir = p["direction"];
+	const length = p["length"];
+	if (!outline || outline.length < 3 || !origin || !dir || typeof length !== "number") return;
+	const t = Math.abs(thickness);
+	try {
+		const inner = new module.CrossSection([outline.map((q) => [q[0], q[1]])]).offset(-t);
+		if (typeof inner.isEmpty === "function" && inner.isEmpty()) return void 0;
+		const cavity = module.Manifold.extrude(inner, length);
+		const dlen = Math.hypot(dir[0], dir[1], dir[2]) || 1;
+		const alignedZ = Math.abs(dir[0]) < 1e-9 && Math.abs(dir[1]) < 1e-9 && dir[2] > 0;
+		let placed = cavity;
+		if (!alignedZ) {
+			const pitch = Math.atan2(Math.hypot(dir[0], dir[1]), dir[2]) * (180 / Math.PI);
+			const yaw = Math.atan2(dir[1], dir[0]) * (180 / Math.PI);
+			placed = placed.rotate([
+				0,
+				pitch,
+				yaw
+			]);
+		}
+		placed = placed.translate([
+			origin[0] + dir[0] / dlen * t,
+			origin[1] + dir[1] / dlen * t,
+			origin[2] + dir[2] / dlen * t
+		]);
+		return orientPositive(module, unwrap(input).subtract(placed));
+	} catch {
+		return;
+	}
+}
 function shell(module, shape, faces, thickness, tolerance) {
 	const input = asShape(shape);
 	const selection = describeSelection(faces);
-	return wrap(approxShellMesh(module, unwrap(input), thickness, false), makeNode("shell", tolerance === void 0 ? {
+	return wrap(extrudeOpenTopShell(module, input, thickness) ?? approxShellMesh(module, unwrap(input), thickness, false), makeNode("shell", tolerance === void 0 ? {
 		thickness,
 		selection
 	} : {
@@ -11642,6 +12393,53 @@ var HANDLERS = {
 		if (typeof t.gridPattern !== "function") throw new Error("manifold replay: target kernel lacks gridPattern");
 		return t.gridPattern(input0(inputs), asVec3(p["directionX"]), asVec3(p["directionY"]), num(p["spacingX"]), num(p["spacingY"]), num(p["countX"], 1), num(p["countY"], 1));
 	},
+	profileEdge: (t, p) => {
+		const pts = p["pts"] ?? [];
+		const a = pts[0] ?? [
+			0,
+			0,
+			0
+		];
+		const b = pts.length > 1 ? pts[pts.length - 1] ?? a : [
+			a[0] + .001,
+			a[1],
+			a[2]
+		];
+		return t.makeLineEdge([
+			a[0],
+			a[1],
+			a[2]
+		], [
+			b[0],
+			b[1],
+			b[2]
+		]);
+	},
+	profileWire: (t, p) => {
+		const ring = p["ring"] ?? [];
+		const edges = [];
+		for (let i = 0; i < ring.length; i++) {
+			const a = ring[i] ?? [
+				0,
+				0,
+				0
+			];
+			const b = ring[(i + 1) % ring.length] ?? a;
+			edges.push(t.makeLineEdge([
+				a[0],
+				a[1],
+				a[2]
+			], [
+				b[0],
+				b[1],
+				b[2]
+			]));
+		}
+		const wire = t.makeWire(edges);
+		for (const e of edges) t.dispose(e);
+		return wire;
+	},
+	profileFace: (t, p) => faceFromOutline(t, p),
 	extrude: (t, p) => {
 		const face = faceFromOutline(t, p);
 		return t.extrude(face, asVec3(p["direction"], [
@@ -11821,7 +12619,62 @@ function replay(node, targetKernel, cache = /* @__PURE__ */ new Map()) {
 function solidOf(shape) {
 	return unwrap(shape);
 }
+/** World points recorded on a profile placeholder node (edge/wire/face/vertex). */
+function profileWorldPoints(shape) {
+	const p = (shape?.node)?.params;
+	if (!p) return void 0;
+	const pts = p["pts"] ?? p["ring"];
+	if (pts && pts.length) return pts;
+	const outline = p["outline"];
+	if (outline && outline.length) {
+		const o = p["origin"] ?? [
+			0,
+			0,
+			0
+		];
+		const x = p["xAxis"] ?? [
+			1,
+			0,
+			0
+		];
+		const y = p["yAxis"] ?? [
+			0,
+			1,
+			0
+		];
+		return outline.map((q) => [
+			o[0] + x[0] * q[0] + y[0] * q[1],
+			o[1] + x[1] * q[0] + y[1] * q[1],
+			o[2] + x[2] * q[0] + y[2] * q[1]
+		]);
+	}
+}
+function aabbOfPoints(pts) {
+	const min = [
+		Infinity,
+		Infinity,
+		Infinity
+	];
+	const max = [
+		-Infinity,
+		-Infinity,
+		-Infinity
+	];
+	for (const q of pts) for (let i = 0; i < 3; i++) {
+		const v = q[i] ?? 0;
+		if (v < (min[i] ?? Infinity)) min[i] = v;
+		if (v > (max[i] ?? -Infinity)) max[i] = v;
+	}
+	return {
+		min,
+		max
+	};
+}
 function boxOf(shape) {
+	const w = shape;
+	if (w && w.__manifoldSub && w.box) return w.box;
+	const pts = profileWorldPoints(shape);
+	if (pts) return aabbOfPoints(pts);
 	return solidOf(shape).boundingBox();
 }
 function meshOf$2(shape) {
@@ -11961,9 +12814,16 @@ function volume(shape) {
 	return solidOf(shape).volume();
 }
 function area(shape) {
+	const w = shape;
+	if (w && w.__nativeFace && typeof w.area === "number") return w.area;
 	return solidOf(shape).surfaceArea();
 }
 function boundingBox(shape) {
+	const w = shape;
+	if (w && w.__manifoldSub && w.box) return {
+		min: [...w.box.min],
+		max: [...w.box.max]
+	};
 	const bb = boxOf(shape);
 	return {
 		min: [...bb.min],
@@ -12034,7 +12894,13 @@ function makeMeasureOps(_module) {
 	return {
 		volume: (shape) => volume(shape),
 		area: (shape) => area(shape),
-		length: () => notImplemented("length"),
+		length: (shape) => {
+			const e = shape;
+			if (e && e.__nativeEdge && typeof e.length === "number") return e.length;
+			const node = asManifoldShape(shape)?.node;
+			if (node?.op === "profileEdge" && node.params?.curve) return descLength(node.params.curve);
+			return notImplemented("length");
+		},
 		centerOfMass: (shape) => centerOfMass(shape),
 		linearCenterOfMass: (shape) => centerOfMass(shape),
 		boundingBox: (shape) => boundingBox(shape),
@@ -12049,6 +12915,459 @@ function makeMeasureOps(_module) {
 	};
 }
 //#endregion
+//#region src/kernel/manifold/nativeFaces.ts
+/** runOriginalID for a triangle index, via the runIndex run boundaries. */
+function originOfTri(mesh, triIndex) {
+	const { runIndex, runOriginalID } = mesh;
+	if (!runIndex || !runOriginalID) return 0;
+	const vertPos = triIndex * 3;
+	for (let r = 0; r < runOriginalID.length; r++) {
+		const start = runIndex[r] ?? 0;
+		const end = runIndex[r + 1] ?? Number.MAX_SAFE_INTEGER;
+		if (vertPos >= start && vertPos < end) return runOriginalID[r] ?? 0;
+	}
+	return 0;
+}
+/**
+* Extract planar faces from a manifold solid by grouping triangles on `faceID`.
+* Returns one {@link NativeFace} per group with normal/center/area/bbox/origin.
+*/
+function extractFaces(meshUnknown) {
+	const mesh = meshUnknown;
+	const tv = mesh.triVerts;
+	const vp = mesh.vertProperties;
+	const stride = mesh.numProp || 3;
+	const faceID = mesh.faceID;
+	const triCount = tv.length / 3;
+	const pos = (vi) => {
+		const o = vi * stride;
+		return [
+			vp[o] ?? 0,
+			vp[o + 1] ?? 0,
+			vp[o + 2] ?? 0
+		];
+	};
+	const groups = /* @__PURE__ */ new Map();
+	for (let t = 0; t < triCount; t++) {
+		const id = faceID ? faceID[t] ?? t : t;
+		let g = groups.get(id);
+		if (!g) {
+			g = [];
+			groups.set(id, g);
+		}
+		g.push(t);
+	}
+	const faces = [];
+	for (const [faceId, tris] of groups) {
+		let nx = 0;
+		let ny = 0;
+		let nz = 0;
+		let cx = 0;
+		let cy = 0;
+		let cz = 0;
+		let area = 0;
+		let minX = Infinity;
+		let minY = Infinity;
+		let minZ = Infinity;
+		let maxX = -Infinity;
+		let maxY = -Infinity;
+		let maxZ = -Infinity;
+		const triData = new Float32Array(tris.length * 9);
+		let w = 0;
+		for (const t of tris) {
+			const a = pos(tv[t * 3] ?? 0);
+			const b = pos(tv[t * 3 + 1] ?? 0);
+			const c = pos(tv[t * 3 + 2] ?? 0);
+			const ux = b[0] - a[0];
+			const uy = b[1] - a[1];
+			const uz = b[2] - a[2];
+			const vx = c[0] - a[0];
+			const vy = c[1] - a[1];
+			const vz = c[2] - a[2];
+			const px = uy * vz - uz * vy;
+			const py = uz * vx - ux * vz;
+			const pz = ux * vy - uy * vx;
+			nx += px;
+			ny += py;
+			nz += pz;
+			const triArea = .5 * Math.hypot(px, py, pz);
+			area += triArea;
+			const tcx = (a[0] + b[0] + c[0]) / 3;
+			const tcy = (a[1] + b[1] + c[1]) / 3;
+			const tcz = (a[2] + b[2] + c[2]) / 3;
+			cx += triArea * tcx;
+			cy += triArea * tcy;
+			cz += triArea * tcz;
+			for (const p of [
+				a,
+				b,
+				c
+			]) {
+				if (p[0] < minX) minX = p[0];
+				if (p[1] < minY) minY = p[1];
+				if (p[2] < minZ) minZ = p[2];
+				if (p[0] > maxX) maxX = p[0];
+				if (p[1] > maxY) maxY = p[1];
+				if (p[2] > maxZ) maxZ = p[2];
+				triData[w++] = p[0];
+				triData[w++] = p[1];
+				triData[w++] = p[2];
+			}
+		}
+		const nlen = Math.hypot(nx, ny, nz) || 1;
+		const normal = [
+			nx / nlen,
+			ny / nlen,
+			nz / nlen
+		];
+		const center = area > 0 ? [
+			cx / area,
+			cy / area,
+			cz / area
+		] : [
+			0,
+			0,
+			0
+		];
+		faces.push({
+			__nativeFace: true,
+			faceId,
+			originId: originOfTri(mesh, tris[0] ?? 0),
+			normal,
+			center,
+			area,
+			min: [
+				minX,
+				minY,
+				minZ
+			],
+			max: [
+				maxX,
+				maxY,
+				maxZ
+			],
+			tris: triData
+		});
+	}
+	return faces;
+}
+function isNativeFace(shape) {
+	return !!shape && typeof shape === "object" && shape.__nativeFace === true;
+}
+//#endregion
+//#region src/kernel/manifold/nativeEdges.ts
+var CREASE_COS = Math.cos(45 * Math.PI / 180);
+var edgeKey = (a, b) => a < b ? a * 1e9 + b : b * 1e9 + a;
+var pairKey = (a, b) => a < b ? `${a},${b}` : `${b},${a}`;
+/**
+* Extract feature edges (face-pair boundaries) from a manifold solid's mesh.
+*/
+function extractEdges(meshUnknown) {
+	const mesh = meshUnknown;
+	const tv = mesh.triVerts;
+	const vp = mesh.vertProperties;
+	const stride = mesh.numProp || 3;
+	const faceID = mesh.faceID;
+	const triCount = tv.length / 3;
+	if (!faceID) return [];
+	const pos = (vi) => {
+		const o = vi * stride;
+		return [
+			vp[o] ?? 0,
+			vp[o + 1] ?? 0,
+			vp[o + 2] ?? 0
+		];
+	};
+	const triNormal = (t) => {
+		const a = pos(tv[t * 3] ?? 0);
+		const b = pos(tv[t * 3 + 1] ?? 0);
+		const c = pos(tv[t * 3 + 2] ?? 0);
+		const ux = b[0] - a[0];
+		const uy = b[1] - a[1];
+		const uz = b[2] - a[2];
+		const vx = c[0] - a[0];
+		const vy = c[1] - a[1];
+		const vz = c[2] - a[2];
+		const nx = uy * vz - uz * vy;
+		const ny = uz * vx - ux * vz;
+		const nz = ux * vy - uy * vx;
+		const l = Math.hypot(nx, ny, nz) || 1;
+		return [
+			nx / l,
+			ny / l,
+			nz / l
+		];
+	};
+	const edgeFaces = /* @__PURE__ */ new Map();
+	for (let t = 0; t < triCount; t++) {
+		const a = tv[t * 3] ?? 0;
+		const b = tv[t * 3 + 1] ?? 0;
+		const c = tv[t * 3 + 2] ?? 0;
+		const fid = faceID[t] ?? t;
+		const n = triNormal(t);
+		for (const [u, w] of [
+			[a, b],
+			[b, c],
+			[c, a]
+		]) {
+			const k = edgeKey(u, w);
+			let e = edgeFaces.get(k);
+			if (!e) {
+				e = {
+					v: [u, w],
+					faces: [],
+					nrm: []
+				};
+				edgeFaces.set(k, e);
+			}
+			e.faces.push(fid);
+			e.nrm.push(n);
+		}
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const { v, faces, nrm } of edgeFaces.values()) {
+		if (faces.length !== 2) continue;
+		const [f0, f1] = faces;
+		if (f0 === f1) continue;
+		const [n0, n1] = nrm;
+		if (n0[0] * n1[0] + n0[1] * n1[1] + n0[2] * n1[2] > CREASE_COS) continue;
+		const key = pairKey(f0, f1);
+		let g = groups.get(key);
+		if (!g) {
+			g = {
+				faces: f0 < f1 ? [f0, f1] : [f1, f0],
+				segs: []
+			};
+			groups.set(key, g);
+		}
+		g.segs.push(v);
+	}
+	const edges = [];
+	for (const { faces, segs } of groups.values()) for (const chain of chainSegments(segs)) edges.push(buildEdge(faces, chain, pos));
+	return edges;
+}
+/** Order a bag of undirected vertex-pair segments into one or more vertex chains. */
+function chainSegments(segs) {
+	const adj = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	const addAdj = (v, i) => {
+		let list = adj.get(v);
+		if (!list) {
+			list = [];
+			adj.set(v, list);
+		}
+		list.push(i);
+	};
+	segs.forEach(([a, b], i) => {
+		addAdj(a, i);
+		addAdj(b, i);
+	});
+	const otherEnd = (i, v) => {
+		const s = segs[i] ?? [v, v];
+		return s[0] === v ? s[1] : s[0];
+	};
+	const chains = [];
+	for (let start = 0; start < segs.length; start++) {
+		if (used.has(start)) continue;
+		used.add(start);
+		const s = segs[start] ?? [0, 0];
+		const chain = [s[0], s[1]];
+		for (let guard = 0; guard < segs.length; guard++) {
+			const tail = chain[chain.length - 1] ?? 0;
+			const next = (adj.get(tail) ?? []).find((i) => !used.has(i));
+			if (next === void 0) break;
+			used.add(next);
+			chain.push(otherEnd(next, tail));
+		}
+		for (let guard = 0; guard < segs.length; guard++) {
+			const head = chain[0] ?? 0;
+			const prev = (adj.get(head) ?? []).find((i) => !used.has(i));
+			if (prev === void 0) break;
+			used.add(prev);
+			chain.unshift(otherEnd(prev, head));
+		}
+		chains.push(chain);
+	}
+	return chains;
+}
+function buildEdge(faces, chain, pos) {
+	const n = chain.length;
+	const pts = new Float32Array(n * 3);
+	const arc = new Float32Array(n);
+	let minX = Infinity;
+	let minY = Infinity;
+	let minZ = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	let maxZ = -Infinity;
+	let len = 0;
+	let prev = null;
+	for (let i = 0; i < n; i++) {
+		const p = pos(chain[i] ?? 0);
+		pts[i * 3] = p[0];
+		pts[i * 3 + 1] = p[1];
+		pts[i * 3 + 2] = p[2];
+		if (prev) len += Math.hypot(p[0] - prev[0], p[1] - prev[1], p[2] - prev[2]);
+		arc[i] = len;
+		prev = p;
+		if (p[0] < minX) minX = p[0];
+		if (p[1] < minY) minY = p[1];
+		if (p[2] < minZ) minZ = p[2];
+		if (p[0] > maxX) maxX = p[0];
+		if (p[1] > maxY) maxY = p[1];
+		if (p[2] > maxZ) maxZ = p[2];
+	}
+	return {
+		__nativeEdge: true,
+		faces,
+		pts,
+		arc,
+		length: len,
+		min: [
+			minX,
+			minY,
+			minZ
+		],
+		max: [
+			maxX,
+			maxY,
+			maxZ
+		],
+		curveType: isStraight(pts) ? "LINE" : "CIRCLE"
+	};
+}
+/** Straight if every interior point lies on the chord within a small tolerance. */
+function isStraight(pts) {
+	const n = pts.length / 3;
+	if (n <= 2) return true;
+	const ax = pts[0] ?? 0;
+	const ay = pts[1] ?? 0;
+	const az = pts[2] ?? 0;
+	const bx = pts[(n - 1) * 3] ?? 0;
+	const by = pts[(n - 1) * 3 + 1] ?? 0;
+	const bz = pts[(n - 1) * 3 + 2] ?? 0;
+	let dx = bx - ax;
+	let dy = by - ay;
+	let dz = bz - az;
+	const dl = Math.hypot(dx, dy, dz) || 1;
+	dx /= dl;
+	dy /= dl;
+	dz /= dl;
+	for (let i = 1; i < n - 1; i++) {
+		const px = (pts[i * 3] ?? 0) - ax;
+		const py = (pts[i * 3 + 1] ?? 0) - ay;
+		const pz = (pts[i * 3 + 2] ?? 0) - az;
+		const t = px * dx + py * dy + pz * dz;
+		const ex = px - t * dx;
+		const ey = py - t * dy;
+		const ez = pz - t * dz;
+		if (Math.hypot(ex, ey, ez) > 1e-6 * Math.max(1, dl)) return false;
+	}
+	return true;
+}
+/**
+* Extract B-rep vertices: mesh vertices where three or more distinct faces
+* (faceID groups) meet — i.e. the corners where edges terminate. A box yields
+* its 8 corners; interior/edge-midpoint vertices (1–2 faces) are excluded.
+*/
+function extractVertices(meshUnknown) {
+	const mesh = meshUnknown;
+	const tv = mesh.triVerts;
+	const vp = mesh.vertProperties;
+	const stride = mesh.numProp || 3;
+	const faceID = mesh.faceID;
+	if (!faceID) return [];
+	const triCount = tv.length / 3;
+	const facesAtVert = /* @__PURE__ */ new Map();
+	for (let t = 0; t < triCount; t++) {
+		const fid = faceID[t] ?? t;
+		for (let j = 0; j < 3; j++) {
+			const v = tv[t * 3 + j] ?? 0;
+			let s = facesAtVert.get(v);
+			if (!s) {
+				s = /* @__PURE__ */ new Set();
+				facesAtVert.set(v, s);
+			}
+			s.add(fid);
+		}
+	}
+	const verts = [];
+	for (const [v, faces] of facesAtVert) {
+		if (faces.size < 3) continue;
+		const o = v * stride;
+		verts.push({
+			__nativeVertex: true,
+			point: [
+				vp[o] ?? 0,
+				vp[o + 1] ?? 0,
+				vp[o + 2] ?? 0
+			]
+		});
+	}
+	return verts;
+}
+function isNativeVertex(shape) {
+	return !!shape && typeof shape === "object" && shape.__nativeVertex === true;
+}
+function isNativeEdge(shape) {
+	return !!shape && typeof shape === "object" && shape.__nativeEdge === true;
+}
+/** Point at arc-length `s` along the edge polyline. */
+function edgePointAt(edge, s) {
+	const { pts, arc } = edge;
+	const n = arc.length;
+	if (n === 0) return [
+		0,
+		0,
+		0
+	];
+	if (s <= 0) return [
+		pts[0] ?? 0,
+		pts[1] ?? 0,
+		pts[2] ?? 0
+	];
+	if (s >= edge.length) return [
+		pts[(n - 1) * 3] ?? 0,
+		pts[(n - 1) * 3 + 1] ?? 0,
+		pts[(n - 1) * 3 + 2] ?? 0
+	];
+	let i = 1;
+	while (i < n && (arc[i] ?? 0) < s) i++;
+	const a0 = arc[i - 1] ?? 0;
+	const a1 = arc[i] ?? a0;
+	const t = a1 > a0 ? (s - a0) / (a1 - a0) : 0;
+	const o0 = (i - 1) * 3;
+	const o1 = i * 3;
+	return [
+		(pts[o0] ?? 0) + ((pts[o1] ?? 0) - (pts[o0] ?? 0)) * t,
+		(pts[o0 + 1] ?? 0) + ((pts[o1 + 1] ?? 0) - (pts[o0 + 1] ?? 0)) * t,
+		(pts[o0 + 2] ?? 0) + ((pts[o1 + 2] ?? 0) - (pts[o0 + 2] ?? 0)) * t
+	];
+}
+/** Unit tangent at arc-length `s` (direction of the containing segment). */
+function edgeTangentAt(edge, s) {
+	const { pts, arc } = edge;
+	const n = arc.length;
+	if (n < 2) return [
+		1,
+		0,
+		0
+	];
+	let i = 1;
+	while (i < n - 1 && (arc[i] ?? 0) < s) i++;
+	const o0 = (i - 1) * 3;
+	const o1 = i * 3;
+	const dx = (pts[o1] ?? 0) - (pts[o0] ?? 0);
+	const dy = (pts[o1 + 1] ?? 0) - (pts[o0 + 1] ?? 0);
+	const dz = (pts[o1 + 2] ?? 0) - (pts[o0 + 2] ?? 0);
+	const l = Math.hypot(dx, dy, dz) || 1;
+	return [
+		dx / l,
+		dy / l,
+		dz / l
+	];
+}
+//#endregion
 //#region src/kernel/manifold/topologyOps.ts
 function brepOf(shape, method) {
 	const ms = asManifoldShape(shape);
@@ -12093,7 +13412,50 @@ function iterShapes(shape, type) {
 	const s = asManifoldShape(shape);
 	if (!s) return [];
 	if (type === "solid") return [shape];
+	if (type === "vertex") {
+		const solid = unwrap(s);
+		if (solid && typeof solid.getMesh === "function") return extractVertices(solid.getMesh()).map((v, index) => ({
+			...v,
+			__manifoldSub: true,
+			index,
+			box: {
+				min: v.point,
+				max: v.point
+			},
+			parent: s.node,
+			subType: "vertex"
+		}));
+		return [];
+	}
 	if (type !== "edge" && type !== "face") return [];
+	if (type === "face") {
+		const solid = unwrap(s);
+		if (solid && typeof solid.getMesh === "function") return extractFaces(solid.getMesh()).map((f, index) => ({
+			...f,
+			__manifoldSub: true,
+			index,
+			box: {
+				min: f.min,
+				max: f.max
+			},
+			parent: s.node,
+			subType: "face"
+		}));
+	}
+	if (type === "edge") {
+		const solid = unwrap(s);
+		if (solid && typeof solid.getMesh === "function") return extractEdges(solid.getMesh()).map((e, index) => ({
+			...e,
+			__manifoldSub: true,
+			index,
+			box: {
+				min: e.min,
+				max: e.max
+			},
+			parent: s.node,
+			subType: "edge"
+		}));
+	}
 	if (!s.node.replayable) return [];
 	const occt = resolveOcct();
 	if (!occt) return [];
@@ -12105,7 +13467,10 @@ function iterShapes(shape, type) {
 	return occt.iterShapes(brep, type).map((sub, index) => ({
 		__manifoldSub: true,
 		index,
-		box: occt.boundingBox(sub)
+		box: occt.boundingBox(sub),
+		occt: sub,
+		parent: s.node,
+		subType: type
 	}));
 }
 function edgeToFaceMap(shape) {
@@ -12680,6 +14045,12 @@ function vertexAt(mesh, index) {
 	];
 }
 function viaOcct(shape, query) {
+	const witness = shape;
+	if (witness && witness.__manifoldSub && witness.occt) {
+		const occt = resolveOcct();
+		if (!occt) throw new Error("manifold: sub-shape geometry query requires a registered occt kernel");
+		return query(witness.occt, occt);
+	}
 	const ms = asManifoldShape(shape);
 	if (!ms) throw new Error("manifold: exact geometry query requires a manifold shape handle");
 	const occt = resolveOcct();
@@ -12692,15 +14063,56 @@ function viaOcct(shape, query) {
 	}
 	return query(occtShape, occt);
 }
+/** The analytic curve descriptor of a standalone profile edge, if it has one. */
+function descOf(shape) {
+	const ms = asManifoldShape(shape);
+	if (!ms) return void 0;
+	const node = ms.node;
+	return node.op === "profileEdge" ? node.params?.curve : void 0;
+}
 function makeGeometryOps(_module) {
 	return {
-		curveType: (shape) => viaOcct(shape, (s, occt) => occt.curveType(s)),
-		curveParameters: (shape) => viaOcct(shape, (s, occt) => occt.curveParameters(s)),
-		curvePointAtParam: (shape, param) => viaOcct(shape, (s, occt) => occt.curvePointAtParam(s, param)),
-		curveTangent: (shape, param) => viaOcct(shape, (s, occt) => occt.curveTangent(s, param)),
-		curveIsClosed: (shape) => viaOcct(shape, (s, occt) => occt.curveIsClosed(s)),
-		curveIsPeriodic: (shape) => viaOcct(shape, (s, occt) => occt.curveIsPeriodic(s)),
-		curvePeriod: (shape) => viaOcct(shape, (s, occt) => occt.curvePeriod(s)),
+		curveType: (shape) => {
+			const d = descOf(shape);
+			if (d) return descType(d);
+			return isNativeEdge(shape) ? shape.curveType : viaOcct(shape, (s, occt) => occt.curveType(s));
+		},
+		curveParameters: (shape) => {
+			const d = descOf(shape);
+			if (d) {
+				const b = descBounds(d);
+				return [b.first, b.last];
+			}
+			return isNativeEdge(shape) ? [0, shape.length] : viaOcct(shape, (s, occt) => occt.curveParameters(s));
+		},
+		curvePointAtParam: (shape, param) => {
+			const d = descOf(shape);
+			if (d) return descPointAt(d, param);
+			return isNativeEdge(shape) ? edgePointAt(shape, param) : viaOcct(shape, (s, occt) => occt.curvePointAtParam(s, param));
+		},
+		curveTangent: (shape, param) => {
+			const d = descOf(shape);
+			if (d) return {
+				point: descPointAt(d, param),
+				tangent: descTangent(d, param)
+			};
+			return isNativeEdge(shape) ? {
+				point: edgePointAt(shape, param),
+				tangent: edgeTangentAt(shape, param)
+			} : viaOcct(shape, (s, occt) => occt.curveTangent(s, param));
+		},
+		curveIsClosed: (shape) => {
+			const d = descOf(shape);
+			return d ? descIsClosed(d) : viaOcct(shape, (s, occt) => occt.curveIsClosed(s));
+		},
+		curveIsPeriodic: (shape) => {
+			const d = descOf(shape);
+			return d ? descIsPeriodic(d) : viaOcct(shape, (s, occt) => occt.curveIsPeriodic(s));
+		},
+		curvePeriod: (shape) => {
+			const d = descOf(shape);
+			return d ? descPeriod(d) : viaOcct(shape, (s, occt) => occt.curvePeriod(s));
+		},
 		interpolatePoints: (points, options) => occtOrThrow("interpolatePoints").interpolatePoints(points, options),
 		approximatePoints: (points, options) => occtOrThrow("approximatePoints").approximatePoints(points, options),
 		curveDegreeElevate: (edge, elevateBy) => viaOcct(edge, (s, occt) => occt.curveDegreeElevate(s, elevateBy)),
@@ -12711,13 +14123,24 @@ function makeGeometryOps(_module) {
 		getBezierPenultimatePole: (edge) => viaOcct(edge, (s, occt) => occt.getBezierPenultimatePole(s)),
 		getNurbsCurveData: (edge) => viaOcct(edge, (s, occt) => occt.getNurbsCurveData?.(s) ?? null),
 		vertexPosition: (vertex) => {
+			if (isNativeVertex(vertex)) return vertex.point;
 			if (!asManifoldShape(vertex)) return viaOcct(vertex, (s, occt) => occt.vertexPosition(s));
 			return vertexAt(meshOf(vertex), 0);
 		},
-		surfaceType: (face) => viaOcct(face, (s, occt) => occt.surfaceType(s)),
-		uvBounds: (face) => viaOcct(face, (s, occt) => occt.uvBounds(s)),
+		surfaceType: (face) => {
+			if (isNativeFace(face)) return "plane";
+			const ms = asManifoldShape(face);
+			if (ms && ms.node.op === "profileFace") return "plane";
+			return viaOcct(face, (s, occt) => occt.surfaceType(s));
+		},
+		uvBounds: (face) => isNativeFace(face) ? {
+			uMin: 0,
+			uMax: 1,
+			vMin: 0,
+			vMax: 1
+		} : viaOcct(face, (s, occt) => occt.uvBounds(s)),
 		outerWire: (face) => viaOcct(face, (s, occt) => occt.outerWire(s)),
-		surfaceNormal: (face, u, v) => viaOcct(face, (s, occt) => occt.surfaceNormal(s, u, v)),
+		surfaceNormal: (face, u, v) => isNativeFace(face) ? face.normal : viaOcct(face, (s, occt) => occt.surfaceNormal(s, u, v)),
 		pointOnSurface: (face, u, v) => viaOcct(face, (s, occt) => occt.pointOnSurface(s, u, v)),
 		uvFromPoint: (face, point) => viaOcct(face, (s, occt) => occt.uvFromPoint(s, point)),
 		projectPointOnFace: (face, point) => viaOcct(face, (s, occt) => occt.projectPointOnFace(s, point)),
@@ -12811,6 +14234,614 @@ function makeRepairOps(_module) {
 	};
 }
 //#endregion
+//#region src/kernel/manifold/kernel2dNative.ts
+var CHORD_TOL = .004;
+function isNative(x) {
+	return !!x && typeof x === "object" && x.__nativeC2d === true;
+}
+function line(p1, p2) {
+	return {
+		__nativeC2d: true,
+		k: "line",
+		p1,
+		p2
+	};
+}
+function conic(c, u, v, a0, a1) {
+	return {
+		__nativeC2d: true,
+		k: "conic",
+		c,
+		u,
+		v,
+		a0,
+		a1
+	};
+}
+function applyPt(m, [x, y]) {
+	return [m.a * x + m.b * y + m.tx, m.c * x + m.d * y + m.ty];
+}
+function applyVec(m, [x, y]) {
+	return [m.a * x + m.b * y, m.c * x + m.d * y];
+}
+function compose(p, q) {
+	return {
+		a: p.a * q.a + p.b * q.c,
+		b: p.a * q.b + p.b * q.d,
+		c: p.c * q.a + p.d * q.c,
+		d: p.c * q.b + p.d * q.d,
+		tx: p.a * q.tx + p.b * q.ty + p.tx,
+		ty: p.c * q.tx + p.d * q.ty + p.ty
+	};
+}
+function transform(curve, m) {
+	if (curve.k === "line") return line(applyPt(m, curve.p1), applyPt(m, curve.p2));
+	if (curve.k === "bezier") return {
+		__nativeC2d: true,
+		k: "bezier",
+		pts: curve.pts.map((p) => applyPt(m, p))
+	};
+	return conic(applyPt(m, curve.c), applyVec(m, curve.u), applyVec(m, curve.v), curve.a0, curve.a1);
+}
+function bezierAt(pts, t) {
+	const tmp = pts.map((p) => [p[0], p[1]]);
+	for (let k = 1; k < tmp.length; k++) for (let i = 0; i < tmp.length - k; i++) {
+		const a = tmp[i] ?? [0, 0];
+		const b = tmp[i + 1] ?? [0, 0];
+		tmp[i] = [a[0] * (1 - t) + b[0] * t, a[1] * (1 - t) + b[1] * t];
+	}
+	return tmp[0] ?? [0, 0];
+}
+function conicPoint(c, t) {
+	const ct = Math.cos(t);
+	const st = Math.sin(t);
+	return [c.c[0] + c.u[0] * ct + c.v[0] * st, c.c[1] + c.u[1] * ct + c.v[1] * st];
+}
+/** Bezier first derivative B'(t) = n·Σ(P_{i+1}−P_i)·b_{i,n−1}(t). */
+function bezierD1(pts, t) {
+	const n = pts.length - 1;
+	if (n < 1) return [0, 0];
+	const diff = [];
+	for (let i = 0; i < n; i++) {
+		const a = pts[i] ?? [0, 0];
+		const b = pts[i + 1] ?? [0, 0];
+		diff.push([n * (b[0] - a[0]), n * (b[1] - a[1])]);
+	}
+	return bezierAt(diff, t);
+}
+/**
+* Segment count for a conic arc, driven by chord-height tolerance rather than a
+* fixed count: the polygon's sagitta is `ρ(1 − cos(Δθ/2))`, so to keep it under
+* CHORD_TOL the per-segment angle must satisfy `Δθ ≤ 2·acos(1 − tol/ρ)`. This
+* gives tiny gridfinity corner arcs few segments (fast) while large circles get
+* enough to match OCCT's exact volume (parity). `ρ` is the larger conjugate
+* radius (ellipse worst case).
+*/
+function conicSegments(curve) {
+	const span = Math.abs(curve.a1 - curve.a0);
+	const ru = Math.hypot(curve.u[0], curve.u[1]);
+	const rv = Math.hypot(curve.v[0], curve.v[1]);
+	const rho = Math.max(ru, rv);
+	if (rho <= CHORD_TOL) return Math.max(2, Math.ceil(span / (2 * Math.PI) * 8));
+	const maxAngle = 2 * Math.acos(Math.max(-1, 1 - CHORD_TOL / rho));
+	return Math.max(2, Math.ceil(span / maxAngle));
+}
+function sample(curve) {
+	if (curve.k === "line") return [curve.p1, curve.p2];
+	if (curve.k === "bezier") {
+		const out = [];
+		for (let i = 0; i <= 24; i++) out.push(bezierAt(curve.pts, i / 24));
+		return out;
+	}
+	const span = curve.a1 - curve.a0;
+	const n = conicSegments(curve);
+	const pts = [];
+	for (let i = 0; i <= n; i++) {
+		const t = curve.a0 + span * i / n;
+		const ct = Math.cos(t);
+		const st = Math.sin(t);
+		pts.push([curve.c[0] + curve.u[0] * ct + curve.v[0] * st, curve.c[1] + curve.u[1] * ct + curve.v[1] * st]);
+	}
+	return pts;
+}
+/** Circle/arc through param helpers. */
+function circleThrough3(p1, pm, p2) {
+	const ax = p1[0];
+	const ay = p1[1];
+	const bx = pm[0];
+	const by = pm[1];
+	const cx2 = p2[0];
+	const cy2 = p2[1];
+	const d = 2 * (ax * (by - cy2) + bx * (cy2 - ay) + cx2 * (ay - by));
+	if (Math.abs(d) < 1e-12) return line(p1, p2);
+	const ux = ((ax * ax + ay * ay) * (by - cy2) + (bx * bx + by * by) * (cy2 - ay) + (cx2 * cx2 + cy2 * cy2) * (ay - by)) / d;
+	const uy = ((ax * ax + ay * ay) * (cx2 - bx) + (bx * bx + by * by) * (ax - cx2) + (cx2 * cx2 + cy2 * cy2) * (bx - ax)) / d;
+	const center = [ux, uy];
+	const r = Math.hypot(ax - ux, ay - uy);
+	const ang = (p) => Math.atan2(p[1] - uy, p[0] - ux);
+	const a0 = ang(p1);
+	const am = ang(pm);
+	let a1 = ang(p2);
+	const norm = (x) => (x % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI);
+	const dm = norm(am - a0);
+	const d1 = norm(a1 - a0);
+	if (dm <= d1) a1 = a0 + d1;
+	else a1 = a0 - norm(a0 - a1);
+	return conic(center, [r, 0], [0, r], a0, a1);
+}
+function makeNativeKernel2DOps(module, occt) {
+	const PLACEHOLDER = {
+		delete: () => {},
+		isEmpty: () => false
+	};
+	function delegate(method, ...args) {
+		const o = occt();
+		const fn = o?.[method];
+		if (!fn) throw new Error(`manifold 2D: ${method} needs an OCCT kernel (none registered)`);
+		return fn.call(o, ...args);
+	}
+	const asC = (h) => h;
+	function occtOr(method) {
+		const o = occt();
+		if (!o) throw new Error(`manifold 2D: ${method} needs an OCCT kernel (none registered)`);
+		return o;
+	}
+	/**
+	* Reconstruct a native curve descriptor as an *exact* OCCT 2D curve so it can
+	* flow into OCCT-only paths (2D booleans, intersection, NURBS). Curve type is
+	* preserved — line→line, circle→circle, arc→3-point arc, ellipse→ellipse —
+	* which keeps OCCT's shared-edge detection working in blueprint booleans.
+	* Skewed/odd cases fall back to a dense B-spline. OCCT handles pass through.
+	*/
+	function toOcct(h) {
+		if (!isNative(h)) return h;
+		const o = occtOr("toOcct");
+		const c = asC(h);
+		if (c.k === "line") return o.makeLine2d(c.p1[0], c.p1[1], c.p2[0], c.p2[1]);
+		if (c.k === "bezier") return o.makeBezier2d(c.pts);
+		const ru = Math.hypot(c.u[0], c.u[1]);
+		const rv = Math.hypot(c.v[0], c.v[1]);
+		const full = Math.abs(Math.abs(c.a1 - c.a0) - 2 * Math.PI) < 1e-9;
+		const sense = c.u[0] * c.v[1] - c.u[1] * c.v[0] >= 0;
+		if (Math.abs(ru - rv) < 1e-9 * Math.max(1, ru)) {
+			if (full) return o.makeCircle2d(c.c[0], c.c[1], ru, sense);
+			const p0 = conicPoint(c, c.a0);
+			const pm = conicPoint(c, (c.a0 + c.a1) / 2);
+			const p1 = conicPoint(c, c.a1);
+			return o.makeArc2dThreePoints(p0[0], p0[1], pm[0], pm[1], p1[0], p1[1]);
+		}
+		const dotUV = c.u[0] * c.v[0] + c.u[1] * c.v[1];
+		if (Math.abs(dotUV) < 1e-9 * Math.max(1, ru * rv)) {
+			const xdx = c.u[0] / ru;
+			const xdy = c.u[1] / ru;
+			return full ? o.makeEllipse2d(c.c[0], c.c[1], ru, rv, xdx, xdy, sense) : o.makeEllipseArc2d(c.c[0], c.c[1], ru, rv, c.a0, c.a1, xdx, xdy, sense);
+		}
+		return o.makeBSpline2d(sample(c).map((p) => [p[0], p[1]]));
+	}
+	const impl = {
+		createPoint2d: (x, y) => ({
+			x,
+			y
+		}),
+		createDirection2d: (x, y) => ({
+			x,
+			y
+		}),
+		createVector2d: (x, y) => ({
+			x,
+			y
+		}),
+		createAxis2d: (px, py, dx, dy) => ({
+			px,
+			py,
+			dx,
+			dy
+		}),
+		wrapCurve2dHandle: (h) => h,
+		createCurve2dAdaptor: (h) => h,
+		makeLine2d: (x1, y1, x2, y2) => line([x1, y1], [x2, y2]),
+		makeCircle2d: (cx, cy, r, sense = true) => conic([cx, cy], [r, 0], sense ? [0, r] : [0, -r], 0, 2 * Math.PI),
+		makeArc2dThreePoints: (x1, y1, xm, ym, x2, y2) => circleThrough3([x1, y1], [xm, ym], [x2, y2]),
+		makeArc2dTangent: (sx, sy, tx, ty, ex, ey) => {
+			const tlen = Math.hypot(tx, ty) || 1;
+			const nx = -ty / tlen;
+			const ny = tx / tlen;
+			const chord = [ex - sx, ey - sy];
+			const ndotc = nx * chord[0] + ny * chord[1];
+			if (Math.abs(ndotc) < 1e-12) return line([sx, sy], [ex, ey]);
+			const t = (chord[0] * chord[0] + chord[1] * chord[1]) / (2 * ndotc);
+			const cx = sx + nx * t;
+			const cy = sy + ny * t;
+			const r = Math.hypot(sx - cx, sy - cy);
+			const a0 = Math.atan2(sy - cy, sx - cx);
+			let a1 = Math.atan2(ey - cy, ex - cx);
+			nx * tx + ny * ty;
+			const norm = (x) => (x % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI);
+			const tangCCW = [-(sy - cy), sx - cx];
+			if (tangCCW[0] * tx + tangCCW[1] * ty >= 0) a1 = a0 + norm(a1 - a0);
+			else a1 = a0 - norm(a0 - a1);
+			return conic([cx, cy], [r, 0], [0, r], a0, a1);
+		},
+		makeEllipse2d: (cx, cy, maj, min, xdx = 1, xdy = 0, sense = true) => {
+			const xl = Math.hypot(xdx, xdy) || 1;
+			const ux = xdx / xl * maj;
+			const uy = xdy / xl * maj;
+			const vx = -xdy / xl * min * (sense ? 1 : -1);
+			const vy = xdx / xl * min * (sense ? 1 : -1);
+			return conic([cx, cy], [ux, uy], [vx, vy], 0, 2 * Math.PI);
+		},
+		makeEllipseArc2d: (cx, cy, maj, min, a0, a1, xdx = 1, xdy = 0, sense = true) => {
+			const xl = Math.hypot(xdx, xdy) || 1;
+			const ux = xdx / xl * maj;
+			const uy = xdy / xl * maj;
+			const vx = -xdy / xl * min * (sense ? 1 : -1);
+			const vy = xdx / xl * min * (sense ? 1 : -1);
+			return conic([cx, cy], [ux, uy], [vx, vy], a0, a1);
+		},
+		makeBezier2d: (points) => ({
+			__nativeC2d: true,
+			k: "bezier",
+			pts: points.map((p) => [p[0], p[1]])
+		}),
+		evaluateCurve2d: (h, param) => {
+			const c = asC(h);
+			if (c.k === "line") {
+				const dx = c.p2[0] - c.p1[0];
+				const dy = c.p2[1] - c.p1[1];
+				const len = Math.hypot(dx, dy) || 1;
+				return [c.p1[0] + dx * param / len, c.p1[1] + dy * param / len];
+			}
+			if (c.k === "bezier") return bezierAt(c.pts, param);
+			return [c.c[0] + c.u[0] * Math.cos(param) + c.v[0] * Math.sin(param), c.c[1] + c.u[1] * Math.cos(param) + c.v[1] * Math.sin(param)];
+		},
+		evaluateCurve2dD1: (h, param) => {
+			const c = asC(h);
+			if (c.k === "line") {
+				const dx = c.p2[0] - c.p1[0];
+				const dy = c.p2[1] - c.p1[1];
+				const len = Math.hypot(dx, dy) || 1;
+				return {
+					point: [c.p1[0] + dx * param / len, c.p1[1] + dy * param / len],
+					tangent: [dx / len, dy / len]
+				};
+			}
+			if (c.k === "bezier") return {
+				point: bezierAt(c.pts, param),
+				tangent: bezierD1(c.pts, param)
+			};
+			const ct = Math.cos(param);
+			const st = Math.sin(param);
+			return {
+				point: [c.c[0] + c.u[0] * ct + c.v[0] * st, c.c[1] + c.u[1] * ct + c.v[1] * st],
+				tangent: [-c.u[0] * st + c.v[0] * ct, -c.u[1] * st + c.v[1] * ct]
+			};
+		},
+		getCurve2dBounds: (h) => {
+			const c = asC(h);
+			if (c.k === "conic") return {
+				first: c.a0,
+				last: c.a1
+			};
+			if (c.k === "line") return {
+				first: 0,
+				last: Math.hypot(c.p2[0] - c.p1[0], c.p2[1] - c.p1[1])
+			};
+			return {
+				first: 0,
+				last: 1
+			};
+		},
+		getCurve2dType: (h) => {
+			const c = asC(h);
+			return c.k === "line" ? "LINE" : c.k === "bezier" ? "BEZIER" : "CIRCLE";
+		},
+		reverseCurve2d: (h) => {
+			const c = asC(h);
+			if (c.k === "line") {
+				const t = c.p1;
+				c.p1 = c.p2;
+				c.p2 = t;
+			} else if (c.k === "bezier") c.pts.reverse();
+			else {
+				const t = c.a0;
+				c.a0 = c.a1;
+				c.a1 = t;
+			}
+		},
+		copyCurve2d: (h) => structuredClone(asC(h)),
+		trimCurve2d: (h, start, end) => {
+			const c = asC(h);
+			if (c.k === "conic") return conic(c.c, c.u, c.v, start, end);
+			if (c.k === "line") {
+				const dx = c.p2[0] - c.p1[0];
+				const dy = c.p2[1] - c.p1[1];
+				const len = Math.hypot(dx, dy) || 1;
+				return line([c.p1[0] + dx * start / len, c.p1[1] + dy * start / len], [c.p1[0] + dx * end / len, c.p1[1] + dy * end / len]);
+			}
+			return structuredClone(c);
+		},
+		createIdentityGTrsf2d: () => ({
+			a: 1,
+			b: 0,
+			c: 0,
+			d: 1,
+			tx: 0,
+			ty: 0
+		}),
+		createTranslationGTrsf2d: (dx, dy) => ({
+			a: 1,
+			b: 0,
+			c: 0,
+			d: 1,
+			tx: dx,
+			ty: dy
+		}),
+		createRotationGTrsf2d: (angle, cx, cy) => {
+			const co = Math.cos(angle);
+			const si = Math.sin(angle);
+			return {
+				a: co,
+				b: -si,
+				c: si,
+				d: co,
+				tx: cx - (co * cx - si * cy),
+				ty: cy - (si * cx + co * cy)
+			};
+		},
+		createScaleGTrsf2d: (f, cx, cy) => ({
+			a: f,
+			b: 0,
+			c: 0,
+			d: f,
+			tx: cx - f * cx,
+			ty: cy - f * cy
+		}),
+		createMirrorGTrsf2d: (cx, cy, mode, ox = 0, oy = 0, dx = 1, dy = 0) => {
+			if (mode === "point") return {
+				a: -1,
+				b: 0,
+				c: 0,
+				d: -1,
+				tx: 2 * cx,
+				ty: 2 * cy
+			};
+			const l = Math.hypot(dx, dy) || 1;
+			const ux = dx / l;
+			const uy = dy / l;
+			const a = ux * ux - uy * uy;
+			const b = 2 * ux * uy;
+			return {
+				a,
+				b,
+				c: b,
+				d: -a,
+				tx: ox - (a * ox + b * oy),
+				ty: oy - (b * ox - a * oy)
+			};
+		},
+		createAffinityGTrsf2d: (ox, oy, dx, dy, ratio) => {
+			const l = Math.hypot(dx, dy) || 1;
+			const ux = dx / l;
+			const uy = dy / l;
+			const nx = -uy;
+			const ny = ux;
+			const a = ux * ux + ratio * nx * nx;
+			const b = ux * uy + ratio * nx * ny;
+			const c = uy * ux + ratio * ny * nx;
+			const d = uy * uy + ratio * ny * ny;
+			return {
+				a,
+				b,
+				c,
+				d,
+				tx: ox - (a * ox + b * oy),
+				ty: oy - (c * ox + d * oy)
+			};
+		},
+		setGTrsf2dTranslationPart: (g, dx, dy) => {
+			const m = g;
+			m.tx = dx;
+			m.ty = dy;
+		},
+		multiplyGTrsf2d: (base, other) => {
+			const r = compose(base, other);
+			Object.assign(base, r);
+		},
+		transformCurve2dGeneral: (h, g) => transform(asC(h), g),
+		translateCurve2d: (h, dx, dy) => transform(asC(h), {
+			a: 1,
+			b: 0,
+			c: 0,
+			d: 1,
+			tx: dx,
+			ty: dy
+		}),
+		rotateCurve2d: (h, angle, cx, cy) => {
+			const co = Math.cos(angle);
+			const si = Math.sin(angle);
+			return transform(asC(h), {
+				a: co,
+				b: -si,
+				c: si,
+				d: co,
+				tx: cx - (co * cx - si * cy),
+				ty: cy - (si * cx + co * cy)
+			});
+		},
+		scaleCurve2d: (h, f, cx, cy) => transform(asC(h), {
+			a: f,
+			b: 0,
+			c: 0,
+			d: f,
+			tx: cx - f * cx,
+			ty: cy - f * cy
+		}),
+		mirrorCurve2dAtPoint: (h, cx, cy) => transform(asC(h), {
+			a: -1,
+			b: 0,
+			c: 0,
+			d: -1,
+			tx: 2 * cx,
+			ty: 2 * cy
+		}),
+		mirrorCurve2dAcrossAxis: (h, ox, oy, dx, dy) => {
+			const l = Math.hypot(dx, dy) || 1;
+			const ux = dx / l;
+			const uy = dy / l;
+			const a = ux * ux - uy * uy;
+			const b = 2 * ux * uy;
+			return transform(asC(h), {
+				a,
+				b,
+				c: b,
+				d: -a,
+				tx: ox - (a * ox + b * oy),
+				ty: oy - (b * ox - a * oy)
+			});
+		},
+		affinityTransform2d: (h, ox, oy, dx, dy, ratio) => {
+			const l = Math.hypot(dx, dy) || 1;
+			const ux = dx / l;
+			const uy = dy / l;
+			const nx = -uy;
+			const ny = ux;
+			const a = ux * ux + ratio * nx * nx;
+			const b = ux * uy + ratio * nx * ny;
+			const c = uy * ux + ratio * ny * nx;
+			const d = uy * uy + ratio * ny * ny;
+			return transform(asC(h), {
+				a,
+				b,
+				c,
+				d,
+				tx: ox - (a * ox + b * oy),
+				ty: oy - (c * ox + d * oy)
+			});
+		},
+		createBoundingBox2d: () => ({
+			min: [Infinity, Infinity],
+			max: [-Infinity, -Infinity]
+		}),
+		addCurveToBBox2d: (bb, h) => {
+			const box = bb;
+			let pts;
+			if (isNative(h)) pts = sample(asC(h));
+			else {
+				const o = occtOr("addCurveToBBox2d");
+				const { first, last } = o.getCurve2dBounds(h);
+				pts = [];
+				for (let i = 0; i <= 32; i++) pts.push(o.evaluateCurve2d(h, first + (last - first) * i / 32));
+			}
+			for (const [x, y] of pts) {
+				if (x < box.min[0]) box.min[0] = x;
+				if (y < box.min[1]) box.min[1] = y;
+				if (x > box.max[0]) box.max[0] = x;
+				if (y > box.max[1]) box.max[1] = y;
+			}
+		},
+		getBBox2dBounds: (bb) => {
+			const box = bb;
+			return {
+				xMin: box.min[0],
+				yMin: box.min[1],
+				xMax: box.max[0],
+				yMax: box.max[1]
+			};
+		},
+		mergeBBox2d: (t, o) => {
+			const a = t;
+			const b = o;
+			a.min[0] = Math.min(a.min[0], b.min[0]);
+			a.min[1] = Math.min(a.min[1], b.min[1]);
+			a.max[0] = Math.max(a.max[0], b.max[0]);
+			a.max[1] = Math.max(a.max[1], b.max[1]);
+		},
+		isBBox2dOut: (a, b) => {
+			const x = a;
+			const y = b;
+			return x.max[0] < y.min[0] || x.min[0] > y.max[0] || x.max[1] < y.min[1] || x.min[1] > y.max[1];
+		},
+		isBBox2dOutPoint: (bb, x, y) => {
+			const box = bb;
+			return x < box.min[0] || x > box.max[0] || y < box.min[1] || y > box.max[1];
+		},
+		getCurve2dCircleData: (h) => {
+			const c = asC(h);
+			if (c.k !== "conic") return null;
+			const ru = Math.hypot(c.u[0], c.u[1]);
+			const rv = Math.hypot(c.v[0], c.v[1]);
+			if (Math.abs(ru - rv) > 1e-6) return null;
+			return {
+				cx: c.c[0],
+				cy: c.c[1],
+				radius: ru,
+				isDirect: true
+			};
+		},
+		liftCurve2dToPlane: (h, origin, zDir, xDir) => {
+			const zx = zDir[0];
+			const zy = zDir[1];
+			const zz = zDir[2];
+			const xx = xDir[0];
+			const xy = xDir[1];
+			const xz = xDir[2];
+			const yx = zy * xz - zz * xy;
+			const yy = zz * xx - zx * xz;
+			const yz = zx * xy - zy * xx;
+			return wrap(PLACEHOLDER, makeNode("profileEdge", { pts: sample(asC(h)).map(([u, v]) => [
+				origin[0] + xx * u + yx * v,
+				origin[1] + xy * u + yy * v,
+				origin[2] + xz * u + yz * v
+			]) }, []));
+		},
+		makeBSpline2d: (points, options) => occtOr("makeBSpline2d").makeBSpline2d(points, options),
+		offsetCurve2d: (c, offset) => occtOr("offsetCurve2d").offsetCurve2d(toOcct(c), offset),
+		intersectCurves2d: (c1, c2, tol) => occtOr("intersectCurves2d").intersectCurves2d(toOcct(c1), toOcct(c2), tol),
+		projectPointOnCurve2d: (c, x, y) => occtOr("projectPointOnCurve2d").projectPointOnCurve2d(toOcct(c), x, y),
+		distanceBetweenCurves2d: (c1, c2, s1, e1, s2, e2) => occtOr("distanceBetweenCurves2d").distanceBetweenCurves2d(toOcct(c1), toOcct(c2), s1, e1, s2, e2),
+		approximateCurve2dAsBSpline: (c, tol, cont, maxSeg) => occtOr("approximateCurve2dAsBSpline").approximateCurve2dAsBSpline(toOcct(c), tol, cont, maxSeg),
+		decomposeBSpline2dToBeziers: (c) => occtOr("decomposeBSpline2dToBeziers").decomposeBSpline2dToBeziers(toOcct(c)),
+		serializeCurve2d: (c) => occtOr("serializeCurve2d").serializeCurve2d(toOcct(c)),
+		deserializeCurve2d: (data) => occtOr("deserializeCurve2d").deserializeCurve2d(data),
+		splitCurve2d: (c, params) => occtOr("splitCurve2d").splitCurve2d(toOcct(c), params),
+		getCurve2dEllipseData: (c) => occtOr("getCurve2dEllipseData").getCurve2dEllipseData(toOcct(c)),
+		getCurve2dBezierPoles: (c) => occtOr("getCurve2dBezierPoles").getCurve2dBezierPoles(toOcct(c)),
+		getCurve2dBezierDegree: (c) => occtOr("getCurve2dBezierDegree").getCurve2dBezierDegree(toOcct(c)),
+		getCurve2dBSplineData: (c) => occtOr("getCurve2dBSplineData").getCurve2dBSplineData(toOcct(c)),
+		buildEdgeOnSurface: (c, surface) => occtOr("buildEdgeOnSurface").buildEdgeOnSurface(toOcct(c), surface),
+		extractSurfaceFromFace: (face) => occtOr("extractSurfaceFromFace").extractSurfaceFromFace(face),
+		extractCurve2dFromEdge: (edge, face) => occtOr("extractCurve2dFromEdge").extractCurve2dFromEdge(edge, face),
+		buildCurves3d: (wire) => {
+			occtOr("buildCurves3d").buildCurves3d(wire);
+		},
+		fixWireOnFace: (wire, face, tol) => occtOr("fixWireOnFace").fixWireOnFace(wire, face, tol),
+		fillSurface: (wires, opts) => occtOr("fillSurface").fillSurface(wires, opts)
+	};
+	for (const m of [
+		"evaluateCurve2d",
+		"evaluateCurve2dD1",
+		"getCurve2dBounds",
+		"getCurve2dType",
+		"reverseCurve2d",
+		"copyCurve2d",
+		"trimCurve2d",
+		"transformCurve2dGeneral",
+		"translateCurve2d",
+		"rotateCurve2d",
+		"scaleCurve2d",
+		"mirrorCurve2dAtPoint",
+		"mirrorCurve2dAcrossAxis",
+		"affinityTransform2d",
+		"getCurve2dCircleData",
+		"liftCurve2dToPlane"
+	]) {
+		const nativeFn = impl[m];
+		if (!nativeFn) continue;
+		impl[m] = ((h, ...rest) => isNative(h) ? nativeFn(h, ...rest) : delegate(m, h, ...rest));
+	}
+	return impl;
+}
+//#endregion
 //#region src/kernel/manifold/kernel2dOps.ts
 var KERNEL_2D_METHODS = [
 	"createPoint2d",
@@ -12882,9 +14913,11 @@ function resolveOcct2D(method) {
 	if (!occt) throw new Error(`manifold: ${method} unsupported on manifold kernel; no B-rep kernel registered`);
 	return occt;
 }
-function makeKernel2DOps(_module) {
+function makeKernel2DOps(module) {
 	const ops = {};
 	for (const method of KERNEL_2D_METHODS) ops[method] = (...args) => resolveOcct2D(method)[method](...args);
+	const native = makeNativeKernel2DOps(module, () => resolveOcct());
+	Object.assign(ops, native);
 	return ops;
 }
 //#endregion