brepjs 18.66.2 → 18.68.0

package/dist/brepjs.cjs

@@ -182,7 +182,7 @@ function validateInputs(mesh, queries) {
 	return null;
 }
 /** Resolve a registered voxel engine, mapping an unregistered id to an error. */
-function resolveEngine(id) {
+function resolveEngine$1(id) {
 	try {
 		return require_errors.ok(getVoxel(id));
 	} catch (cause) {
@@ -199,7 +199,7 @@ function resolveEngine(id) {
 function windingNumbers(mesh, queries, id) {
 	const invalid = validateInputs(mesh, queries);
 	if (invalid) return require_errors.err(invalid);
-	const engine = resolveEngine(id);
+	const engine = resolveEngine$1(id);
 	if (require_errors.isErr(engine)) return engine;
 	return require_errors.ok(engine.value.winding_numbers(mesh.vertices, mesh.triangles, queries));
 }
@@ -211,15 +211,15 @@ function windingNumbers(mesh, queries, id) {
 function pointsInside(mesh, queries, id) {
 	const invalid = validateInputs(mesh, queries);
 	if (invalid) return require_errors.err(invalid);
-	const engine = resolveEngine(id);
+	const engine = resolveEngine$1(id);
 	if (require_errors.isErr(engine)) return engine;
 	const flags = engine.value.points_inside(mesh.vertices, mesh.triangles, queries);
 	return require_errors.ok(Array.from(flags, (flag) => flag === 1));
 }
 //#endregion
 //#region src/voxel/repairFns.ts
-var DEFAULT_RESOLUTION$2 = 48;
-var DEFAULT_PADDING$2 = 2;
+var DEFAULT_RESOLUTION$4 = 48;
+var DEFAULT_PADDING$4 = 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$4;
+	const padding = opts?.padding ?? DEFAULT_PADDING$4;
 	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);
+	const engine = resolveEngine$1(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$3 = 48;
+var DEFAULT_PADDING$3 = 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$2(opts) {
+	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."));
 	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$2(opts);
 	if (require_errors.isErr(params)) return params;
-	const engine = resolveEngine(id);
+	const engine = resolveEngine$1(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,9 +359,9 @@ 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$2(opts);
 	if (require_errors.isErr(params)) return params;
-	const engine = resolveEngine(id);
+	const engine = resolveEngine$1(id);
 	if (require_errors.isErr(engine)) return engine;
 	try {
 		try {
@@ -390,10 +390,10 @@ 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$2(opts);
 	if (require_errors.isErr(params)) return params;
-	const engine = resolveEngine(id);
+	const engine = resolveEngine$1(id);
 	if (require_errors.isErr(engine)) return engine;
 	try {
 		try {
@@ -441,6 +441,423 @@ 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$2 = 48;
+var DEFAULT_PADDING$2 = 2;
+var BOOLEAN_OP_CODES = {
+	union: 0,
+	intersection: 1,
+	difference: 2
+};
+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({
+		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 makeFieldHandle(raw) {
+	return makeHandle(raw);
+}
+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$1(opts);
+	if (require_errors.isErr(params)) return params;
+	const engine = resolveEngine$1(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$1(opts);
+	if (require_errors.isErr(params)) return params;
+	const engine = resolveEngine$1(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/implicit/sdfFns.ts
+var DEFAULT_RESOLUTION$1 = 48;
+var DEFAULT_PADDING$1 = 2;
+function resolveEngine(id) {
+	try {
+		return require_errors.ok(getVoxel(id));
+	} catch (cause) {
+		return require_errors.err(require_errors.moduleInitError("VOXEL_NOT_INITIALIZED", cause instanceof Error ? cause.message : "voxel engine not initialized", cause));
+	}
+}
+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("SDF_INVALID_RESOLUTION", "resolution must be an integer >= 1."));
+	if (!Number.isInteger(padding) || padding < 1) return require_errors.err(require_errors.validationError("SDF_INVALID_PADDING", "padding must be an integer >= 1."));
+	return require_errors.ok({
+		resolution,
+		padding
+	});
+}
+function sdfDeletable(raw) {
+	return {
+		raw,
+		delete() {
+			raw.free();
+		}
+	};
+}
+function makeSdfHandle(raw) {
+	const inner = require_shapeTypes.createKernelHandle(sdfDeletable(raw));
+	return {
+		get value() {
+			return inner.value.raw;
+		},
+		get disposed() {
+			return inner.disposed;
+		},
+		[Symbol.dispose]() {
+			inner[Symbol.dispose]();
+		},
+		union(other) {
+			return makeSdfHandle(this.value.union(other.value));
+		},
+		intersection(other) {
+			return makeSdfHandle(this.value.intersection(other.value));
+		},
+		difference(other) {
+			return makeSdfHandle(this.value.difference(other.value));
+		},
+		smoothUnion(other, k) {
+			return makeSdfHandle(this.value.smooth_union(other.value, k));
+		},
+		smoothIntersection(other, k) {
+			return makeSdfHandle(this.value.smooth_intersection(other.value, k));
+		},
+		smoothDifference(other, k) {
+			return makeSdfHandle(this.value.smooth_difference(other.value, k));
+		},
+		offset(distance) {
+			return makeSdfHandle(this.value.offset(distance));
+		},
+		round(radius) {
+			return makeSdfHandle(this.value.round(radius));
+		},
+		shell(thickness) {
+			return makeSdfHandle(this.value.shell(thickness));
+		},
+		onion(thickness) {
+			return makeSdfHandle(this.value.onion(thickness));
+		},
+		translate(x, y, z) {
+			return makeSdfHandle(this.value.translate(x, y, z));
+		},
+		rotate(ax, ay, az, angle) {
+			return makeSdfHandle(this.value.rotate(ax, ay, az, angle));
+		},
+		scale(s) {
+			return makeSdfHandle(this.value.scale(s));
+		},
+		rasterize(opts) {
+			return rasterizeField(this.value, opts);
+		},
+		rasterizeIn(bounds, opts) {
+			return rasterizeFieldIn(this.value, bounds, opts);
+		}
+	};
+}
+function rasterizeField(sdf, opts) {
+	const params = resolveGridParams(opts);
+	if (require_errors.isErr(params)) return params;
+	try {
+		return require_errors.ok(makeFieldHandle(sdf.rasterize(params.value.resolution, params.value.padding)));
+	} catch (cause) {
+		return rasterizeError(cause);
+	}
+}
+function rasterizeFieldIn(sdf, bounds, opts) {
+	const params = resolveGridParams(opts);
+	if (require_errors.isErr(params)) return params;
+	const invalid = validateBounds(bounds);
+	if (invalid) return require_errors.err(invalid);
+	try {
+		return require_errors.ok(makeFieldHandle(sdf.rasterize_in(bounds.min[0], bounds.min[1], bounds.min[2], bounds.max[0], bounds.max[1], bounds.max[2], params.value.resolution, params.value.padding)));
+	} catch (cause) {
+		return rasterizeError(cause);
+	}
+}
+function rasterizeError(cause) {
+	return require_errors.err(require_errors.computationError("SDF_RASTERIZE_FAILED", cause instanceof Error ? cause.message : "SDF rasterization failed (grid too large?).", cause));
+}
+function validateBounds(bounds) {
+	if (![...bounds.min, ...bounds.max].every((v) => Number.isFinite(v))) return require_errors.validationError("SDF_INVALID_BOUNDS", "bounds must be finite numbers.");
+	for (let axis = 0; axis < 3; axis++) if (bounds.max[axis] <= bounds.min[axis]) return require_errors.validationError("SDF_INVALID_BOUNDS", "bounds max must exceed min on every axis.");
+	return null;
+}
+function build(make, id) {
+	const engine = resolveEngine(id);
+	if (require_errors.isErr(engine)) return engine;
+	try {
+		return require_errors.ok(makeSdfHandle(make(engine.value)));
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("SDF_BUILD_FAILED", cause instanceof Error ? cause.message : "SDF primitive construction failed.", cause));
+	}
+}
+/** A sphere of radius `r`, centered at the origin. */
+function sphere(r, id) {
+	return build((e) => e.Sdf.sphere(r), id);
+}
+/** An axis-aligned box of half-extents `(hx, hy, hz)`, centered at the origin. */
+function box$1(hx, hy, hz, id) {
+	return build((e) => e.Sdf.box_(hx, hy, hz), id);
+}
+/** A box with rounded edges of radius `r`. */
+function roundedBox(hx, hy, hz, r, id) {
+	return build((e) => e.Sdf.rounded_box(hx, hy, hz, r), id);
+}
+/** A capped cylinder, axis +Z, radius `r`, total height `h`, centered at origin. */
+function cylinder$1(r, h, id) {
+	return build((e) => e.Sdf.cylinder(r, h), id);
+}
+/** A capped cone centered at the origin: base radius `r` at z = −h/2 tapering to an apex at z = +h/2. */
+function cone$1(r, h, id) {
+	return build((e) => e.Sdf.cone(r, h), id);
+}
+/** A capsule: a line segment `a`→`b` of radius `r`. */
+function capsule(a, b, r, id) {
+	return build((e) => e.Sdf.capsule(a[0], a[1], a[2], b[0], b[1], b[2], r), id);
+}
+/** A torus in the XY plane (axis +Z): a `minor`-radius tube on a `major` circle. */
+function torus(major, minor, id) {
+	return build((e) => e.Sdf.torus(major, minor), id);
+}
+/** A half-space: the plane through `h·n` with outward normal `n` (normalized). */
+function plane(n, h, id) {
+	return build((e) => e.Sdf.plane(n[0], n[1], n[2], h), id);
+}
+//#endregion
 //#region src/lattice/latticeFns.ts
 var LATTICE_TAGS = {
 	gyroid: 0,
@@ -494,7 +911,7 @@ function latticeInfill(mesh, opts, id) {
 	if (mesh.vertices.length === 0 || mesh.triangles.length === 0) return require_errors.err(require_errors.validationError("LATTICE_EMPTY_MESH", "latticeInfill requires a non-empty triangle mesh."));
 	const resolved = validateOptions(opts);
 	if (require_errors.isErr(resolved)) return resolved;
-	const engine = resolveEngine(id);
+	const engine = resolveEngine$1(id);
 	if (require_errors.isErr(engine)) return engine;
 	const { tag, period, thickness, resolution, padding } = resolved.value;
 	try {
@@ -535,7 +952,7 @@ function tpmsLattice(bounds, opts, id) {
 	}
 	const resolved = validateOptions(opts);
 	if (require_errors.isErr(resolved)) return resolved;
-	const engine = resolveEngine(id);
+	const engine = resolveEngine$1(id);
 	if (require_errors.isErr(engine)) return engine;
 	const { tag, period, thickness, resolution, padding } = resolved.value;
 	const [minX, minY, minZ] = bounds.min;
@@ -4204,7 +4621,7 @@ function depsOf(...sources) {
 	}
 	return acc.size === 0 ? EMPTY_DEPS : acc;
 }
-function box$1(x, y, z) {
+function box$2(x, y, z) {
 	const xe = asScalarExpr(x);
 	const ye = asScalarExpr(y);
 	const ze = asScalarExpr(z);
@@ -4219,7 +4636,7 @@ function box$1(x, y, z) {
 		freeParams: depsOf(xe, ye, ze)
 	};
 }
-function sphere$1(radius) {
+function sphere$2(radius) {
 	const re = asScalarExpr(radius);
 	return {
 		kind: "Sphere",
@@ -4228,7 +4645,7 @@ function sphere$1(radius) {
 		freeParams: re.freeParams
 	};
 }
-function cylinder$1(radius, height) {
+function cylinder$2(radius, height) {
 	const re = asScalarExpr(radius);
 	const he = asScalarExpr(height);
 	return {
@@ -4239,7 +4656,7 @@ function cylinder$1(radius, height) {
 		freeParams: depsOf(re, he)
 	};
 }
-function cone$1(radius1, radius2, height) {
+function cone$2(radius1, radius2, height) {
 	const r1 = asScalarExpr(radius1);
 	const r2 = asScalarExpr(radius2);
 	const he = asScalarExpr(height);
@@ -4254,7 +4671,7 @@ function cone$1(radius1, radius2, height) {
 		freeParams: depsOf(r1, r2, he)
 	};
 }
-function torus$1(majorRadius, minorRadius) {
+function torus$2(majorRadius, minorRadius) {
 	const ma = asScalarExpr(majorRadius);
 	const mi = asScalarExpr(minorRadius);
 	return {
@@ -5159,7 +5576,7 @@ function readSingleExpr(j, key, build) {
 function readPrimitive(kind, j) {
 	switch (kind) {
 		case "Box": return readBox(j);
-		case "Sphere": return readSingleExpr(j, "radius", sphere$1);
+		case "Sphere": return readSingleExpr(j, "radius", sphere$2);
 		case "Cylinder": return readCylinder(j);
 		case "Cone": return readCone(j);
 		case "Torus": return readTorus(j);
@@ -5178,14 +5595,14 @@ function readBox(j) {
 	if (!y.ok) return y;
 	const z = readExpr(j["z"]);
 	if (!z.ok) return z;
-	return require_errors.ok(box$1(x.value, y.value, z.value));
+	return require_errors.ok(box$2(x.value, y.value, z.value));
 }
 function readCylinder(j) {
 	const r = readExpr(j["radius"]);
 	if (!r.ok) return r;
 	const h = readExpr(j["height"]);
 	if (!h.ok) return h;
-	return require_errors.ok(cylinder$1(r.value, h.value));
+	return require_errors.ok(cylinder$2(r.value, h.value));
 }
 function readCone(j) {
 	const r1 = readExpr(j["radius1"]);
@@ -5194,14 +5611,14 @@ function readCone(j) {
 	if (!r2.ok) return r2;
 	const h = readExpr(j["height"]);
 	if (!h.ok) return h;
-	return require_errors.ok(cone$1(r1.value, r2.value, h.value));
+	return require_errors.ok(cone$2(r1.value, r2.value, h.value));
 }
 function readTorus(j) {
 	const ma = readExpr(j["majorRadius"]);
 	if (!ma.ok) return ma;
 	const mi = readExpr(j["minorRadius"]);
 	if (!mi.ok) return mi;
-	return require_errors.ok(torus$1(ma.value, mi.value));
+	return require_errors.ok(torus$2(ma.value, mi.value));
 }
 function readPolygon(j) {
 	const pts = j["points"];
@@ -5377,11 +5794,11 @@ function foldBuildVec(dim, comps) {
 }
 function optimizeNode(n) {
 	switch (n.kind) {
-		case "Box": return box$1(foldExpr(n.x), foldExpr(n.y), foldExpr(n.z));
-		case "Sphere": return sphere$1(foldExpr(n.radius));
-		case "Cylinder": return cylinder$1(foldExpr(n.radius), foldExpr(n.height));
-		case "Cone": return cone$1(foldExpr(n.radius1), foldExpr(n.radius2), foldExpr(n.height));
-		case "Torus": return torus$1(foldExpr(n.majorRadius), foldExpr(n.minorRadius));
+		case "Box": return box$2(foldExpr(n.x), foldExpr(n.y), foldExpr(n.z));
+		case "Sphere": return sphere$2(foldExpr(n.radius));
+		case "Cylinder": return cylinder$2(foldExpr(n.radius), foldExpr(n.height));
+		case "Cone": return cone$2(foldExpr(n.radius1), foldExpr(n.radius2), foldExpr(n.height));
+		case "Torus": return torus$2(foldExpr(n.majorRadius), foldExpr(n.minorRadius));
 		case "Polygon": return polygon$1(n.points.map(foldExpr));
 		case "Circle": return circle$1(foldExpr(n.radius));
 		case "Line": return line$1(foldExpr(n.from), foldExpr(n.to));
@@ -5539,15 +5956,15 @@ var csg_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	asVec2Expr: () => asVec2Expr,
 	asVec3Expr: () => asVec3Expr,
 	binOp: () => binOp,
-	box: () => box$1,
+	box: () => box$2,
 	buildVec: () => buildVec,
 	circle: () => circle$1,
 	component: () => component,
 	compound: () => compound$1,
-	cone: () => cone$1,
+	cone: () => cone$2,
 	cut: () => cut$1,
 	cutAll: () => cutAll$1,
-	cylinder: () => cylinder$1,
+	cylinder: () => cylinder$2,
 	emptyFace: () => emptyFace,
 	emptySolid: () => emptySolid,
 	emptyWire: () => emptyWire,
@@ -5569,9 +5986,9 @@ var csg_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	replaceNode: () => replaceNode,
 	rotate: () => rotate$1,
 	scale: () => scale$1,
-	sphere: () => sphere$1,
+	sphere: () => sphere$2,
 	toJSON: () => toJSON,
-	torus: () => torus$1,
+	torus: () => torus$2,
 	translate: () => translate$1,
 	unaryOp: () => unaryOp,
 	vec2Lit: () => vec2Lit,
@@ -5776,6 +6193,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;
@@ -6046,6 +6468,14 @@ exports.roundedRectangleBlueprint = require_boolean2D.roundedRectangleBlueprint;
 exports.scale = scale;
 exports.scale2D = require_blueprintFns.scale2D;
 exports.scaleDrawing = require_drawFns.scaleDrawing;
+exports.sdfBox = box$1;
+exports.sdfCapsule = capsule;
+exports.sdfCone = cone$1;
+exports.sdfCylinder = cylinder$1;
+exports.sdfPlane = plane;
+exports.sdfRoundedBox = roundedBox;
+exports.sdfSphere = sphere;
+exports.sdfTorus = torus;
 exports.section = section;
 exports.sectionToFace = sectionToFace;
 exports.serializeHistory = require_historyFns.serializeHistory;
@@ -6164,7 +6594,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;