brepjs 18.66.1 → 18.67.0

package/dist/brepjs.cjs

@@ -1,36 +1,36 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_textBlueprints = require("./textBlueprints-BRqklfRI.cjs");
-const require_shapeTypes = require("./shapeTypes-CPClTSJn.cjs");
+const require_textBlueprints = require("./textBlueprints-Q2gxuZd1.cjs");
+const require_shapeTypes = require("./shapeTypes-kAKwccy_.cjs");
 const require_occtWasmAdapter = require("./occtWasmAdapter-BPu07Zxg.cjs");
 const require_vec3 = require("./vec3-CFwOI0ZI.cjs");
 const require_errors = require("./errors-CXJtc4I7.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-jK9Vpzqr.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-Ck5trXrW.cjs");
 const require_constants = require("./constants-BOVyEYGH.cjs");
 const require_types = require("./types-KjA8tY4Y.cjs");
 const require_vecOps = require("./vecOps-CCnJt-yH.cjs");
 const require_planeOps = require("./planeOps-BA4HfgQu.cjs");
-const require_faceFns = require("./faceFns-BmaS4kkW.cjs");
-const require_shapeFns = require("./shapeFns-ClKe2vri.cjs");
-const require_curveFns = require("./curveFns-BJLQixZw.cjs");
-const require_meshFns = require("./meshFns-B5jxU_H4.cjs");
+const require_faceFns = require("./faceFns-Byt7Vd3F.cjs");
+const require_shapeFns = require("./shapeFns-B5JrP5aD.cjs");
+const require_curveFns = require("./curveFns-CYP8UOgX.cjs");
+const require_meshFns = require("./meshFns-DwHAYqRN.cjs");
 const require_arrayAccess = require("./arrayAccess-e4H9cBfh.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-88vLyzZe.cjs");
-const require_booleanFns = require("./booleanFns-D57G9tJA.cjs");
-const require_primitiveFns = require("./primitiveFns-B_Vhus6h.cjs");
-const require_historyFns = require("./historyFns-CDVZ3KM8.cjs");
-const require_blueprintSketcher = require("./blueprintSketcher-CWSesXXR.cjs");
-const require_helpers = require("./helpers-qkB-gFkC.cjs");
-const require_drawFns = require("./drawFns-BuE0lne3.cjs");
-const require_solidBuilders = require("./solidBuilders-CtxTfDlu.cjs");
-const require_measureFns = require("./measureFns-HhPPUiRO.cjs");
-const require_cornerFinder = require("./cornerFinder-Dvu2q_-E.cjs");
-const require_boolean2D = require("./boolean2D-C6xLLzU_.cjs");
-const require_blueprintFns = require("./blueprintFns-pq0yw94E.cjs");
-const require_importFns = require("./importFns-B7pbqJhZ.cjs");
-const require_extrudeFns = require("./extrudeFns-BDgqrytA.cjs");
-const require_cameraFns = require("./cameraFns-DSAYGgrz.cjs");
-const require_textMetrics = require("./textMetrics-F2qR-eqQ.cjs");
-const require_shapeRefFns = require("./shapeRefFns-DUt-hIWq.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-BkvJS8pw.cjs");
+const require_booleanFns = require("./booleanFns-aeG4pQmM.cjs");
+const require_primitiveFns = require("./primitiveFns-CKCALTVe.cjs");
+const require_historyFns = require("./historyFns-BzPsKySX.cjs");
+const require_blueprintSketcher = require("./blueprintSketcher-4zOPSOnK.cjs");
+const require_helpers = require("./helpers-wFts3ttt.cjs");
+const require_drawFns = require("./drawFns-Chpdmj4G.cjs");
+const require_solidBuilders = require("./solidBuilders-B2IX6Pm8.cjs");
+const require_measureFns = require("./measureFns-CrSEblGG.cjs");
+const require_cornerFinder = require("./cornerFinder-tTS3ny7e.cjs");
+const require_boolean2D = require("./boolean2D-xDBZQH_n.cjs");
+const require_blueprintFns = require("./blueprintFns-DULa6FpG.cjs");
+const require_importFns = require("./importFns-CwILDYiQ.cjs");
+const require_extrudeFns = require("./extrudeFns-IvYW5-8y.cjs");
+const require_cameraFns = require("./cameraFns-Bk8frXwa.cjs");
+const require_textMetrics = require("./textMetrics-CnCjqf59.cjs");
+const require_shapeRefFns = require("./shapeRefFns-H_O8zyAx.cjs");
 const require_workerHandler = require("./workerHandler-CdlOTwJg.cjs");
 //#region src/topology/shapeBooleans.ts
 var BOPAlgo_GlueShift = 1;
@@ -218,8 +218,8 @@ function pointsInside(mesh, queries, id) {
 }
 //#endregion
 //#region src/voxel/repairFns.ts
-var DEFAULT_RESOLUTION$2 = 48;
-var DEFAULT_PADDING$2 = 2;
+var DEFAULT_RESOLUTION$3 = 48;
+var DEFAULT_PADDING$3 = 2;
 /**
 * Repair a (possibly non-watertight) triangle-soup mesh into a closed surface:
 * voxelize an FWN-signed SDF, then Surface-Nets contour it back to triangles.
@@ -232,16 +232,16 @@ function repairMesh(mesh, opts, id) {
 	const invalid = validateMesh(mesh);
 	if (invalid) return require_errors.err(invalid);
 	if (mesh.vertices.length === 0 || mesh.triangles.length === 0) return require_errors.err(require_errors.validationError("VOXEL_EMPTY_MESH", "repairMesh requires a non-empty triangle mesh."));
-	const resolution = opts?.resolution ?? DEFAULT_RESOLUTION$2;
-	const padding = opts?.padding ?? DEFAULT_PADDING$2;
+	const resolution = opts?.resolution ?? DEFAULT_RESOLUTION$3;
+	const padding = opts?.padding ?? DEFAULT_PADDING$3;
 	if (!Number.isInteger(resolution) || resolution < 1) return require_errors.err(require_errors.validationError("VOXEL_INVALID_RESOLUTION", "resolution must be an integer >= 1."));
 	if (!Number.isInteger(padding) || padding < 1) return require_errors.err(require_errors.validationError("VOXEL_INVALID_PADDING", "padding must be an integer >= 1."));
 	const engine = resolveEngine(id);
 	if (require_errors.isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$6 = require_shapeTypes._usingCtx();
-			const repaired = _usingCtx$6.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
+			var _usingCtx$7 = require_shapeTypes._usingCtx();
+			const repaired = _usingCtx$7.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
 			const vertexCount = repaired.positions.length / 3;
 			return require_errors.ok({
 				vertices: repaired.positions,
@@ -255,9 +255,9 @@ function repairMesh(mesh, opts, id) {
 				}]
 			});
 		} catch (_) {
-			_usingCtx$6.e = _;
+			_usingCtx$7.e = _;
 		} finally {
-			_usingCtx$6.d();
+			_usingCtx$7.d();
 		}
 	} catch (cause) {
 		return require_errors.err(require_errors.computationError("VOXEL_REPAIR_FAILED", cause instanceof Error ? cause.message : "voxel repair failed (grid too large?).", cause));
@@ -286,16 +286,16 @@ function shapeToMeshInput(shape, deflection = DEFAULT_DEFLECTION) {
 }
 //#endregion
 //#region src/voxel/meshOpsFns.ts
-var DEFAULT_RESOLUTION$1 = 48;
-var DEFAULT_PADDING$1 = 2;
-var BOOLEAN_OP_CODES = {
+var DEFAULT_RESOLUTION$2 = 48;
+var DEFAULT_PADDING$2 = 2;
+var BOOLEAN_OP_CODES$1 = {
 	union: 0,
 	intersection: 1,
 	difference: 2
 };
-function resolveGridParams(opts) {
-	const resolution = opts?.resolution ?? DEFAULT_RESOLUTION$1;
-	const padding = opts?.padding ?? DEFAULT_PADDING$1;
+function resolveGridParams$1(opts) {
+	const resolution = opts?.resolution ?? DEFAULT_RESOLUTION$2;
+	const padding = opts?.padding ?? DEFAULT_PADDING$2;
 	if (!Number.isInteger(resolution) || resolution < 1) return require_errors.err(require_errors.validationError("VOXEL_INVALID_RESOLUTION", "resolution must be an integer >= 1."));
 	if (!Number.isInteger(padding) || padding < 1) return require_errors.err(require_errors.validationError("VOXEL_INVALID_PADDING", "padding must be an integer >= 1."));
 	return require_errors.ok({
@@ -330,18 +330,18 @@ function offsetMesh(mesh, distance, opts, id) {
 	if (invalid) return require_errors.err(invalid);
 	if (mesh.vertices.length === 0 || mesh.triangles.length === 0) return require_errors.err(require_errors.validationError("VOXEL_EMPTY_MESH", "offsetMesh requires a non-empty triangle mesh."));
 	if (!Number.isFinite(distance)) return require_errors.err(require_errors.validationError("VOXEL_INVALID_DISTANCE", "distance must be a finite number."));
-	const params = resolveGridParams(opts);
+	const params = resolveGridParams$1(opts);
 	if (require_errors.isErr(params)) return params;
 	const engine = resolveEngine(id);
 	if (require_errors.isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$5 = require_shapeTypes._usingCtx();
-			return meshFromResult(_usingCtx$5.u(engine.value.offset_mesh(mesh.vertices, mesh.triangles, distance, params.value.resolution, params.value.padding)));
+			var _usingCtx$6 = require_shapeTypes._usingCtx();
+			return meshFromResult(_usingCtx$6.u(engine.value.offset_mesh(mesh.vertices, mesh.triangles, distance, params.value.resolution, params.value.padding)));
 		} catch (_) {
-			_usingCtx$5.e = _;
+			_usingCtx$6.e = _;
 		} finally {
-			_usingCtx$5.d();
+			_usingCtx$6.d();
 		}
 	} catch (cause) {
 		return require_errors.err(require_errors.computationError("VOXEL_OFFSET_FAILED", cause instanceof Error ? cause.message : "voxel offset failed (grid too large?).", cause));
@@ -359,7 +359,7 @@ function shellMesh(mesh, thickness, opts, id) {
 	if (invalid) return require_errors.err(invalid);
 	if (mesh.vertices.length === 0 || mesh.triangles.length === 0) return require_errors.err(require_errors.validationError("VOXEL_EMPTY_MESH", "shellMesh requires a non-empty triangle mesh."));
 	if (!Number.isFinite(thickness) || thickness <= 0) return require_errors.err(require_errors.validationError("VOXEL_INVALID_THICKNESS", "thickness must be a finite number > 0."));
-	const params = resolveGridParams(opts);
+	const params = resolveGridParams$1(opts);
 	if (require_errors.isErr(params)) return params;
 	const engine = resolveEngine(id);
 	if (require_errors.isErr(engine)) return engine;
@@ -390,8 +390,8 @@ function voxelBoolean(a, b, op, opts, id) {
 	if (invalidB) return require_errors.err(invalidB);
 	if (a.vertices.length === 0 || a.triangles.length === 0) return require_errors.err(require_errors.validationError("VOXEL_EMPTY_MESH", "voxelBoolean requires a non-empty mesh for operand A."));
 	if (b.vertices.length === 0 || b.triangles.length === 0) return require_errors.err(require_errors.validationError("VOXEL_EMPTY_MESH", "voxelBoolean requires a non-empty mesh for operand B."));
-	const opCode = BOOLEAN_OP_CODES[op];
-	const params = resolveGridParams(opts);
+	const opCode = BOOLEAN_OP_CODES$1[op];
+	const params = resolveGridParams$1(opts);
 	if (require_errors.isErr(params)) return params;
 	const engine = resolveEngine(id);
 	if (require_errors.isErr(engine)) return engine;
@@ -441,6 +441,263 @@ function voxelBooleanShapes(a, b, op, opts, id) {
 	return voxelBoolean(meshA.value, meshB.value, op, opts, id);
 }
 //#endregion
+//#region src/voxel/fieldFns.ts
+var DEFAULT_RESOLUTION$1 = 48;
+var DEFAULT_PADDING$1 = 2;
+var BOOLEAN_OP_CODES = {
+	union: 0,
+	intersection: 1,
+	difference: 2
+};
+function resolveGridParams(opts) {
+	const resolution = opts?.resolution ?? DEFAULT_RESOLUTION$1;
+	const padding = opts?.padding ?? DEFAULT_PADDING$1;
+	if (!Number.isInteger(resolution) || resolution < 1) return require_errors.err(require_errors.validationError("VOXEL_INVALID_RESOLUTION", "resolution must be an integer >= 1."));
+	if (!Number.isInteger(padding) || padding < 1) return require_errors.err(require_errors.validationError("VOXEL_INVALID_PADDING", "padding must be an integer >= 1."));
+	return require_errors.ok({
+		resolution,
+		padding
+	});
+}
+/**
+* Copy the buffers out of a WASM {@link VoxelRepairResult} into a plain
+* {@link KernelMeshResult}, freeing the WASM result via `using` (the getters
+* copy, so the mesh survives the free). An empty contour surfaces as an error.
+*/
+function meshFromField(field) {
+	try {
+		var _usingCtx$5 = require_shapeTypes._usingCtx();
+		const rawResult = field.contour();
+		const { positions, normals, indices } = _usingCtx$5.u({
+			value: rawResult,
+			[Symbol.dispose]() {
+				rawResult.free();
+			}
+		}).value;
+		if (positions.length === 0 || indices.length === 0) return require_errors.err(require_errors.computationError("VOXEL_DEGENERATE_RESULT", "the voxel field contoured to an empty mesh (over-shrunk offset or disjoint operands?)."));
+		const vertexCount = positions.length / 3;
+		return require_errors.ok({
+			vertices: positions,
+			normals,
+			triangles: indices,
+			uvs: new Float32Array(vertexCount * 2),
+			faceGroups: [{
+				start: 0,
+				count: indices.length / 3,
+				faceHash: 0
+			}]
+		});
+	} catch (_) {
+		_usingCtx$5.e = _;
+	} finally {
+		_usingCtx$5.d();
+	}
+}
+function fieldDeletable(raw) {
+	return {
+		raw,
+		delete() {
+			raw.free();
+		}
+	};
+}
+function makeHandle(raw) {
+	const inner = require_shapeTypes.createKernelHandle(fieldDeletable(raw));
+	const handle = {
+		get value() {
+			return inner.value.raw;
+		},
+		get disposed() {
+			return inner.disposed;
+		},
+		[Symbol.dispose]() {
+			inner[Symbol.dispose]();
+		},
+		boolean(other, op) {
+			this.value.boolean(other.value, BOOLEAN_OP_CODES[op]);
+			return handle;
+		},
+		offset(distance) {
+			this.value.offset(distance);
+			return handle;
+		},
+		shell(thickness) {
+			this.value.shell(thickness);
+			return handle;
+		},
+		reinit() {
+			this.value.reinit();
+			return handle;
+		},
+		contour() {
+			const mesh = meshFromField(this.value);
+			if (require_errors.isErr(mesh)) throw new Error(mesh.error.message);
+			return mesh.value;
+		}
+	};
+	return handle;
+}
+/** Live-handle guard (the `VoxelFieldHandle` analogue of disposal's `isLive`). */
+function isLive$1(handle) {
+	return !handle.disposed;
+}
+function disposedErr() {
+	return require_errors.err(require_errors.validationError("VOXEL_FIELD_DISPOSED", "the voxel field handle has been disposed."));
+}
+/**
+* Voxelize a mesh into a persistent dense {@link VoxelFieldHandle}: one grid you
+* can boolean / offset / shell / reinit in place, then contour once. The handle
+* is disposable — free the WASM grid with `using` (or `[Symbol.dispose]()`).
+*
+* `resolution` sizes the longest bbox axis; `padding` is the air-margin ring.
+* Errors on an empty/invalid mesh, or if the grid would exceed the dense budget
+* (the persistent path is dense-only) or the voxel cap.
+*/
+function voxelField(mesh, opts, id) {
+	const invalid = validateMesh(mesh);
+	if (invalid) return require_errors.err(invalid);
+	if (mesh.vertices.length === 0 || mesh.triangles.length === 0) return require_errors.err(require_errors.validationError("VOXEL_EMPTY_MESH", "voxelField requires a non-empty triangle mesh."));
+	const params = resolveGridParams(opts);
+	if (require_errors.isErr(params)) return params;
+	const engine = resolveEngine(id);
+	if (require_errors.isErr(engine)) return engine;
+	try {
+		return require_errors.ok(makeHandle(new engine.value.VoxelField(mesh.vertices, mesh.triangles, params.value.resolution, params.value.padding)));
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("VOXEL_FIELD_VOXELIZE_FAILED", cause instanceof Error ? cause.message : "voxel field voxelization failed (grid too large or non-dense?).", cause));
+	}
+}
+/**
+* Boolean two meshes into ONE co-registered, chainable {@link VoxelFieldHandle}:
+* voxelize both onto a single shared grid sized to their union bbox, combine by
+* `op`, and keep the field. This is THE correct way to "boolean then chain
+* offset/shell" two independently-described meshes — unlike {@link fieldBoolean},
+* which requires the operands to already share grid geometry. The result is
+* dirty (the blend drifts the gradient), so a subsequent offset/shell
+* auto-reinitializes. The handle is disposable — free it with `using`.
+*
+* `op` is `'difference'` = A − B. Errors on an empty/invalid mesh, or if the
+* shared grid would exceed the dense budget (the persistent path is dense-only).
+*/
+function voxelBooleanField(a, b, op, opts, id) {
+	const invalidA = validateMesh(a);
+	if (invalidA) return require_errors.err(invalidA);
+	const invalidB = validateMesh(b);
+	if (invalidB) return require_errors.err(invalidB);
+	if (a.vertices.length === 0 || a.triangles.length === 0) return require_errors.err(require_errors.validationError("VOXEL_EMPTY_MESH", "voxelBooleanField requires a non-empty mesh for operand A."));
+	if (b.vertices.length === 0 || b.triangles.length === 0) return require_errors.err(require_errors.validationError("VOXEL_EMPTY_MESH", "voxelBooleanField requires a non-empty mesh for operand B."));
+	const params = resolveGridParams(opts);
+	if (require_errors.isErr(params)) return params;
+	const engine = resolveEngine(id);
+	if (require_errors.isErr(engine)) return engine;
+	try {
+		return require_errors.ok(makeHandle(engine.value.VoxelField.boolean_of(a.vertices, a.triangles, b.vertices, b.triangles, BOOLEAN_OP_CODES[op], params.value.resolution, params.value.padding)));
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("VOXEL_FIELD_BOOLEAN_FAILED", cause instanceof Error ? cause.message : "voxel field boolean failed (grid too large or non-dense?).", cause));
+	}
+}
+/**
+* CSG-combine two fields IN PLACE, returning the SAME `handle` for chaining. The
+* min/max blend keeps the zero set exact but drifts the gradient near the join,
+* so a subsequent {@link fieldOffset}/{@link fieldShell} auto-reinitializes.
+*
+* PRECONDITION: both operands must be CO-REGISTERED — same origin, spacing, AND
+* dims. Two fields built by {@link voxelField} from DIFFERENT meshes generally do
+* NOT share geometry (each sizes its grid to its own bbox), and the WASM guard
+* rejects that mismatch as an `err(...)` rather than silently blending mismatched
+* coordinate frames. For the easy co-registered path, build the field directly
+* from both meshes with {@link voxelBooleanField}.
+*/
+function fieldBoolean(handle, other, op) {
+	if (!isLive$1(handle) || !isLive$1(other)) return disposedErr();
+	try {
+		handle.value.boolean(other.value, BOOLEAN_OP_CODES[op]);
+		return require_errors.ok(handle);
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("VOXEL_FIELD_BOOLEAN_FAILED", cause instanceof Error ? cause.message : "voxel field boolean failed (dim mismatch?).", cause));
+	}
+}
+/**
+* Offset the field's surface IN PLACE (>0 outward, <0 inward), returning the
+* SAME `handle`. Auto-reinitializes first if the field is dirty (post-boolean),
+* so the iso-shift always rides a true SDF.
+*/
+function fieldOffset(handle, distance) {
+	if (!isLive$1(handle)) return disposedErr();
+	if (!Number.isFinite(distance)) return require_errors.err(require_errors.validationError("VOXEL_INVALID_DISTANCE", "distance must be a finite number."));
+	try {
+		handle.value.offset(distance);
+		return require_errors.ok(handle);
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("VOXEL_FIELD_OFFSET_FAILED", cause instanceof Error ? cause.message : "voxel field offset failed.", cause));
+	}
+}
+/**
+* Hollow the field into an inward shell of `thickness` IN PLACE, returning the
+* SAME `handle`. Auto-reinitializes first if dirty; the result is dirty again
+* (the shell re-introduces a kink).
+*/
+function fieldShell(handle, thickness) {
+	if (!isLive$1(handle)) return disposedErr();
+	if (!Number.isFinite(thickness) || thickness <= 0) return require_errors.err(require_errors.validationError("VOXEL_INVALID_THICKNESS", "thickness must be a finite number > 0."));
+	try {
+		handle.value.shell(thickness);
+		return require_errors.ok(handle);
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("VOXEL_FIELD_SHELL_FAILED", cause instanceof Error ? cause.message : "voxel field shell failed.", cause));
+	}
+}
+/**
+* Explicitly reinitialize φ to a true SDF (|∇φ|=1) while preserving the zero
+* set, returning the SAME `handle`. Idempotent on a clean field. Offset/shell
+* already auto-reinitialize, so this is for advanced control only.
+*/
+function fieldReinit(handle) {
+	if (!isLive$1(handle)) return disposedErr();
+	try {
+		handle.value.reinit();
+		return require_errors.ok(handle);
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("VOXEL_FIELD_REINIT_FAILED", cause instanceof Error ? cause.message : "voxel field reinit failed.", cause));
+	}
+}
+/**
+* Surface-Nets contour the current field to a {@link KernelMeshResult}. The
+* field stays alive and chainable afterwards (contour borrows it). An empty
+* contour surfaces as `VOXEL_DEGENERATE_RESULT`.
+*/
+function fieldContour(handle) {
+	if (!isLive$1(handle)) return disposedErr();
+	try {
+		return meshFromField(handle.value);
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("VOXEL_FIELD_CONTOUR_FAILED", cause instanceof Error ? cause.message : "voxel field contour failed.", cause));
+	}
+}
+/**
+* Voxelize a B-rep shape into a persistent {@link VoxelFieldHandle}: tessellate
+* it, then run {@link voxelField}. Threads a meshing failure back as an
+* `err(...)`. The handle is disposable — free it with `using`.
+*/
+function voxelFieldFromShape(shape, opts, id) {
+	const meshInput = shapeToMeshInput(shape);
+	if (require_errors.isErr(meshInput)) return meshInput;
+	return voxelField(meshInput.value, opts, id);
+}
+/**
+* Boolean two B-rep shapes into one co-registered, chainable
+* {@link VoxelFieldHandle}: tessellate both, then run {@link voxelBooleanField}.
+* `op` is `'difference'` = A − B. Threads either meshing failure back as an
+* `err(...)`. The handle is disposable — free it with `using`.
+*/
+function voxelBooleanFieldShapes(a, b, op, opts, id) {
+	const meshA = shapeToMeshInput(a);
+	if (require_errors.isErr(meshA)) return meshA;
+	const meshB = shapeToMeshInput(b);
+	if (require_errors.isErr(meshB)) return meshB;
+	return voxelBooleanField(meshA.value, meshB.value, op, opts, id);
+}
+//#endregion
 //#region src/lattice/latticeFns.ts
 var LATTICE_TAGS = {
 	gyroid: 0,
@@ -5776,6 +6033,11 @@ exports.faceFinder = require_helpers.faceFinder;
 exports.faceGeomType = require_faceFns.faceGeomType;
 exports.faceOrientation = require_faceFns.faceOrientation;
 exports.facesOfEdge = require_primitiveFns.facesOfEdge;
+exports.fieldBoolean = fieldBoolean;
+exports.fieldContour = fieldContour;
+exports.fieldOffset = fieldOffset;
+exports.fieldReinit = fieldReinit;
+exports.fieldShell = fieldShell;
 exports.fill = require_surfaceBuilders.fill;
 exports.filledFace = require_primitiveFns.filledFace;
 exports.fillet = fillet;
@@ -6164,7 +6426,11 @@ exports.vertexFinder = vertexFinder;
 exports.vertexPosition = require_topologyQueryFns.vertexPosition;
 exports.verticesOfEdge = require_primitiveFns.verticesOfEdge;
 exports.voxelBoolean = voxelBoolean;
+exports.voxelBooleanField = voxelBooleanField;
+exports.voxelBooleanFieldShapes = voxelBooleanFieldShapes;
 exports.voxelBooleanShapes = voxelBooleanShapes;
+exports.voxelField = voxelField;
+exports.voxelFieldFromShape = voxelFieldFromShape;
 exports.walkAssembly = require_historyFns.walkAssembly;
 exports.windingNumbers = windingNumbers;
 exports.wire = require_primitiveFns.wire;