brepjs 20.12.7 → 20.12.9

package/dist/{occtWasmAdapter-D3qerQTq.cjs → occtWasmAdapter-CZPZnpCe.cjs}

@@ -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);