brepjs 18.66.2 → 18.67.0

package/dist/brepjs.cjs

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

package/dist/brepjs.js

@@ -229,8 +229,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.
@@ -243,16 +243,16 @@ function repairMesh(mesh, opts, id) {
 	const invalid = validateMesh(mesh);
 	if (invalid) return err(invalid);
 	if (mesh.vertices.length === 0 || mesh.triangles.length === 0) return err(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 err(validationError("VOXEL_INVALID_RESOLUTION", "resolution must be an integer >= 1."));
 	if (!Number.isInteger(padding) || padding < 1) return err(validationError("VOXEL_INVALID_PADDING", "padding must be an integer >= 1."));
 	const engine = resolveEngine(id);
 	if (isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$6 = _usingCtx();
-			const repaired = _usingCtx$6.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
+			var _usingCtx$7 = _usingCtx();
+			const repaired = _usingCtx$7.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
 			const vertexCount = repaired.positions.length / 3;
 			return ok({
 				vertices: repaired.positions,
@@ -266,9 +266,9 @@ function repairMesh(mesh, opts, id) {
 				}]
 			});
 		} catch (_) {
-			_usingCtx$6.e = _;
+			_usingCtx$7.e = _;
 		} finally {
-			_usingCtx$6.d();
+			_usingCtx$7.d();
 		}
 	} catch (cause) {
 		return err(computationError("VOXEL_REPAIR_FAILED", cause instanceof Error ? cause.message : "voxel repair failed (grid too large?).", cause));
@@ -297,16 +297,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 err(validationError("VOXEL_INVALID_RESOLUTION", "resolution must be an integer >= 1."));
 	if (!Number.isInteger(padding) || padding < 1) return err(validationError("VOXEL_INVALID_PADDING", "padding must be an integer >= 1."));
 	return ok({
@@ -341,18 +341,18 @@ function offsetMesh(mesh, distance, opts, id) {
 	if (invalid) return err(invalid);
 	if (mesh.vertices.length === 0 || mesh.triangles.length === 0) return err(validationError("VOXEL_EMPTY_MESH", "offsetMesh requires a non-empty triangle mesh."));
 	if (!Number.isFinite(distance)) return err(validationError("VOXEL_INVALID_DISTANCE", "distance must be a finite number."));
-	const params = resolveGridParams(opts);
+	const params = resolveGridParams$1(opts);
 	if (isErr(params)) return params;
 	const engine = resolveEngine(id);
 	if (isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$5 = _usingCtx();
-			return meshFromResult(_usingCtx$5.u(engine.value.offset_mesh(mesh.vertices, mesh.triangles, distance, params.value.resolution, params.value.padding)));
+			var _usingCtx$6 = _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 err(computationError("VOXEL_OFFSET_FAILED", cause instanceof Error ? cause.message : "voxel offset failed (grid too large?).", cause));
@@ -370,7 +370,7 @@ function shellMesh(mesh, thickness, opts, id) {
 	if (invalid) return err(invalid);
 	if (mesh.vertices.length === 0 || mesh.triangles.length === 0) return err(validationError("VOXEL_EMPTY_MESH", "shellMesh requires a non-empty triangle mesh."));
 	if (!Number.isFinite(thickness) || thickness <= 0) return err(validationError("VOXEL_INVALID_THICKNESS", "thickness must be a finite number > 0."));
-	const params = resolveGridParams(opts);
+	const params = resolveGridParams$1(opts);
 	if (isErr(params)) return params;
 	const engine = resolveEngine(id);
 	if (isErr(engine)) return engine;
@@ -401,8 +401,8 @@ function voxelBoolean(a, b, op, opts, id) {
 	if (invalidB) return err(invalidB);
 	if (a.vertices.length === 0 || a.triangles.length === 0) return err(validationError("VOXEL_EMPTY_MESH", "voxelBoolean requires a non-empty mesh for operand A."));
 	if (b.vertices.length === 0 || b.triangles.length === 0) return err(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 (isErr(params)) return params;
 	const engine = resolveEngine(id);
 	if (isErr(engine)) return engine;
@@ -452,6 +452,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 err(validationError("VOXEL_INVALID_RESOLUTION", "resolution must be an integer >= 1."));
+	if (!Number.isInteger(padding) || padding < 1) return err(validationError("VOXEL_INVALID_PADDING", "padding must be an integer >= 1."));
+	return 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 = _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 err(computationError("VOXEL_DEGENERATE_RESULT", "the voxel field contoured to an empty mesh (over-shrunk offset or disjoint operands?)."));
+		const vertexCount = positions.length / 3;
+		return 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 = 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 (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 err(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 err(invalid);
+	if (mesh.vertices.length === 0 || mesh.triangles.length === 0) return err(validationError("VOXEL_EMPTY_MESH", "voxelField requires a non-empty triangle mesh."));
+	const params = resolveGridParams(opts);
+	if (isErr(params)) return params;
+	const engine = resolveEngine(id);
+	if (isErr(engine)) return engine;
+	try {
+		return ok(makeHandle(new engine.value.VoxelField(mesh.vertices, mesh.triangles, params.value.resolution, params.value.padding)));
+	} catch (cause) {
+		return err(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 err(invalidA);
+	const invalidB = validateMesh(b);
+	if (invalidB) return err(invalidB);
+	if (a.vertices.length === 0 || a.triangles.length === 0) return err(validationError("VOXEL_EMPTY_MESH", "voxelBooleanField requires a non-empty mesh for operand A."));
+	if (b.vertices.length === 0 || b.triangles.length === 0) return err(validationError("VOXEL_EMPTY_MESH", "voxelBooleanField requires a non-empty mesh for operand B."));
+	const params = resolveGridParams(opts);
+	if (isErr(params)) return params;
+	const engine = resolveEngine(id);
+	if (isErr(engine)) return engine;
+	try {
+		return 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 err(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 ok(handle);
+	} catch (cause) {
+		return err(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 err(validationError("VOXEL_INVALID_DISTANCE", "distance must be a finite number."));
+	try {
+		handle.value.offset(distance);
+		return ok(handle);
+	} catch (cause) {
+		return err(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 err(validationError("VOXEL_INVALID_THICKNESS", "thickness must be a finite number > 0."));
+	try {
+		handle.value.shell(thickness);
+		return ok(handle);
+	} catch (cause) {
+		return err(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 ok(handle);
+	} catch (cause) {
+		return err(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 err(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 (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 (isErr(meshA)) return meshA;
+	const meshB = shapeToMeshInput(b);
+	if (isErr(meshB)) return meshB;
+	return voxelBooleanField(meshA.value, meshB.value, op, opts, id);
+}
+//#endregion
 //#region src/lattice/latticeFns.ts
 var LATTICE_TAGS = {
 	gyroid: 0,
@@ -5583,4 +5840,4 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	withEvaluator: () => withEvaluator
 });
 //#endregion
-export { BaseSketcher2d, BlueprintSketcher, BrepBugError, BrepErrorCode, BrepWrapperError, BrepkitAdapter, CompoundSketch, DEFAULT_CAPABILITIES, DEG2RAD, DisposalScope, EXACT_BREP_CAPABILITIES, FaceSketcher, HASH_CODE_MAX, OK, OcctWasmAdapter, RAD2DEG, Sketch, Sketcher, Sketches, addChild, addHoles, addMate, addStep, adjacentFaces, all, andThen, applyGlue, applyMatrix, approximateCurve, as2D, as3D, asTopo, assignRoles, autoHeal, bezier, blueprintToDXF, booleanPipeline, booleans_exports as booleans, boss, box, bsplineApprox, bug, cameraFromPlane, cameraLookAt, captureHint, cast, castShape, castShape3D, chamfer, chamferDistAngle as chamferDistAngleShape, chamferWithEvolution, checkAllInterferences, checkBoolean, checkInterference, circle, circularPattern, classifyPointOnFace, clearMeshCache, clone, closedWire, collect, collectShapes, colorFaces, colorShape, complexExtrude, composeTransforms, compound, compoundSketchExtrude, compoundSketchFace, compoundSketchLoft, compoundSketchRevolve, computationError, computeStraightSkeleton, cone, construction_exports as construction, convexHull, cornerFinder, countNodes, createAssembly, createAssemblyNode, createBlueprint, createCamera, createCompound, createCompoundBlueprint, createDistanceQuery, createEdge, createFace, createHandle, createHistory, createKernelHandle, createMeshCache, createNamedPlane, createOperationRegistry, createPlane, createRef, createRegistry, createShell, createSolid, createTaskQueue, createVertex, createWire, createWorkerClient, createWorkerHandler, csg_exports as csg, currentQuality, curve2dBoundingBox, curve2dDistanceFrom, curve2dFirstPoint, curve2dIsOnCurve, curve2dLastPoint, curve2dParameter, curve2dSplitAt, curve2dTangentAt, curveEndPoint, curveIsClosed, curveIsPeriodic, curveLength, curvePeriod, curvePointAt, curveStartPoint, curveTangentAt, cut, cut2D, cutAll, cutAllBisect, cutBlueprints, cutWithEvolution, cylinder, defaultScorer, dequeueTask, describe, deserializeDrawing, deserializeHistory, fromBREP as deserializeShape, downcast, draft, draw, drawCircle, drawEllipse, drawFaceOutline, drawParametricFunction, drawPointsInterpolation, drawPolysides, drawProjection, drawRectangle, drawRoundedRectangle, drawSingleCircle, drawSingleEllipse, drawText, drawingChamfer, drawingCut, drawingFillet, drawingFuse, drawingIntersect, drawingToSketchOnPlane, drill, edgeFinder, edgesOfFace, ellipse, ellipseArc, ellipsoid, enqueueTask, err, exportAssemblySTEP, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, extrude, extrudeAll, face, faceCenter, faceFinder, faceGeomType, faceOrientation, facesOfEdge, fill, filledFace, fillet, filletWithEvolution, findFacesByTag, findNode, findStep, fixSelfIntersection, fixShape, flatMap, flatten, flipFaceOrientation, flipOrientation, fontMetrics, fromBREP$1 as fromBREP, fromKernelDir, fromKernelPnt, fromKernelVec, fromNullable, fuse, fuse2D, fuseAll, fuseAllBisect, fuseBlueprints, fuseWithEvolution, gearGeometry, getActiveVoxelId, getBounds, getBounds2D, getCompSolids, getCurveType, getDisposalStats, getEdges, getFaceColor, getFaceOrigins, getFaceTags, getFaces, getFont, getHashCode, getShape as getHistoryShape, getKernel, getKernelCapabilities, getKernelTier, getNurbsCurveData, getNurbsSurfaceData, getOrientation, getOrientation2D, getPerformanceStats, getShapeColor, getShapeKind, getShells, getSingleFace, getSolids, getSurfaceType, getTagMetadata, getVertices, getVoxel, getWires, guidedSweep, heal, healFace, healSolid, healWire, helix, hull, importDXF, importGLB, importIGES, importOBJ, importSTEP, importSTL, importSVG, importSVGPathD, importThreeMF, init, initFromManifold, initFromOC, initVoxel, innerWires, interpolateCurve, intersect, intersect2D, intersectBlueprints, intersectWithEvolution, invalidateShapeCache, ioNs_exports as io, ioError, is2D, is3D, isChamferRadius, isClosedWire, isCompSolid, isCompound, isDisposeRequest, isEdge, isEmpty, isEqualShape, isErr, isErrorResponse, isFace, isFilletRadius, isInitRequest, isInside2D, isLive, isManifoldShell, isNumber, isOk, isOperationRequest, isOrientedFace, isPlanarFace, isPlanarWire, isProjectionPlane, isEmpty$1 as isQueueEmpty, isSameShape, isShape1D, isShape3D, isShell, isSolid, isSuccessResponse, isValid, isValidSolid, isVertex, isWire, iterCompSolids, iterEdges, iterFaces, iterShells, iterSolids, iterTopo, iterVertices, iterWires, kernelCall, kernelCallRaw, kernelCallScoped, kernelError, latticeInfill, latticeInfillShape, line, linearPattern, loadFont, loft, loftAll, makeBaseBox, makeExternalGear, makeInternalGear, makePlane, makePlanetaryGear, makeProjectedEdges, manifoldShell, map, mapBoth, mapErr, match, measureArea, measureCurvatureAt, measureCurvatureAtMid, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps, measurement_exports as measurement, mesh, meshEdges, meshMultiLOD, minkowski, mirror, mirror2D, mirrorDrawing, mirrorJoin, modifiers_exports as modifiers, modifyStep, moduleInitError, multiSectionSweep, normalAt, offset, offsetFace, offsetMesh, offsetShape, offsetWire2D, ok, or, orElse, organiseBlueprints, orientedFace, outerWire, patterns_exports as patterns, pendingCount, pipeline, pivotPlane, planarFace, planarWire, planetPlacements, pocket, pointOnSurface, pointsInside, polygon, polyhedron, polysideInnerRadius, polysidesBlueprint, positionOnCurve, prewarm, primitives_exports as primitives, projectEdges, projectPointOnFace, query_exports as query, queryError, rectangularPattern, registerHandler, registerKernel, registerKernelTier, registerOperation, registerShape, registerVoxel, rejectAll, removeChild, removeHolesFromFace, repairMesh, replayFrom, replayHistory, resetDisposalStats, resetPerformanceStats, resize, resolve, resolve3D, resolveDirection, resolvePlane, resolveRef, reverseCurve, revolve, roof, rotate, rotate2D, rotateDrawing, roundedRectangleBlueprint, scale, scale2D, scaleDrawing, section, sectionToFace, serializeHistory, setShapeOrigin, setTagMetadata, sewShells, shape, shapeToMeshInput, shapeType, sharedEdges, shell, shellMesh, shellShape, shellWithEvolution, simplify, sketchCircle, sketchEllipse, sketchExtrude, sketchFace, sketchFaceOffset, sketchHelix, sketchLoft, sketchOnFace2D, sketchOnPlane2D, sketchParametricFunction, sketchPolysides, sketchRectangle, sketchRevolve, sketchRoundedRectangle, sketchSweep, sketchText, sketchWires, sketcherStateError, slice, solid, solidFromShell, solveAssembly, sphere, split, stepCount, stepsFrom, stretch2D, subFace, supportExtrude, supportsConstraintSketch, supportsProjection, surfaceFromGrid, surfaceFromImage, sweep, tagFaces, tangentArc, tap, tapErr, textBlueprints, textMetrics, thicken, threePointArc, toBREP, toBufferGeometryData, toGroupedBufferGeometryData, toKernelVec, toLODGeometryData, toLineGeometryData, toSVGPathD, toVec2, toVec3, torus, tpmsLattice, transformCopy, transforms_exports as transforms, translate, translate2D, translateDrawing, translatePlane, tryCatch, tryCatchAsync, twistExtrude, typeCastError, undoLast, unsupportedError, unwrap, unwrapErr, unwrapOr, unwrapOrElse, updateNode, updateRoles, uvBounds, uvCoordinates, validSolid, validatePlanetary, validationError, variableFillet, vecAdd, vecAngle, vecCross, vecDistance, vecDot, vecEquals, vecIsZero, vecLength, vecLengthSq, vecNegate, vecNormalize, vecProjectToPlane, vecRepr, vecRotate, vecScale, vecSub, vertex, vertexFinder, vertexPosition, verticesOfEdge, voxelBoolean, voxelBooleanShapes, walkAssembly, windingNumbers, wire, wireFinder, wireLoop, wiresOfFace, withKernel, withKernelDir, withKernelPnt, withKernelVec, withQuality, withScope, withScopeResult, withScopeResultAsync, withTier, zip as zipResults };
+export { BaseSketcher2d, BlueprintSketcher, BrepBugError, BrepErrorCode, BrepWrapperError, BrepkitAdapter, CompoundSketch, DEFAULT_CAPABILITIES, DEG2RAD, DisposalScope, EXACT_BREP_CAPABILITIES, FaceSketcher, HASH_CODE_MAX, OK, OcctWasmAdapter, RAD2DEG, Sketch, Sketcher, Sketches, addChild, addHoles, addMate, addStep, adjacentFaces, all, andThen, applyGlue, applyMatrix, approximateCurve, as2D, as3D, asTopo, assignRoles, autoHeal, bezier, blueprintToDXF, booleanPipeline, booleans_exports as booleans, boss, box, bsplineApprox, bug, cameraFromPlane, cameraLookAt, captureHint, cast, castShape, castShape3D, chamfer, chamferDistAngle as chamferDistAngleShape, chamferWithEvolution, checkAllInterferences, checkBoolean, checkInterference, circle, circularPattern, classifyPointOnFace, clearMeshCache, clone, closedWire, collect, collectShapes, colorFaces, colorShape, complexExtrude, composeTransforms, compound, compoundSketchExtrude, compoundSketchFace, compoundSketchLoft, compoundSketchRevolve, computationError, computeStraightSkeleton, cone, construction_exports as construction, convexHull, cornerFinder, countNodes, createAssembly, createAssemblyNode, createBlueprint, createCamera, createCompound, createCompoundBlueprint, createDistanceQuery, createEdge, createFace, createHandle, createHistory, createKernelHandle, createMeshCache, createNamedPlane, createOperationRegistry, createPlane, createRef, createRegistry, createShell, createSolid, createTaskQueue, createVertex, createWire, createWorkerClient, createWorkerHandler, csg_exports as csg, currentQuality, curve2dBoundingBox, curve2dDistanceFrom, curve2dFirstPoint, curve2dIsOnCurve, curve2dLastPoint, curve2dParameter, curve2dSplitAt, curve2dTangentAt, curveEndPoint, curveIsClosed, curveIsPeriodic, curveLength, curvePeriod, curvePointAt, curveStartPoint, curveTangentAt, cut, cut2D, cutAll, cutAllBisect, cutBlueprints, cutWithEvolution, cylinder, defaultScorer, dequeueTask, describe, deserializeDrawing, deserializeHistory, fromBREP as deserializeShape, downcast, draft, draw, drawCircle, drawEllipse, drawFaceOutline, drawParametricFunction, drawPointsInterpolation, drawPolysides, drawProjection, drawRectangle, drawRoundedRectangle, drawSingleCircle, drawSingleEllipse, drawText, drawingChamfer, drawingCut, drawingFillet, drawingFuse, drawingIntersect, drawingToSketchOnPlane, drill, edgeFinder, edgesOfFace, ellipse, ellipseArc, ellipsoid, enqueueTask, err, exportAssemblySTEP, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, extrude, extrudeAll, face, faceCenter, faceFinder, faceGeomType, faceOrientation, facesOfEdge, fieldBoolean, fieldContour, fieldOffset, fieldReinit, fieldShell, fill, filledFace, fillet, filletWithEvolution, findFacesByTag, findNode, findStep, fixSelfIntersection, fixShape, flatMap, flatten, flipFaceOrientation, flipOrientation, fontMetrics, fromBREP$1 as fromBREP, fromKernelDir, fromKernelPnt, fromKernelVec, fromNullable, fuse, fuse2D, fuseAll, fuseAllBisect, fuseBlueprints, fuseWithEvolution, gearGeometry, getActiveVoxelId, getBounds, getBounds2D, getCompSolids, getCurveType, getDisposalStats, getEdges, getFaceColor, getFaceOrigins, getFaceTags, getFaces, getFont, getHashCode, getShape as getHistoryShape, getKernel, getKernelCapabilities, getKernelTier, getNurbsCurveData, getNurbsSurfaceData, getOrientation, getOrientation2D, getPerformanceStats, getShapeColor, getShapeKind, getShells, getSingleFace, getSolids, getSurfaceType, getTagMetadata, getVertices, getVoxel, getWires, guidedSweep, heal, healFace, healSolid, healWire, helix, hull, importDXF, importGLB, importIGES, importOBJ, importSTEP, importSTL, importSVG, importSVGPathD, importThreeMF, init, initFromManifold, initFromOC, initVoxel, innerWires, interpolateCurve, intersect, intersect2D, intersectBlueprints, intersectWithEvolution, invalidateShapeCache, ioNs_exports as io, ioError, is2D, is3D, isChamferRadius, isClosedWire, isCompSolid, isCompound, isDisposeRequest, isEdge, isEmpty, isEqualShape, isErr, isErrorResponse, isFace, isFilletRadius, isInitRequest, isInside2D, isLive, isManifoldShell, isNumber, isOk, isOperationRequest, isOrientedFace, isPlanarFace, isPlanarWire, isProjectionPlane, isEmpty$1 as isQueueEmpty, isSameShape, isShape1D, isShape3D, isShell, isSolid, isSuccessResponse, isValid, isValidSolid, isVertex, isWire, iterCompSolids, iterEdges, iterFaces, iterShells, iterSolids, iterTopo, iterVertices, iterWires, kernelCall, kernelCallRaw, kernelCallScoped, kernelError, latticeInfill, latticeInfillShape, line, linearPattern, loadFont, loft, loftAll, makeBaseBox, makeExternalGear, makeInternalGear, makePlane, makePlanetaryGear, makeProjectedEdges, manifoldShell, map, mapBoth, mapErr, match, measureArea, measureCurvatureAt, measureCurvatureAtMid, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps, measurement_exports as measurement, mesh, meshEdges, meshMultiLOD, minkowski, mirror, mirror2D, mirrorDrawing, mirrorJoin, modifiers_exports as modifiers, modifyStep, moduleInitError, multiSectionSweep, normalAt, offset, offsetFace, offsetMesh, offsetShape, offsetWire2D, ok, or, orElse, organiseBlueprints, orientedFace, outerWire, patterns_exports as patterns, pendingCount, pipeline, pivotPlane, planarFace, planarWire, planetPlacements, pocket, pointOnSurface, pointsInside, polygon, polyhedron, polysideInnerRadius, polysidesBlueprint, positionOnCurve, prewarm, primitives_exports as primitives, projectEdges, projectPointOnFace, query_exports as query, queryError, rectangularPattern, registerHandler, registerKernel, registerKernelTier, registerOperation, registerShape, registerVoxel, rejectAll, removeChild, removeHolesFromFace, repairMesh, replayFrom, replayHistory, resetDisposalStats, resetPerformanceStats, resize, resolve, resolve3D, resolveDirection, resolvePlane, resolveRef, reverseCurve, revolve, roof, rotate, rotate2D, rotateDrawing, roundedRectangleBlueprint, scale, scale2D, scaleDrawing, section, sectionToFace, serializeHistory, setShapeOrigin, setTagMetadata, sewShells, shape, shapeToMeshInput, shapeType, sharedEdges, shell, shellMesh, shellShape, shellWithEvolution, simplify, sketchCircle, sketchEllipse, sketchExtrude, sketchFace, sketchFaceOffset, sketchHelix, sketchLoft, sketchOnFace2D, sketchOnPlane2D, sketchParametricFunction, sketchPolysides, sketchRectangle, sketchRevolve, sketchRoundedRectangle, sketchSweep, sketchText, sketchWires, sketcherStateError, slice, solid, solidFromShell, solveAssembly, sphere, split, stepCount, stepsFrom, stretch2D, subFace, supportExtrude, supportsConstraintSketch, supportsProjection, surfaceFromGrid, surfaceFromImage, sweep, tagFaces, tangentArc, tap, tapErr, textBlueprints, textMetrics, thicken, threePointArc, toBREP, toBufferGeometryData, toGroupedBufferGeometryData, toKernelVec, toLODGeometryData, toLineGeometryData, toSVGPathD, toVec2, toVec3, torus, tpmsLattice, transformCopy, transforms_exports as transforms, translate, translate2D, translateDrawing, translatePlane, tryCatch, tryCatchAsync, twistExtrude, typeCastError, undoLast, unsupportedError, unwrap, unwrapErr, unwrapOr, unwrapOrElse, updateNode, updateRoles, uvBounds, uvCoordinates, validSolid, validatePlanetary, validationError, variableFillet, vecAdd, vecAngle, vecCross, vecDistance, vecDot, vecEquals, vecIsZero, vecLength, vecLengthSq, vecNegate, vecNormalize, vecProjectToPlane, vecRepr, vecRotate, vecScale, vecSub, vertex, vertexFinder, vertexPosition, verticesOfEdge, voxelBoolean, voxelBooleanField, voxelBooleanFieldShapes, voxelBooleanShapes, voxelField, voxelFieldFromShape, walkAssembly, windingNumbers, wire, wireFinder, wireLoop, wiresOfFace, withKernel, withKernelDir, withKernelPnt, withKernelVec, withQuality, withScope, withScopeResult, withScopeResultAsync, withTier, zip as zipResults };

package/dist/index.d.ts

@@ -38,8 +38,8 @@ export { exportDXF, blueprintToDXF, type DXFEntity, type DXFExportOptions, } fro
 export { exportThreeMF, type ThreeMFExportOptions, type ThreeMFMaterial, } from './io/threemfExportFns.js';
 export { importSVGPathD, importSVG, type SVGImportOptions } from './io/svgImportFns.js';
 export { exportSTEPConfigured, type StepExportOptions, type StepExportPart, } from './io/stepConfigFns.js';
-export { initVoxel, registerVoxel, getVoxel, getActiveVoxelId, windingNumbers, pointsInside, repairMesh, offsetMesh, shellMesh, voxelBoolean, offsetShape, shellShape, voxelBooleanShapes, shapeToMeshInput, } from './voxel/index.js';
-export type { VoxelEngine, VoxelMeshInput, VoxelRepairResult, RepairOptions, VoxelOpOptions, } from './voxel/index.js';
+export { initVoxel, registerVoxel, getVoxel, getActiveVoxelId, windingNumbers, pointsInside, repairMesh, offsetMesh, shellMesh, voxelBoolean, offsetShape, shellShape, voxelBooleanShapes, voxelField, voxelBooleanField, fieldBoolean, fieldOffset, fieldShell, fieldReinit, fieldContour, voxelFieldFromShape, voxelBooleanFieldShapes, shapeToMeshInput, } from './voxel/index.js';
+export type { VoxelEngine, VoxelMeshInput, VoxelRepairResult, RepairOptions, VoxelOpOptions, VoxelFieldHandle, VoxelFieldOptions, VoxelBooleanOp, } from './voxel/index.js';
 export { latticeInfill, latticeInfillShape, tpmsLattice } from './lattice/index.js';
 export type { LatticeType, LatticeOptions, LatticeBounds } from './lattice/index.js';
 export { default as Sketcher } from './sketching/sketcher.js';

package/dist/voxel/engine.d.ts

@@ -23,9 +23,52 @@ export interface VoxelEngine {
     shell_mesh(verts: Float32Array, tris: Uint32Array, thickness: number, resolution: number, padding: number): VoxelRepairResult;
     /** Voxel CSG of two meshes (op: 0=union, 1=intersection, 2=difference A−B). */
     voxel_boolean(verts_a: Float32Array, tris_a: Uint32Array, verts_b: Float32Array, tris_b: Uint32Array, op: number, resolution: number, padding: number): VoxelRepairResult;
+    /**
+     * Persistent dense voxel-field class, for same-grid op chains: voxelize a mesh
+     * once, then boolean/offset/shell/reinit in place, contour once. Structurally
+     * satisfied by the generated `VoxelField` wasm-bindgen class.
+     */
+    VoxelField: WasmVoxelFieldConstructor;
     /** Engine artifact version, for loader/artifact compatibility checks. */
     version(): string;
 }
+/**
+ * Constructor of the wasm `VoxelField` class. `new VoxelField(verts, tris, res,
+ * padding)` voxelizes a mesh into a persistent dense field. Throws (as a JS
+ * exception) on a non-dense grid or a grid over the voxel cap.
+ */
+export interface WasmVoxelFieldConstructor {
+    new (verts: Float32Array, tris: Uint32Array, resolution: number, padding: number): WasmVoxelField;
+    /**
+     * Boolean two meshes onto ONE co-registered dense field (union bbox → voxelize
+     * both onto a shared grid → combine), ready to chain. The correct path for
+     * "boolean then offset/shell" two independently-described meshes, where
+     * {@link WasmVoxelField.boolean} requires the operands to already share grid
+     * geometry. `op`: 0=union, 1=intersection, 2=difference A−B.
+     */
+    boolean_of(verts_a: Float32Array, tris_a: Uint32Array, verts_b: Float32Array, tris_b: Uint32Array, op: number, resolution: number, padding: number): WasmVoxelField;
+}
+/**
+ * A persistent dense voxel field. All ops MUTATE IN PLACE (return void), so the
+ * same grid persists across a chain. `contour()` reads the zero set into a fresh
+ * {@link VoxelRepairResult}; `free()` releases the backing WASM grid (mandatory).
+ * Structurally satisfied by the generated `VoxelField` wasm-bindgen class.
+ */
+export interface WasmVoxelField {
+    /** CSG-combine in place (op: 0=union, 1=intersection, 2=difference self−B). */
+    boolean(other: WasmVoxelField, op: number): void;
+    /** Offset the surface in place (>0 outward, <0 inward); auto-reinits if dirty. */
+    offset(distance: number): void;
+    /** Hollow into an inward shell in place (thickness > 0); auto-reinits if dirty. */
+    shell(thickness: number): void;
+    /** Reinitialize φ to a true SDF (|∇φ|=1) while preserving the zero set. */
+    reinit(): void;
+    /** Surface-Nets contour the current field to a triangle mesh. */
+    contour(): VoxelRepairResult;
+    /** Release the backing WASM grid allocation (wasm-bindgen lifecycle). */
+    free(): void;
+    [Symbol.dispose](): void;
+}
 /**
  * The repaired-mesh handle the wasm `repair_mesh` returns. Flat xyz
  * `positions`/`normals` (length 3·V) and a triangle-list `indices` (3 per tri),

package/dist/voxel/fieldFns.d.ts

@@ -0,0 +1,120 @@
+import { Result } from '../core/result.js';
+import { KernelMeshResult } from '../kernel/types.js';
+import { AnyShape, Dimension } from '../core/shapeTypes.js';
+import { VoxelMeshInput } from './signFns.js';
+import { WasmVoxelField } from './engine.js';
+/** Field tuning. `resolution` sizes the longest bbox axis in voxels; `padding`
+ *  is the air-margin ring (>= 1) Surface Nets needs AND the headroom an outward
+ *  offset has before it clips at the grid boundary (the grid is fixed at
+ *  voxelize time — size both for the intended maximum offset). */
+export interface VoxelFieldOptions {
+    resolution?: number;
+    padding?: number;
+}
+/** Boolean op selector for {@link fieldBoolean} / {@link VoxelFieldHandle.boolean}. */
+export type VoxelBooleanOp = 'union' | 'intersection' | 'difference';
+/**
+ * A persistent, disposable voxel field. Carries the wrapped WASM field as
+ * `value` and a fluent op-chain (`.boolean().offset().shell().contour()`) that
+ * throws on the rare WASM error (mirroring the `shape()` facade's
+ * throw-on-`Err` convention), so a `using`-scoped chain reads cleanly:
+ *
+ * ```ts
+ * using field = voxelField(meshA).unwrap();
+ * using other = voxelField(meshB).unwrap();
+ * const mesh = field.boolean(other, 'union').offset(2).contour();
+ * ```
+ *
+ * Dispose is mandatory (FinalizationRegistry is an unreliable safety net): use
+ * `using`, or call `[Symbol.dispose]()` explicitly, to free the WASM grid.
+ */
+export interface VoxelFieldHandle {
+    /** The wrapped WASM field. Throws if the handle has been disposed. */
+    readonly value: WasmVoxelField;
+    /** Whether the backing WASM grid has been freed. */
+    readonly disposed: boolean;
+    [Symbol.dispose](): void;
+    /** CSG-combine with `other` in place (marks the field for lazy reinit). */
+    boolean(other: VoxelFieldHandle, op: VoxelBooleanOp): VoxelFieldHandle;
+    /** Offset the surface in place (>0 outward, <0 inward); auto-reinits if dirty. */
+    offset(distance: number): VoxelFieldHandle;
+    /** Hollow into an inward shell in place (thickness > 0); auto-reinits if dirty. */
+    shell(thickness: number): VoxelFieldHandle;
+    /** Reinitialize φ to a true SDF while preserving the zero set. */
+    reinit(): VoxelFieldHandle;
+    /** Surface-Nets contour the current field to a mesh (the field stays alive). */
+    contour(): KernelMeshResult;
+}
+/**
+ * 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.
+ */
+export declare function voxelField(mesh: VoxelMeshInput, opts?: VoxelFieldOptions, id?: string): Result<VoxelFieldHandle>;
+/**
+ * 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).
+ */
+export declare function voxelBooleanField(a: VoxelMeshInput, b: VoxelMeshInput, op: VoxelBooleanOp, opts?: VoxelFieldOptions, id?: string): Result<VoxelFieldHandle>;
+/**
+ * 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}.
+ */
+export declare function fieldBoolean(handle: VoxelFieldHandle, other: VoxelFieldHandle, op: VoxelBooleanOp): Result<VoxelFieldHandle>;
+/**
+ * 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.
+ */
+export declare function fieldOffset(handle: VoxelFieldHandle, distance: number): Result<VoxelFieldHandle>;
+/**
+ * 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).
+ */
+export declare function fieldShell(handle: VoxelFieldHandle, thickness: number): Result<VoxelFieldHandle>;
+/**
+ * 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.
+ */
+export declare function fieldReinit(handle: VoxelFieldHandle): Result<VoxelFieldHandle>;
+/**
+ * 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`.
+ */
+export declare function fieldContour(handle: VoxelFieldHandle): Result<KernelMeshResult>;
+/**
+ * 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`.
+ */
+export declare function voxelFieldFromShape(shape: AnyShape<Dimension>, opts?: VoxelFieldOptions, id?: string): Result<VoxelFieldHandle>;
+/**
+ * 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`.
+ */
+export declare function voxelBooleanFieldShapes(a: AnyShape<Dimension>, b: AnyShape<Dimension>, op: VoxelBooleanOp, opts?: VoxelFieldOptions, id?: string): Result<VoxelFieldHandle>;

package/dist/voxel/index.d.ts

@@ -9,8 +9,10 @@ export type { VoxelEngine, VoxelRepairResult } from './engine.js';
 export type { VoxelMeshInput } from './signFns.js';
 export type { RepairOptions } from './repairFns.js';
 export type { VoxelOpOptions } from './meshOpsFns.js';
+export type { VoxelFieldHandle, VoxelFieldOptions, VoxelBooleanOp } from './fieldFns.js';
 export { registerVoxel, getVoxel, getActiveVoxelId, initVoxel } from './registry.js';
 export { windingNumbers, pointsInside } from './signFns.js';
 export { repairMesh } from './repairFns.js';
 export { offsetMesh, shellMesh, voxelBoolean, offsetShape, shellShape, voxelBooleanShapes, } from './meshOpsFns.js';
+export { voxelField, voxelBooleanField, fieldBoolean, fieldOffset, fieldShell, fieldReinit, fieldContour, voxelFieldFromShape, voxelBooleanFieldShapes, } from './fieldFns.js';
 export { shapeToMeshInput } from './shapeMesh.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs",
-  "version": "18.66.2",
+  "version": "18.67.0",
   "description": "Web CAD library with pluggable geometry kernel",
   "keywords": [
     "cad",