brepjs 20.12.7 → 20.12.9

package/dist/{occtWasmAdapter-DA7oMgcQ.js → occtWasmAdapter-EM3EhKwk.js}

@@ -2299,16 +2299,56 @@ function multiplyMatrices4x4(a, b) {
 	for (let i = 0; i < 4; i++) for (let j = 0; j < 4; j++) for (let k = 0; k < 4; k++) result[i * 4 + j] = result[i * 4 + j] + a[i * 4 + k] * b[k * 4 + j];
 	return result;
 }
+function resolveEdgeValues(edges, value) {
+	const first = [];
+	const second = [];
+	for (const edge of edges) {
+		const v = typeof value === "function" ? value(edge) : value;
+		first.push(typeof v === "number" ? v : v[0]);
+		second.push(typeof v === "number" ? v : v[1]);
+	}
+	return {
+		first,
+		second
+	};
+}
+/** The value every edge takes on both sides, or `undefined` when they differ. */
+function uniformEdgeValue({ first, second }) {
+	const [value] = first;
+	if (value === void 0) return void 0;
+	return first.every((v) => v === value) && second.every((v) => v === value) ? value : void 0;
+}
 /**
-* Resolve a callback-style radius/distance to a uniform number.
-* occt-wasm's fillet/chamfer take a single radius — uniform per call.
+* Run a fillet or chamfer over `edges`, naming the edges it fails on. Edges
+* that all take one value go to `uniform`, the single-value entry point every
+* occt-wasm build has; otherwise `perEdge` gets each edge's pair as `first`
+* and `second`.
 */
-function resolveUniformRadius(edges, radius) {
-	if (typeof radius === "number") return radius;
-	if (Array.isArray(radius)) return radius[0];
-	if (edges.length === 0) throw new Error("occt-wasm: no edges provided");
-	const val = radius(edges[0]);
-	return typeof val === "number" ? val : val[0];
+function runEdgeTreatment(Module, edges, value, uniform, perEdge) {
+	const values = resolveEdgeValues(edges, value);
+	const shared = uniformEdgeValue(values);
+	const edgeVec = makeVecU32(Module, edges.map(unwrap));
+	try {
+		if (shared !== void 0) return reportingFaultyEdges(edges, () => uniform(edgeVec, shared));
+		const first = makeVecDouble(Module, values.first);
+		const second = makeVecDouble(Module, values.second);
+		try {
+			return reportingFaultyEdges(edges, () => perEdge(edgeVec, first, second));
+		} finally {
+			first.delete();
+			second.delete();
+		}
+	} finally {
+		edgeVec.delete();
+	}
+}
+/** Each face's draft angle, in radians. */
+function draftAnglesRad(faces, angleDeg) {
+	return faces.map((face) => (typeof angleDeg === "function" ? angleDeg(face) : angleDeg) * Math.PI / 180);
+}
+/** The peer range still admits older builds, which lack the per-edge and unit entry points. */
+function needsOcctWasm59(what) {
+	return new UnsupportedKernelOperationError(`occt-wasm: ${what} requires occt-wasm >= 5.9.0`);
 }
 /**
 * Rotate a shape from the kernel's default Z-axis to an arbitrary direction.
@@ -3754,29 +3794,42 @@ function surfaceCurvature(k, face, u, v) {
 // src/kernel/occtWasm/modifierOps.ts
 var HASH_UPPER_BOUND = 2147483647;
 function fillet(k, Module, shape, edges, radius) {
-	const r = resolveUniformRadius(edges, radius);
-	const vec = makeVecU32(Module, edges.map(unwrap));
-	try {
-		return wrapResult(k, reportingFaultyEdges(edges, () => k.fillet(unwrap(shape), vec, r)));
-	} finally {
-		vec.delete();
-	}
+	const id = unwrap(shape);
+	return wrapResult(k, runEdgeTreatment(Module, edges, radius, (edgeVec, r) => k.fillet(id, edgeVec, r), (edgeVec, startRadii, endRadii) => {
+		if (!k.filletRadii) throw needsOcctWasm59("per-edge or tapered fillet radii");
+		return k.filletRadii(id, edgeVec, startRadii, endRadii);
+	}));
 }
 function chamfer(k, Module, shape, edges, distance) {
-	const d = resolveUniformRadius(edges, distance);
-	const vec = makeVecU32(Module, edges.map(unwrap));
+	const id = unwrap(shape);
+	const faceVec = makeVecU32(Module, []);
 	try {
-		return wrapResult(k, reportingFaultyEdges(edges, () => k.chamfer(unwrap(shape), vec, d)));
+		return wrapResult(k, runEdgeTreatment(Module, edges, distance, (edgeVec, d) => k.chamfer(id, edgeVec, d), (edgeVec, distances1, distances2) => {
+			if (!k.chamferDistances) throw needsOcctWasm59("per-edge or asymmetric chamfer distances");
+			return k.chamferDistances(id, edgeVec, distances1, distances2, faceVec);
+		}));
 	} finally {
-		vec.delete();
+		faceVec.delete();
 	}
 }
 function chamferDistAngle(k, Module, shape, edges, distance, angleDeg) {
-	const vec = makeVecU32(Module, edges.map(unwrap));
+	const id = unwrap(shape);
+	const edgeVec = makeVecU32(Module, edges.map(unwrap));
 	try {
-		return wrapResult(k, k.chamferDistAngle(unwrap(shape), vec, distance, angleDeg));
+		if (!k.chamferDistAngles) return wrapResult(k, k.chamferDistAngle(id, edgeVec, distance, angleDeg));
+		const chamferDistAngles = k.chamferDistAngles.bind(k);
+		const distanceVec = makeVecDouble(Module, Array(edges.length).fill(distance));
+		const angleVec = makeVecDouble(Module, Array(edges.length).fill(angleDeg));
+		const faceVec = makeVecU32(Module, []);
+		try {
+			return wrapResult(k, reportingFaultyEdges(edges, () => chamferDistAngles(id, edgeVec, distanceVec, angleVec, faceVec)));
+		} finally {
+			distanceVec.delete();
+			angleVec.delete();
+			faceVec.delete();
+		}
 	} finally {
-		vec.delete();
+		edgeVec.delete();
 	}
 }
 function shell(k, Module, shape, faces, thickness, tolerance) {
@@ -3858,13 +3911,30 @@ function filletVariable(k, shape, spec) {
 	}
 	throw new UnsupportedKernelOperationError("occt-wasm: filletVariable: unrecognized spec");
 }
-function draft(k, shape, faces, pullDirection, _neutralPlane, angleDeg) {
-	let currentId = unwrap(shape);
-	for (const face of faces) {
-		const angleRad = (typeof angleDeg === "function" ? angleDeg(face) : angleDeg) * Math.PI / 180;
-		currentId = k.draft(currentId, unwrap(face), angleRad, pullDirection[0], pullDirection[1], pullDirection[2]);
+/**
+* Before 5.9 occt-wasm drafts one face per call about the XY plane through the
+* origin. That is the caller's plane (through `neutralPlane`, normal to the
+* pull) only for a pull along Z and a point at z = 0.
+*/
+function legacyDraft(k, shape, faces, pullDirection, neutralPlane, anglesRad) {
+	const [face] = faces;
+	const [angle] = anglesRad;
+	const [dx, dy, dz] = pullDirection;
+	if (!(faces.length === 1 && dx === 0 && dy === 0 && neutralPlane[2] === 0) || face === void 0 || angle === void 0) throw needsOcctWasm59("drafting several faces, or about a neutral plane off z = 0,");
+	return wrapResult(k, k.draft(unwrap(shape), unwrap(face), angle, dx, dy, dz));
+}
+/** Draft every face in one operation about the plane through `neutralPlane` normal to the pull. */
+function draft(k, Module, shape, faces, pullDirection, neutralPlane, angleDeg) {
+	const anglesRad = draftAnglesRad(faces, angleDeg);
+	if (!k.draftFaces) return legacyDraft(k, shape, faces, pullDirection, neutralPlane, anglesRad);
+	const faceVec = makeVecU32(Module, faces.map(unwrap));
+	const angleVec = makeVecDouble(Module, anglesRad);
+	try {
+		return wrapResult(k, k.draftFaces(unwrap(shape), faceVec, angleVec, ...pullDirection, ...neutralPlane, ...pullDirection));
+	} finally {
+		faceVec.delete();
+		angleVec.delete();
 	}
-	return wrapResult(k, currentId);
 }
 function defeature(k, Module, shape, faces) {
 	const vec = makeVecU32(Module, faces.map(unwrap));
@@ -4480,10 +4550,85 @@ function buildGltfManifest(vCount, nCount, iCount, posBytes, nrmBytes, idxBytes,
 		]
 	};
 }
+var MM_PER_UNIT = {
+	mm: 1,
+	millimeter: 1,
+	millimetre: 1,
+	cm: 10,
+	centimeter: 10,
+	centimetre: 10,
+	m: 1e3,
+	meter: 1e3,
+	metre: 1e3,
+	km: 1e6,
+	kilometer: 1e6,
+	kilometre: 1e6,
+	in: 25.4,
+	inch: 25.4,
+	ft: 304.8,
+	foot: 304.8,
+	feet: 304.8,
+	mi: 1609344,
+	mile: 1609344,
+	mil: .0254,
+	thou: .0254,
+	um: .001,
+	micron: .001,
+	micrometer: .001,
+	micrometre: .001,
+	uin: 254e-7,
+	microinch: 254e-7
+};
+function mmPerUnit(unit) {
+	const mm = MM_PER_UNIT[unit.toLowerCase()];
+	if (mm === void 0) throw new Error(`occt-wasm: unknown STEP length unit '${unit}'`);
+	return mm;
+}
+/**
+* brepjs writes lengths in `unit` and reads the shapes as `modelUnit`, which
+* defaults to `unit` (so `unit` alone relabels and does not scale). occt-wasm
+* reads shapes as millimeters and scales them into the unit written, so a
+* model in another unit is scaled to millimeters first.
+*/
+function resolveStepUnits(options) {
+	const write = options?.unit ?? options?.modelUnit ?? "mm";
+	return {
+		write,
+		modelScale: mmPerUnit(options?.modelUnit ?? write)
+	};
+}
+/**
+* The writer for `units`: the 5.9 unit-aware one, else the millimeter-only
+* one when the file is in millimeters anyway.
+*/
+function stepWriter(withUnit, inMillimeters, units) {
+	if (withUnit) return (id) => withUnit(id, units.write);
+	if (mmPerUnit(units.write) === 1) return inMillimeters;
+	throw needsOcctWasm59(`STEP export in '${units.write}'`);
+}
+/** Run `use` on `id` scaled by `factor` about the origin, releasing the scaled copy. */
+function withScaled(k, id, factor, use) {
+	if (factor === 1) return use(id);
+	const scaled = k.scale(id, 0, 0, 0, factor);
+	try {
+		return use(scaled);
+	} finally {
+		k.release(scaled);
+	}
+}
+/** One STEP file holding every shape (as a compound when there are several). */
+function writeStepShapes(k, makeCompound, shapes, units) {
+	const write = stepWriter(k.exportStepWithUnit?.bind(k), (id) => k.exportStep(id), units);
+	if (shapes.length === 1) return withScaled(k, unwrap(shapes[0]), units.modelScale, write);
+	const compoundId = unwrap(makeCompound(shapes));
+	try {
+		return withScaled(k, compoundId, units.modelScale, write);
+	} finally {
+		k.release(compoundId);
+	}
+}
 function exportSTEP(k, makeCompound, shapes) {
-	if (shapes.length === 1) return k.exportStep(unwrap(shapes[0]));
-	const compound = makeCompound(shapes);
-	return k.exportStep(unwrap(compound));
+	return writeStepShapes(k, makeCompound, shapes, resolveStepUnits(void 0));
 }
 function exportSTL(mesh, shape, binary, tolerance = DEFAULT_STL_TOLERANCE, angularTolerance = DEFAULT_STL_ANGULAR_TOLERANCE) {
 	const { vertices, triangles } = mesh(shape, {
@@ -4508,22 +4653,19 @@ function importSTL(k, Module, data) {
 	return wrapResult(k, k.importStl(""));
 }
 function exportIGES(k, makeCompound, shapes) {
-	if (shapes.length === 1) return k.exportIges(unwrap(shapes[0]));
-	const compound = makeCompound(shapes);
-	return k.exportIges(unwrap(compound));
+	const exportIges = k.exportIges?.bind(k);
+	if (!exportIges) throw new UnsupportedKernelOperationError("occt-wasm: exportIGES is unsupported");
+	if (shapes.length === 1) return exportIges(unwrap(shapes[0]));
+	return exportIges(unwrap(makeCompound(shapes)));
 }
 function importIGES(k, data) {
-	const str = typeof data === "string" ? data : new TextDecoder().decode(data);
-	return [wrapResult(k, k.importIges(str))];
+	const importIges = k.importIges?.bind(k);
+	if (!importIges) throw new UnsupportedKernelOperationError("occt-wasm: importIGES is unsupported");
+	return [wrapResult(k, importIges(typeof data === "string" ? data : new TextDecoder().decode(data)))];
 }
-function exportSTEPAssembly(k, Module, parts, _options) {
+function exportSTEPAssembly(k, parts, options) {
 	if (parts.length === 0) return "";
-	const doc = createXCAFDocument(k, Module, parts);
-	try {
-		return writeXCAFToSTEP(k, doc);
-	} finally {
-		doc.delete();
-	}
+	return writeXcafParts(k, parts, resolveStepUnits(options));
 }
 function exportGLB(mesh, shape, tolerance) {
 	const result = mesh(shape, {
@@ -4651,9 +4793,9 @@ function toBREP(k, shape) {
 function fromBREP(k, data) {
 	return wrapResult(k, k.fromBREP(data));
 }
-function createXCAFDocument(k, _Module, shapes) {
+function addXcafParts(k, parts) {
 	const docId = k.xcafNewDocument();
-	for (const entry of shapes) {
+	for (const entry of parts) {
 		const labelId = k.xcafAddShape(docId, unwrap(entry.shape));
 		if (entry.name) k.xcafSetName(docId, labelId, entry.name);
 		if (entry.color) {
@@ -4661,37 +4803,94 @@ function createXCAFDocument(k, _Module, shapes) {
 			k.xcafSetColor(docId, labelId, r / 255, g / 255, b / 255);
 		}
 	}
-	return handle("compound", docId);
+	return docId;
 }
-function writeXCAFToSTEP(k, doc, _options) {
-	const docId = unwrap(doc);
+function writeXcafDoc(k, docId, units) {
 	const roots = k.xcafGetRootLabels(docId);
-	const hasShapes = (() => {
+	try {
+		if (roots.size() === 0) return "";
+	} finally {
+		roots.delete();
+	}
+	return stepWriter(k.xcafExportSTEPWithUnit?.bind(k), (id) => k.xcafExportSTEP(id), units)(docId);
+}
+/** Write `parts` as one XCAF STEP file, scaling each into millimeters first if needed. */
+function writeXcafParts(k, parts, units) {
+	const scaled = [];
+	try {
+		const docId = addXcafParts(k, parts.map((part) => {
+			if (units.modelScale === 1) return part;
+			const id = k.scale(unwrap(part.shape), 0, 0, 0, units.modelScale);
+			scaled.push(id);
+			return {
+				...part,
+				shape: id
+			};
+		}));
 		try {
-			return roots.size() > 0;
+			return writeXcafDoc(k, docId, units);
 		} finally {
-			roots.delete();
+			k.xcafClose(docId);
 		}
-	})();
+	} finally {
+		for (const id of scaled) k.release(id);
+	}
+}
+function createXCAFDocument(k, makeCompound, shapes) {
+	const retainedId = unwrap(makeCompound(shapes.map((s) => s.shape)));
 	try {
-		return hasShapes ? k.xcafExportSTEP(docId) : "";
+		return {
+			...handle("compound", addXcafParts(k, shapes)),
+			retainedId,
+			labels: shapes.map(({ name, color }) => ({
+				name,
+				color
+			}))
+		};
+	} catch (e) {
+		k.release(retainedId);
+		throw e;
+	}
+}
+function writeXCAFToSTEP(k, doc, options) {
+	const docId = unwrap(doc);
+	const { retainedId, labels } = doc;
+	try {
+		const units = resolveStepUnits(options);
+		if (units.modelScale === 1) return writeXcafDoc(k, docId, units);
+		if (retainedId === void 0 || labels === void 0) throw new Error("occt-wasm: this XCAF document does not record its parts");
+		return writeScaledXcafParts(k, retainedId, labels, units);
 	} finally {
 		k.xcafClose(docId);
+		if (retainedId !== void 0) k.release(retainedId);
 	}
 }
-function exportSTEPConfigured(k, Module, shapes, _options) {
-	if (shapes.length === 0) return "";
-	const doc = createXCAFDocument(k, Module, shapes.map((s) => ({
-		shape: s.shape,
-		name: s.name ?? "",
-		color: s.color
-	})));
+/** Scale the retained compound once and write its children as the labeled parts. */
+function writeScaledXcafParts(k, retainedId, labels, units) {
+	const scaledId = k.scale(retainedId, 0, 0, 0, units.modelScale);
+	const children = k.iterShapes(scaledId);
+	const childIds = [];
 	try {
-		return writeXCAFToSTEP(k, doc);
+		for (let i = 0; i < children.size(); i++) childIds.push(children.get(i));
+		return writeXcafParts(k, labels.map((label, i) => ({
+			...label,
+			shape: handle("compound", childIds[i] ?? 0)
+		})), {
+			...units,
+			modelScale: 1
+		});
 	} finally {
-		doc.delete();
+		children.delete();
+		for (const id of childIds) k.release(id);
+		k.release(scaledId);
 	}
 }
+function exportSTEPConfigured(k, makeCompound, shapes, options) {
+	if (shapes.length === 0) return "";
+	const units = resolveStepUnits(options);
+	if (!shapes.some((s) => s.name || s.color)) return writeStepShapes(k, makeCompound, shapes.map((s) => s.shape), units);
+	return writeXcafParts(k, shapes, units);
+}
 // src/kernel/occtWasm/constructionOps.ts
 function makeVertex(k, x, y, z) {
 	return handle("vertex", k.makeVertex(x, y, z));
@@ -5924,32 +6123,36 @@ function cutAllWithHistory(k, Module, shape, tools, inputFaceHashes, hashUpperBo
 	return withSolidIds(k, [shape], (argIds) => withSolidIds(k, tools, (toolIds) => viaBooleanOp(k, Module, "cut", argIds, toolIds, inputFaceHashes, hashUpperBound, options)));
 }
 function filletWithHistory(k, Module, shape, edges, radius, inputFaceHashes, hashUpperBound) {
-	const r = resolveUniformRadius(edges, radius);
-	const edgeVec = makeVecU32(Module, edges.map(unwrap));
+	const shapeId = unwrap(shape);
 	const hashVec = makeVecInt(Module, inputFaceHashes);
 	try {
-		const { id, evolution } = parseEvolution(reportingFaultyEdges(edges, () => k.filletWithHistory(unwrap(shape), edgeVec, r, hashVec, hashUpperBound)));
+		const { id, evolution } = parseEvolution(runEdgeTreatment(Module, edges, radius, (edgeVec, r) => k.filletWithHistory(shapeId, edgeVec, r, hashVec, hashUpperBound), (edgeVec, startRadii, endRadii) => {
+			if (!k.filletRadiiWithHistory) throw needsOcctWasm59("per-edge or tapered fillet radii");
+			return k.filletRadiiWithHistory(shapeId, edgeVec, startRadii, endRadii, hashVec, hashUpperBound);
+		}));
 		return {
 			shape: wrapResult(k, id),
 			evolution
 		};
 	} finally {
-		edgeVec.delete();
 		hashVec.delete();
 	}
 }
 function chamferWithHistory(k, Module, shape, edges, distance, inputFaceHashes, hashUpperBound) {
-	const d = resolveUniformRadius(edges, distance);
-	const edgeVec = makeVecU32(Module, edges.map(unwrap));
+	const shapeId = unwrap(shape);
+	const faceVec = makeVecU32(Module, []);
 	const hashVec = makeVecInt(Module, inputFaceHashes);
 	try {
-		const { id, evolution } = parseEvolution(reportingFaultyEdges(edges, () => k.chamferWithHistory(unwrap(shape), edgeVec, d, hashVec, hashUpperBound)));
+		const { id, evolution } = parseEvolution(runEdgeTreatment(Module, edges, distance, (edgeVec, d) => k.chamferWithHistory(shapeId, edgeVec, d, hashVec, hashUpperBound), (edgeVec, distances1, distances2) => {
+			if (!k.chamferDistancesWithHistory) throw needsOcctWasm59("per-edge or asymmetric chamfer distances");
+			return k.chamferDistancesWithHistory(shapeId, edgeVec, distances1, distances2, faceVec, hashVec, hashUpperBound);
+		}));
 		return {
 			shape: wrapResult(k, id),
 			evolution
 		};
 	} finally {
-		edgeVec.delete();
+		faceVec.delete();
 		hashVec.delete();
 	}
 }
@@ -5991,21 +6194,30 @@ function offsetWithHistory(k, Module, shape, distance, inputFaceHashes, hashUppe
 		hashVec.delete();
 	}
 }
-function draftWithHistory(k, shape, faces, pullDirection, angleDeg) {
-	const [dx, dy, dz] = pullDirection;
-	let currentId = unwrap(shape);
-	for (const face of faces) {
-		const angleRad = (typeof angleDeg === "number" ? angleDeg : angleDeg(face)) * Math.PI / 180;
-		currentId = k.draft(currentId, unwrap(face), angleRad, dx, dy, dz);
-	}
-	return {
-		shape: wrapResult(k, currentId),
+function draftWithHistory(k, Module, shape, faces, pullDirection, neutralPlane, angleDeg, inputFaceHashes, hashUpperBound) {
+	if (!k.draftFacesWithHistory) return {
+		shape: draft(k, Module, shape, faces, pullDirection, neutralPlane, angleDeg),
 		evolution: {
 			modified: /* @__PURE__ */ new Map(),
 			generated: /* @__PURE__ */ new Map(),
 			deleted: /* @__PURE__ */ new Set()
 		}
 	};
+	const anglesRad = draftAnglesRad(faces, angleDeg);
+	const faceVec = makeVecU32(Module, faces.map(unwrap));
+	const angleVec = makeVecDouble(Module, anglesRad);
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(k.draftFacesWithHistory(unwrap(shape), faceVec, angleVec, ...pullDirection, ...neutralPlane, ...pullDirection, hashVec, hashUpperBound));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		faceVec.delete();
+		angleVec.delete();
+		hashVec.delete();
+	}
 }
 function applyComposedTransformWithHistory(transformFn, iterShapesFn, hashCodeFn, shape, transformHandle, inputFaceHashes, hashUpperBound) {
 	const result = transformFn(shape, transformHandle);
@@ -6367,7 +6579,7 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 		return filletVariable(this.k, shape, spec);
 	}
 	draft(shape, faces, pullDirection, neutralPlane, angleDeg) {
-		return draft(this.k, shape, faces, pullDirection, neutralPlane, angleDeg);
+		return draft(this.k, this.Module, shape, faces, pullDirection, neutralPlane, angleDeg);
 	}
 	defeature(shape, faces) {
 		return defeature(this.k, this.Module, shape, faces);
@@ -6459,8 +6671,8 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 	offsetWithHistory(shape, distance, inputFaceHashes, hashUpperBound, tolerance) {
 		return offsetWithHistory(this.k, this.Module, shape, distance, inputFaceHashes, hashUpperBound, tolerance);
 	}
-	draftWithHistory(shape, faces, pullDirection, _neutralPlane, angleDeg, _inputFaceHashes, _hashUpperBound) {
-		return draftWithHistory(this.k, shape, faces, pullDirection, angleDeg);
+	draftWithHistory(shape, faces, pullDirection, neutralPlane, angleDeg, inputFaceHashes, hashUpperBound) {
+		return draftWithHistory(this.k, this.Module, shape, faces, pullDirection, neutralPlane, angleDeg, inputFaceHashes, hashUpperBound);
 	}
 	applyComposedTransformWithHistory(shape, transformHandle, inputFaceHashes, hashUpperBound) {
 		return applyComposedTransformWithHistory((s, t) => this.transform(s, t), (s, t) => this.iterShapes(s, t), (s, ub) => this.hashCode(s, ub), shape, transformHandle, inputFaceHashes, hashUpperBound);
@@ -6496,7 +6708,7 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 		return importIGES(this.k, data);
 	}
 	exportSTEPAssembly(parts, options) {
-		return exportSTEPAssembly(this.k, this.Module, parts, options);
+		return exportSTEPAssembly(this.k, parts, options);
 	}
 	export3MF(_shape, _tolerance) {
 		throw new Error("export3MF is only available with the brepkit kernel");
@@ -6526,13 +6738,13 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 		return fromBREP(this.k, data);
 	}
 	createXCAFDocument(shapes) {
-		return createXCAFDocument(this.k, this.Module, shapes);
+		return createXCAFDocument(this.k, this.makeCompound.bind(this), shapes);
 	}
 	writeXCAFToSTEP(doc, options) {
 		return writeXCAFToSTEP(this.k, doc, options);
 	}
 	exportSTEPConfigured(shapes, options) {
-		return exportSTEPConfigured(this.k, this.Module, shapes, options);
+		return exportSTEPConfigured(this.k, this.makeCompound.bind(this), shapes, options);
 	}
 	volume(shape) {
 		return volume(this.k, shape);

package/dist/operations.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_threadFns = require("./threadFns-1H60LrFX.cjs");
-const require_loftFns = require("./loftFns-DGV1z2NJ.cjs");
+const require_threadFns = require("./threadFns-e8_26ZYw.cjs");
+const require_loftFns = require("./loftFns-T0GxcPlB.cjs");
 exports.addChild = require_threadFns.addChild;
 exports.addJoint = require_threadFns.addJoint;
 exports.addStep = require_threadFns.addStep;

package/dist/operations.js

@@ -1,3 +1,3 @@
-import { A as setJointValue, B as walkAssembly, C as cylindricalJoint, D as planarJoint, E as mechanismDOF, F as countNodes, H as circularPattern, I as createAssemblyNode, L as findNode, M as sphericalJoint, N as addChild, O as prismaticJoint, P as collectShapes, R as removeChild, S as addJoint, T as jointTransform, U as gridPattern, V as exportAssemblySTEP, W as linearPattern, Y as createAssembly, _ as exportURDF, b as inverseKinematics, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, j as setJointValues, k as revoluteJoint, l as registerOperation, m as stepCount, n as addStep, o as findStep, r as createHistory, s as getShape, t as thread, u as registerShape, v as importURDF, w as forwardKinematics, x as jointTrajectory, y as jointsFromDH, z as updateNode } from "./threadFns-CHdY-4Cz.js";
-import { c as twistExtrude, o as supportExtrude, r as complexExtrude, s as sweep } from "./loftFns-DQ7Z29n3.js";
+import { A as setJointValue, B as walkAssembly, C as cylindricalJoint, D as planarJoint, E as mechanismDOF, F as countNodes, H as circularPattern, I as createAssemblyNode, L as findNode, M as sphericalJoint, N as addChild, O as prismaticJoint, P as collectShapes, R as removeChild, S as addJoint, T as jointTransform, U as gridPattern, V as exportAssemblySTEP, W as linearPattern, Y as createAssembly, _ as exportURDF, b as inverseKinematics, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, j as setJointValues, k as revoluteJoint, l as registerOperation, m as stepCount, n as addStep, o as findStep, r as createHistory, s as getShape, t as thread, u as registerShape, v as importURDF, w as forwardKinematics, x as jointTrajectory, y as jointsFromDH, z as updateNode } from "./threadFns-CmZFykpi.js";
+import { c as twistExtrude, o as supportExtrude, r as complexExtrude, s as sweep } from "./loftFns-Bh_RuF7a.js";
 export { addChild, addJoint, addStep, circularPattern, collectShapes, complexExtrude, countNodes, createAssembly, createAssemblyNode, createHistory, createRegistry, cylindricalJoint, exportAssemblySTEP, exportURDF, findNode, findStep, forwardKinematics, getShape as getHistoryShape, gridPattern, importURDF, inverseKinematics, jointTrajectory, jointTransform, jointsFromDH, linearPattern, mechanismDOF, modifyStep, planarJoint, prismaticJoint, registerOperation, registerShape, removeChild, replayFrom, replayHistory, revoluteJoint, setJointValue, setJointValues, sphericalJoint, stepCount, stepsFrom, supportExtrude, sweep, thread, twistExtrude, undoLast, updateNode, walkAssembly };

package/dist/{primitiveFns-3-gs-FUX.js → primitiveFns-CeRc4Sls.js}

@@ -1,10 +1,11 @@
-import { E as GeometryCleanupError, G as _usingCtx, d as createSolid, n as castResultShape, q as getKernel } from "./shapeTypes-BNGu103j.js";
+import { E as GeometryCleanupError, G as _usingCtx, d as createSolid, n as castResultShape, q as getKernel } from "./shapeTypes-DvzbSivn.js";
 import { E as ok, d as validationError, g as err, m as andThen, t as BrepErrorCode } from "./errors-BTccWbtE.js";
-import { n as isClosedWire } from "./validityTypes-GanLrmvY.js";
+import { n as isClosedWire } from "./validityTypes-CdY06B8c.js";
 import { n as HASH_CODE_MAX, t as DEG2RAD } from "./constants-iraOnb2p.js";
 import { d as vecNormalize, h as vecScale } from "./vecOps-S-m9H_fe.js";
-import { C as propagateAllMetadata, S as hasAnyMetadata, T as propagateMetadataThroughRelocation, a as makeOffset, c as makeTorus, i as makeEllipsoid, l as makeVertex, n as makeCone, o as makeSolid, r as makeCylinder, s as makeSphere, t as makeCompound, u as weldShellsAndFaces, w as propagateMetadataByHash, x as collectInputFaceHashes } from "./solidBuilders-Bmr59cGp.js";
-import { _ as makeThreePointArc, a as makeNonPlanarFace, c as makeBSplineApproximation, d as makeCircle, f as makeEllipse, g as makeTangentArc, h as makeLine, i as makeNewFaceWithinFace, m as makeHelix, o as makePolygon, p as makeEllipseArc, r as makeFace, s as assembleWire, t as addHolesInFace, u as makeBezierCurve } from "./surfaceBuilders-DI376ai0.js";
+import { a as makeOffset, c as makeTorus, i as makeEllipsoid, l as makeVertex, n as makeCone, o as makeSolid, r as makeCylinder, s as makeSphere, t as makeCompound, u as weldShellsAndFaces } from "./solidBuilders-BqSVC4cB.js";
+import { d as collectInputFaceHashes, f as hasAnyMetadata, h as propagateMetadataThroughRelocation, m as propagateMetadataByHash, p as propagateAllMetadata } from "./booleanFns-CKDyqKz0.js";
+import { _ as makeThreePointArc, a as makeNonPlanarFace, c as makeBSplineApproximation, d as makeCircle, f as makeEllipse, g as makeTangentArc, h as makeLine, i as makeNewFaceWithinFace, m as makeHelix, o as makePolygon, p as makeEllipseArc, r as makeFace, s as assembleWire, t as addHolesInFace, u as makeBezierCurve } from "./surfaceBuilders--HOoTQad.js";
 // src/topology/transformFns.ts
 /**
 * Immutable shape transforms — translate, rotate, scale, mirror, applyMatrix.