brepjs 18.38.0 → 18.40.0

package/dist/brepjs.cjs

@@ -218,8 +218,8 @@ function pointsInside(mesh, queries, id) {
 }
 //#endregion
 //#region src/voxel/repairFns.ts
-var DEFAULT_RESOLUTION = 48;
-var DEFAULT_PADDING = 2;
+var DEFAULT_RESOLUTION$2 = 48;
+var DEFAULT_PADDING$2 = 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;
-	const padding = opts?.padding ?? DEFAULT_PADDING;
+	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."));
 	const engine = resolveEngine(id);
 	if (require_errors.isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$4 = require_shapeTypes._usingCtx();
-			const repaired = _usingCtx$4.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
+			var _usingCtx$6 = require_shapeTypes._usingCtx();
+			const repaired = _usingCtx$6.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
 			const vertexCount = repaired.positions.length / 3;
 			return require_errors.ok({
 				vertices: repaired.positions,
@@ -254,13 +254,303 @@ function repairMesh(mesh, opts, id) {
 					faceHash: 0
 				}]
 			});
+		} catch (_) {
+			_usingCtx$6.e = _;
+		} finally {
+			_usingCtx$6.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));
+	}
+}
+//#endregion
+//#region src/voxel/shapeMesh.ts
+var DEFAULT_DEFLECTION = .001;
+/**
+* Mesh a B-rep shape into the flat triangle-soup {@link VoxelMeshInput} the voxel
+* ops consume. Tessellates via the topology mesh API at `deflection` linear
+* tolerance and forwards its `{ vertices, triangles }` (already Float32Array /
+* Uint32Array). Meshing failures surface as an `err(...)` rather than a throw.
+*/
+function shapeToMeshInput(shape, deflection = DEFAULT_DEFLECTION) {
+	try {
+		const tessellated = require_meshFns.mesh(shape, { tolerance: deflection });
+		if (tessellated.vertices.length === 0 || tessellated.triangles.length === 0) return require_errors.err(require_errors.computationError("VOXEL_SHAPE_MESH_EMPTY", "shape tessellated to an empty triangle mesh."));
+		return require_errors.ok({
+			vertices: tessellated.vertices,
+			triangles: tessellated.triangles
+		});
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("VOXEL_SHAPE_MESH_FAILED", cause instanceof Error ? cause.message : "failed to mesh shape for voxel op.", cause));
+	}
+}
+//#endregion
+//#region src/voxel/meshOpsFns.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
+	});
+}
+function meshFromResult(result) {
+	if (result.positions.length === 0 || result.indices.length === 0) return require_errors.err(require_errors.computationError("VOXEL_DEGENERATE_RESULT", "the voxel operation produced an empty mesh (over-shrunk offset or disjoint operands?)."));
+	const vertexCount = result.positions.length / 3;
+	return require_errors.ok({
+		vertices: result.positions,
+		normals: result.normals,
+		triangles: result.indices,
+		uvs: new Float32Array(vertexCount * 2),
+		faceGroups: [{
+			start: 0,
+			count: result.indices.length / 3,
+			faceHash: 0
+		}]
+	});
+}
+/**
+* Offset a mesh by `distance` via a true-SDF iso-level shift: voxelize an
+* FWN-signed SDF, subtract `distance`, then Surface-Nets contour it back.
+*
+* `distance > 0` grows the surface outward, `< 0` shrinks it inward. Returns a
+* {@link KernelMeshResult} in world coordinates (a single face group, no UVs).
+*/
+function offsetMesh(mesh, distance, 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", "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);
+	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)));
+		} catch (_) {
+			_usingCtx$5.e = _;
+		} finally {
+			_usingCtx$5.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));
+	}
+}
+/**
+* Hollow a solid mesh into a shell of the given inward `thickness`: voxelize an
+* FWN-signed SDF, take `max(solid, -(solid + thickness))`, then contour it.
+*
+* `thickness` must be finite and > 0 (inward-only). Returns a
+* {@link KernelMeshResult} in world coordinates (a single face group, no UVs).
+*/
+function shellMesh(mesh, thickness, 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", "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);
+	if (require_errors.isErr(params)) return params;
+	const engine = resolveEngine(id);
+	if (require_errors.isErr(engine)) return engine;
+	try {
+		try {
+			var _usingCtx3 = require_shapeTypes._usingCtx();
+			return meshFromResult(_usingCtx3.u(engine.value.shell_mesh(mesh.vertices, mesh.triangles, thickness, params.value.resolution, params.value.padding)));
+		} catch (_) {
+			_usingCtx3.e = _;
+		} finally {
+			_usingCtx3.d();
+		}
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("VOXEL_SHELL_FAILED", cause instanceof Error ? cause.message : "voxel shell failed (grid too large?).", cause));
+	}
+}
+/**
+* Voxel-based CSG of two meshes: voxelize both onto a shared grid, combine their
+* SDFs (union/intersection/difference), then Surface-Nets contour the result.
+*
+* `op` is `'difference'` = A − B. Robust on non-watertight input (FWN sign).
+* Returns a {@link KernelMeshResult} in world coordinates (single group, no UVs).
+*/
+function voxelBoolean(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", "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);
+	if (require_errors.isErr(params)) return params;
+	const engine = resolveEngine(id);
+	if (require_errors.isErr(engine)) return engine;
+	try {
+		try {
+			var _usingCtx4 = require_shapeTypes._usingCtx();
+			return meshFromResult(_usingCtx4.u(engine.value.voxel_boolean(a.vertices, a.triangles, b.vertices, b.triangles, opCode, params.value.resolution, params.value.padding)));
+		} catch (_) {
+			_usingCtx4.e = _;
+		} finally {
+			_usingCtx4.d();
+		}
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("VOXEL_BOOLEAN_FAILED", cause instanceof Error ? cause.message : "voxel boolean failed (grid too large?).", cause));
+	}
+}
+/**
+* Offset a B-rep shape by `distance`: tessellate it, then run {@link offsetMesh}
+* on the resulting triangle soup. `distance > 0` grows outward, `< 0` shrinks
+* inward. Threads a meshing failure straight back as an `err(...)`.
+*/
+function offsetShape(shape, distance, opts, id) {
+	const meshInput = shapeToMeshInput(shape);
+	if (require_errors.isErr(meshInput)) return meshInput;
+	return offsetMesh(meshInput.value, distance, opts, id);
+}
+/**
+* Hollow a B-rep shape into a shell of inward `thickness`: tessellate it, then
+* run {@link shellMesh}. `thickness` must be finite and > 0. Threads a meshing
+* failure straight back as an `err(...)`.
+*/
+function shellShape(shape, thickness, opts, id) {
+	const meshInput = shapeToMeshInput(shape);
+	if (require_errors.isErr(meshInput)) return meshInput;
+	return shellMesh(meshInput.value, thickness, opts, id);
+}
+/**
+* Voxel CSG of two B-rep shapes: tessellate both, then run {@link voxelBoolean}.
+* `op` is `'difference'` = A − B. Threads either meshing failure back as an
+* `err(...)`.
+*/
+function voxelBooleanShapes(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 voxelBoolean(meshA.value, meshB.value, op, opts, id);
+}
+//#endregion
+//#region src/lattice/latticeFns.ts
+var LATTICE_TAGS = {
+	gyroid: 0,
+	schwarzP: 1,
+	diamond: 2
+};
+var DEFAULT_RESOLUTION = 48;
+var DEFAULT_PADDING = 2;
+function validateOptions(opts) {
+	const tag = LATTICE_TAGS[opts.type];
+	if (tag === void 0) return require_errors.err(require_errors.validationError("LATTICE_INVALID_TYPE", `lattice type must be one of gyroid, schwarzP, diamond (got '${opts.type}').`));
+	if (!(opts.period > 0)) return require_errors.err(require_errors.validationError("LATTICE_INVALID_PERIOD", "period must be > 0."));
+	if (!(opts.thickness > 0)) return require_errors.err(require_errors.validationError("LATTICE_INVALID_THICKNESS", "thickness must be > 0."));
+	const resolution = opts.resolution ?? DEFAULT_RESOLUTION;
+	const padding = opts.padding ?? DEFAULT_PADDING;
+	if (!Number.isInteger(resolution) || resolution < 1) return require_errors.err(require_errors.validationError("LATTICE_INVALID_RESOLUTION", "resolution must be an integer >= 1."));
+	if (!Number.isInteger(padding) || padding < 1) return require_errors.err(require_errors.validationError("LATTICE_INVALID_PADDING", "padding must be an integer >= 1."));
+	return require_errors.ok({
+		tag,
+		period: opts.period,
+		thickness: opts.thickness,
+		resolution,
+		padding
+	});
+}
+function toMesh(repaired) {
+	const vertexCount = repaired.positions.length / 3;
+	return {
+		vertices: repaired.positions,
+		normals: repaired.normals,
+		triangles: repaired.indices,
+		uvs: new Float32Array(vertexCount * 2),
+		faceGroups: [{
+			start: 0,
+			count: repaired.indices.length / 3,
+			faceHash: 0
+		}]
+	};
+}
+/**
+* Fill a solid mesh with a TPMS lattice infill: intersect the FWN-signed solid
+* with the chosen lattice shell field, then Surface-Nets contour the result.
+*
+* Returns a {@link KernelMeshResult} in world coordinates (a single face group,
+* no UVs). The TPMS field is the approximate implicit (raw trig), so the surface
+* is contoured at the zero level without distance normalization (ADR-0013).
+*/
+function latticeInfill(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("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);
+	if (require_errors.isErr(engine)) return engine;
+	const { tag, period, thickness, resolution, padding } = resolved.value;
+	try {
+		try {
+			var _usingCtx$4 = require_shapeTypes._usingCtx();
+			return require_errors.ok(toMesh(_usingCtx$4.u(engine.value.lattice_infill(mesh.vertices, mesh.triangles, resolution, padding, tag, period, thickness))));
 		} catch (_) {
 			_usingCtx$4.e = _;
 		} finally {
 			_usingCtx$4.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));
+		return require_errors.err(require_errors.computationError("LATTICE_INFILL_FAILED", cause instanceof Error ? cause.message : "lattice infill failed (grid too large?).", cause));
+	}
+}
+/**
+* Fill a B-rep shape with a TPMS lattice infill: tessellate the shape, then run
+* {@link latticeInfill} on the resulting triangle soup. Threads a meshing
+* failure straight back as an `err(...)`.
+*/
+function latticeInfillShape(shape, opts, id) {
+	const meshInput = shapeToMeshInput(shape);
+	if (require_errors.isErr(meshInput)) return meshInput;
+	return latticeInfill(meshInput.value, opts, id);
+}
+/**
+* Contour the infinite TPMS lattice clipped to an axis-aligned box.
+*
+* Returns a {@link KernelMeshResult} in world coordinates (a single face group,
+* no UVs). The TPMS field is the approximate implicit (raw trig), contoured at
+* the zero level without distance normalization (ADR-0013).
+*/
+function tpmsLattice(bounds, opts, id) {
+	for (let axis = 0; axis < 3; axis++) {
+		const lo = bounds.min[axis];
+		const hi = bounds.max[axis];
+		if (lo === void 0 || hi === void 0 || !(lo < hi)) return require_errors.err(require_errors.validationError("LATTICE_INVALID_BOUNDS", `bounds.min must be strictly less than bounds.max on every axis (axis ${axis}).`));
+	}
+	const resolved = validateOptions(opts);
+	if (require_errors.isErr(resolved)) return resolved;
+	const engine = resolveEngine(id);
+	if (require_errors.isErr(engine)) return engine;
+	const { tag, period, thickness, resolution, padding } = resolved.value;
+	const [minX, minY, minZ] = bounds.min;
+	const [maxX, maxY, maxZ] = bounds.max;
+	try {
+		try {
+			var _usingCtx3 = require_shapeTypes._usingCtx();
+			return require_errors.ok(toMesh(_usingCtx3.u(engine.value.tpms_box(minX, minY, minZ, maxX, maxY, maxZ, resolution, padding, tag, period, thickness))));
+		} catch (_) {
+			_usingCtx3.e = _;
+		} finally {
+			_usingCtx3.d();
+		}
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("TPMS_LATTICE_FAILED", cause instanceof Error ? cause.message : "tpms lattice failed (grid too large?).", cause));
 	}
 }
 //#endregion
@@ -5621,6 +5911,8 @@ exports.kernelCall = require_topologyQueryFns.kernelCall;
 exports.kernelCallRaw = require_topologyQueryFns.kernelCallRaw;
 exports.kernelCallScoped = require_topologyQueryFns.kernelCallScoped;
 exports.kernelError = require_errors.kernelError;
+exports.latticeInfill = latticeInfill;
+exports.latticeInfillShape = latticeInfillShape;
 exports.line = require_primitiveFns.line;
 exports.linearPattern = require_historyFns.linearPattern;
 exports.loadFont = require_textBlueprints.loadFont;
@@ -5673,6 +5965,8 @@ exports.multiSectionSweep = require_extrudeFns.multiSectionSweep;
 exports.normalAt = require_faceFns.normalAt;
 exports.offset = offset;
 exports.offsetFace = require_primitiveFns.offsetFace;
+exports.offsetMesh = offsetMesh;
+exports.offsetShape = offsetShape;
 exports.offsetWire2D = require_curveFns.offsetWire2D;
 exports.ok = require_errors.ok;
 exports.or = require_errors.or;
@@ -5753,9 +6047,12 @@ exports.setShapeOrigin = require_shapeFns.setShapeOrigin;
 exports.setTagMetadata = require_shapeFns.setTagMetadata;
 exports.sewShells = require_primitiveFns.sewShells;
 exports.shape = shape;
+exports.shapeToMeshInput = shapeToMeshInput;
 exports.shapeType = require_faceFns.shapeType;
 exports.sharedEdges = require_primitiveFns.sharedEdges;
 exports.shell = shell;
+exports.shellMesh = shellMesh;
+exports.shellShape = shellShape;
 exports.shellWithEvolution = require_primitiveFns.shellWithEvolution;
 exports.simplify = simplify;
 exports.sketchCircle = require_drawFns.sketchCircle;
@@ -5810,6 +6107,7 @@ exports.toSVGPathD = require_blueprintFns.toSVGPathD;
 exports.toVec2 = require_types.toVec2;
 exports.toVec3 = require_types.toVec3;
 exports.torus = require_primitiveFns.torus;
+exports.tpmsLattice = tpmsLattice;
 exports.transformCopy = transformCopy;
 Object.defineProperty(exports, "transforms", {
 	enumerable: true,
@@ -5859,6 +6157,8 @@ exports.vertex = require_primitiveFns.vertex;
 exports.vertexFinder = vertexFinder;
 exports.vertexPosition = require_topologyQueryFns.vertexPosition;
 exports.verticesOfEdge = require_primitiveFns.verticesOfEdge;
+exports.voxelBoolean = voxelBoolean;
+exports.voxelBooleanShapes = voxelBooleanShapes;
 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 = 48;
-var DEFAULT_PADDING = 2;
+var DEFAULT_RESOLUTION$2 = 48;
+var DEFAULT_PADDING$2 = 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;
-	const padding = opts?.padding ?? DEFAULT_PADDING;
+	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."));
 	const engine = resolveEngine(id);
 	if (isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$4 = _usingCtx();
-			const repaired = _usingCtx$4.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
+			var _usingCtx$6 = _usingCtx();
+			const repaired = _usingCtx$6.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
 			const vertexCount = repaired.positions.length / 3;
 			return ok({
 				vertices: repaired.positions,
@@ -265,13 +265,303 @@ function repairMesh(mesh, opts, id) {
 					faceHash: 0
 				}]
 			});
+		} catch (_) {
+			_usingCtx$6.e = _;
+		} finally {
+			_usingCtx$6.d();
+		}
+	} catch (cause) {
+		return err(computationError("VOXEL_REPAIR_FAILED", cause instanceof Error ? cause.message : "voxel repair failed (grid too large?).", cause));
+	}
+}
+//#endregion
+//#region src/voxel/shapeMesh.ts
+var DEFAULT_DEFLECTION = .001;
+/**
+* Mesh a B-rep shape into the flat triangle-soup {@link VoxelMeshInput} the voxel
+* ops consume. Tessellates via the topology mesh API at `deflection` linear
+* tolerance and forwards its `{ vertices, triangles }` (already Float32Array /
+* Uint32Array). Meshing failures surface as an `err(...)` rather than a throw.
+*/
+function shapeToMeshInput(shape, deflection = DEFAULT_DEFLECTION) {
+	try {
+		const tessellated = mesh$1(shape, { tolerance: deflection });
+		if (tessellated.vertices.length === 0 || tessellated.triangles.length === 0) return err(computationError("VOXEL_SHAPE_MESH_EMPTY", "shape tessellated to an empty triangle mesh."));
+		return ok({
+			vertices: tessellated.vertices,
+			triangles: tessellated.triangles
+		});
+	} catch (cause) {
+		return err(computationError("VOXEL_SHAPE_MESH_FAILED", cause instanceof Error ? cause.message : "failed to mesh shape for voxel op.", cause));
+	}
+}
+//#endregion
+//#region src/voxel/meshOpsFns.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
+	});
+}
+function meshFromResult(result) {
+	if (result.positions.length === 0 || result.indices.length === 0) return err(computationError("VOXEL_DEGENERATE_RESULT", "the voxel operation produced an empty mesh (over-shrunk offset or disjoint operands?)."));
+	const vertexCount = result.positions.length / 3;
+	return ok({
+		vertices: result.positions,
+		normals: result.normals,
+		triangles: result.indices,
+		uvs: new Float32Array(vertexCount * 2),
+		faceGroups: [{
+			start: 0,
+			count: result.indices.length / 3,
+			faceHash: 0
+		}]
+	});
+}
+/**
+* Offset a mesh by `distance` via a true-SDF iso-level shift: voxelize an
+* FWN-signed SDF, subtract `distance`, then Surface-Nets contour it back.
+*
+* `distance > 0` grows the surface outward, `< 0` shrinks it inward. Returns a
+* {@link KernelMeshResult} in world coordinates (a single face group, no UVs).
+*/
+function offsetMesh(mesh, distance, 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", "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);
+	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)));
+		} catch (_) {
+			_usingCtx$5.e = _;
+		} finally {
+			_usingCtx$5.d();
+		}
+	} catch (cause) {
+		return err(computationError("VOXEL_OFFSET_FAILED", cause instanceof Error ? cause.message : "voxel offset failed (grid too large?).", cause));
+	}
+}
+/**
+* Hollow a solid mesh into a shell of the given inward `thickness`: voxelize an
+* FWN-signed SDF, take `max(solid, -(solid + thickness))`, then contour it.
+*
+* `thickness` must be finite and > 0 (inward-only). Returns a
+* {@link KernelMeshResult} in world coordinates (a single face group, no UVs).
+*/
+function shellMesh(mesh, thickness, 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", "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);
+	if (isErr(params)) return params;
+	const engine = resolveEngine(id);
+	if (isErr(engine)) return engine;
+	try {
+		try {
+			var _usingCtx3 = _usingCtx();
+			return meshFromResult(_usingCtx3.u(engine.value.shell_mesh(mesh.vertices, mesh.triangles, thickness, params.value.resolution, params.value.padding)));
+		} catch (_) {
+			_usingCtx3.e = _;
+		} finally {
+			_usingCtx3.d();
+		}
+	} catch (cause) {
+		return err(computationError("VOXEL_SHELL_FAILED", cause instanceof Error ? cause.message : "voxel shell failed (grid too large?).", cause));
+	}
+}
+/**
+* Voxel-based CSG of two meshes: voxelize both onto a shared grid, combine their
+* SDFs (union/intersection/difference), then Surface-Nets contour the result.
+*
+* `op` is `'difference'` = A − B. Robust on non-watertight input (FWN sign).
+* Returns a {@link KernelMeshResult} in world coordinates (single group, no UVs).
+*/
+function voxelBoolean(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", "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);
+	if (isErr(params)) return params;
+	const engine = resolveEngine(id);
+	if (isErr(engine)) return engine;
+	try {
+		try {
+			var _usingCtx4 = _usingCtx();
+			return meshFromResult(_usingCtx4.u(engine.value.voxel_boolean(a.vertices, a.triangles, b.vertices, b.triangles, opCode, params.value.resolution, params.value.padding)));
+		} catch (_) {
+			_usingCtx4.e = _;
+		} finally {
+			_usingCtx4.d();
+		}
+	} catch (cause) {
+		return err(computationError("VOXEL_BOOLEAN_FAILED", cause instanceof Error ? cause.message : "voxel boolean failed (grid too large?).", cause));
+	}
+}
+/**
+* Offset a B-rep shape by `distance`: tessellate it, then run {@link offsetMesh}
+* on the resulting triangle soup. `distance > 0` grows outward, `< 0` shrinks
+* inward. Threads a meshing failure straight back as an `err(...)`.
+*/
+function offsetShape(shape, distance, opts, id) {
+	const meshInput = shapeToMeshInput(shape);
+	if (isErr(meshInput)) return meshInput;
+	return offsetMesh(meshInput.value, distance, opts, id);
+}
+/**
+* Hollow a B-rep shape into a shell of inward `thickness`: tessellate it, then
+* run {@link shellMesh}. `thickness` must be finite and > 0. Threads a meshing
+* failure straight back as an `err(...)`.
+*/
+function shellShape(shape, thickness, opts, id) {
+	const meshInput = shapeToMeshInput(shape);
+	if (isErr(meshInput)) return meshInput;
+	return shellMesh(meshInput.value, thickness, opts, id);
+}
+/**
+* Voxel CSG of two B-rep shapes: tessellate both, then run {@link voxelBoolean}.
+* `op` is `'difference'` = A − B. Threads either meshing failure back as an
+* `err(...)`.
+*/
+function voxelBooleanShapes(a, b, op, opts, id) {
+	const meshA = shapeToMeshInput(a);
+	if (isErr(meshA)) return meshA;
+	const meshB = shapeToMeshInput(b);
+	if (isErr(meshB)) return meshB;
+	return voxelBoolean(meshA.value, meshB.value, op, opts, id);
+}
+//#endregion
+//#region src/lattice/latticeFns.ts
+var LATTICE_TAGS = {
+	gyroid: 0,
+	schwarzP: 1,
+	diamond: 2
+};
+var DEFAULT_RESOLUTION = 48;
+var DEFAULT_PADDING = 2;
+function validateOptions(opts) {
+	const tag = LATTICE_TAGS[opts.type];
+	if (tag === void 0) return err(validationError("LATTICE_INVALID_TYPE", `lattice type must be one of gyroid, schwarzP, diamond (got '${opts.type}').`));
+	if (!(opts.period > 0)) return err(validationError("LATTICE_INVALID_PERIOD", "period must be > 0."));
+	if (!(opts.thickness > 0)) return err(validationError("LATTICE_INVALID_THICKNESS", "thickness must be > 0."));
+	const resolution = opts.resolution ?? DEFAULT_RESOLUTION;
+	const padding = opts.padding ?? DEFAULT_PADDING;
+	if (!Number.isInteger(resolution) || resolution < 1) return err(validationError("LATTICE_INVALID_RESOLUTION", "resolution must be an integer >= 1."));
+	if (!Number.isInteger(padding) || padding < 1) return err(validationError("LATTICE_INVALID_PADDING", "padding must be an integer >= 1."));
+	return ok({
+		tag,
+		period: opts.period,
+		thickness: opts.thickness,
+		resolution,
+		padding
+	});
+}
+function toMesh(repaired) {
+	const vertexCount = repaired.positions.length / 3;
+	return {
+		vertices: repaired.positions,
+		normals: repaired.normals,
+		triangles: repaired.indices,
+		uvs: new Float32Array(vertexCount * 2),
+		faceGroups: [{
+			start: 0,
+			count: repaired.indices.length / 3,
+			faceHash: 0
+		}]
+	};
+}
+/**
+* Fill a solid mesh with a TPMS lattice infill: intersect the FWN-signed solid
+* with the chosen lattice shell field, then Surface-Nets contour the result.
+*
+* Returns a {@link KernelMeshResult} in world coordinates (a single face group,
+* no UVs). The TPMS field is the approximate implicit (raw trig), so the surface
+* is contoured at the zero level without distance normalization (ADR-0013).
+*/
+function latticeInfill(mesh, opts, id) {
+	const invalid = validateMesh(mesh);
+	if (invalid) return err(invalid);
+	if (mesh.vertices.length === 0 || mesh.triangles.length === 0) return err(validationError("LATTICE_EMPTY_MESH", "latticeInfill requires a non-empty triangle mesh."));
+	const resolved = validateOptions(opts);
+	if (isErr(resolved)) return resolved;
+	const engine = resolveEngine(id);
+	if (isErr(engine)) return engine;
+	const { tag, period, thickness, resolution, padding } = resolved.value;
+	try {
+		try {
+			var _usingCtx$4 = _usingCtx();
+			return ok(toMesh(_usingCtx$4.u(engine.value.lattice_infill(mesh.vertices, mesh.triangles, resolution, padding, tag, period, thickness))));
 		} catch (_) {
 			_usingCtx$4.e = _;
 		} finally {
 			_usingCtx$4.d();
 		}
 	} catch (cause) {
-		return err(computationError("VOXEL_REPAIR_FAILED", cause instanceof Error ? cause.message : "voxel repair failed (grid too large?).", cause));
+		return err(computationError("LATTICE_INFILL_FAILED", cause instanceof Error ? cause.message : "lattice infill failed (grid too large?).", cause));
+	}
+}
+/**
+* Fill a B-rep shape with a TPMS lattice infill: tessellate the shape, then run
+* {@link latticeInfill} on the resulting triangle soup. Threads a meshing
+* failure straight back as an `err(...)`.
+*/
+function latticeInfillShape(shape, opts, id) {
+	const meshInput = shapeToMeshInput(shape);
+	if (isErr(meshInput)) return meshInput;
+	return latticeInfill(meshInput.value, opts, id);
+}
+/**
+* Contour the infinite TPMS lattice clipped to an axis-aligned box.
+*
+* Returns a {@link KernelMeshResult} in world coordinates (a single face group,
+* no UVs). The TPMS field is the approximate implicit (raw trig), contoured at
+* the zero level without distance normalization (ADR-0013).
+*/
+function tpmsLattice(bounds, opts, id) {
+	for (let axis = 0; axis < 3; axis++) {
+		const lo = bounds.min[axis];
+		const hi = bounds.max[axis];
+		if (lo === void 0 || hi === void 0 || !(lo < hi)) return err(validationError("LATTICE_INVALID_BOUNDS", `bounds.min must be strictly less than bounds.max on every axis (axis ${axis}).`));
+	}
+	const resolved = validateOptions(opts);
+	if (isErr(resolved)) return resolved;
+	const engine = resolveEngine(id);
+	if (isErr(engine)) return engine;
+	const { tag, period, thickness, resolution, padding } = resolved.value;
+	const [minX, minY, minZ] = bounds.min;
+	const [maxX, maxY, maxZ] = bounds.max;
+	try {
+		try {
+			var _usingCtx3 = _usingCtx();
+			return ok(toMesh(_usingCtx3.u(engine.value.tpms_box(minX, minY, minZ, maxX, maxY, maxZ, resolution, padding, tag, period, thickness))));
+		} catch (_) {
+			_usingCtx3.e = _;
+		} finally {
+			_usingCtx3.d();
+		}
+	} catch (cause) {
+		return err(computationError("TPMS_LATTICE_FAILED", cause instanceof Error ? cause.message : "tpms lattice failed (grid too large?).", cause));
 	}
 }
 //#endregion
@@ -5293,4 +5583,4 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	withEvaluator: () => withEvaluator
 });
 //#endregion
-export { BaseSketcher2d, BlueprintSketcher, BrepBugError, BrepErrorCode, BrepWrapperError, BrepkitAdapter, CompoundSketch, DEG2RAD, DisposalScope, 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, 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, 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, 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, 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, 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, shapeType, sharedEdges, shell, 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, 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, walkAssembly, windingNumbers, wire, wireFinder, wireLoop, wiresOfFace, withKernel, withKernelDir, withKernelPnt, withKernelVec, withScope, withScopeResult, withScopeResultAsync, zip as zipResults };
+export { BaseSketcher2d, BlueprintSketcher, BrepBugError, BrepErrorCode, BrepWrapperError, BrepkitAdapter, CompoundSketch, DEG2RAD, DisposalScope, 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, 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, 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, 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, withScope, withScopeResult, withScopeResultAsync, zip as zipResults };

package/dist/index.d.ts

@@ -34,8 +34,10 @@ 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, } from './voxel/index.js';
-export type { VoxelEngine, VoxelMeshInput, VoxelRepairResult, RepairOptions, } from './voxel/index.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 { latticeInfill, latticeInfillShape, tpmsLattice } from './lattice/index.js';
+export type { LatticeType, LatticeOptions, LatticeBounds } from './lattice/index.js';
 export { default as Sketcher } from './sketching/sketcher.js';
 export { default as FaceSketcher } from './sketching/faceSketcher.js';
 export { BaseSketcher2d } from './2d/blueprints/baseSketcher2d.js';

package/dist/lattice/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lattice / TPMS geometry domain (ADR-0013, Layer 3).
+ *
+ * Builds triangle meshes from triply-periodic minimal surfaces, either filling a
+ * solid (infill) or clipped to a box. Sits on the voxel domain's FWN-signed grid
+ * and Surface-Nets contour, surfaced through the shared voxel engine registry.
+ */
+export { latticeInfill, latticeInfillShape, tpmsLattice } from './latticeFns.js';
+export type { LatticeType, LatticeOptions, LatticeBounds } from './latticeFns.js';

package/dist/lattice/latticeFns.d.ts

@@ -0,0 +1,47 @@
+import { Result } from '../core/result.js';
+import { KernelMeshResult } from '../kernel/types.js';
+import { AnyShape, Dimension } from '../core/shapeTypes.js';
+import { VoxelMeshInput } from '../voxel/signFns.js';
+/** TPMS lattice families. Maps to the wasm tag (0=Gyroid, 1=SchwarzP, 2=Diamond). */
+export type LatticeType = 'gyroid' | 'schwarzP' | 'diamond';
+/**
+ * TPMS lattice tuning. `period` is the unit-cell size (world units); `thickness`
+ * is the strut wall width in field units. `resolution` sizes the longest bbox
+ * axis in voxels; `padding` is the positive air-margin ring (>= 1) Surface Nets
+ * needs.
+ */
+export interface LatticeOptions {
+    type: LatticeType;
+    period: number;
+    thickness: number;
+    resolution?: number;
+    padding?: number;
+}
+/**
+ * Fill a solid mesh with a TPMS lattice infill: intersect the FWN-signed solid
+ * with the chosen lattice shell field, then Surface-Nets contour the result.
+ *
+ * Returns a {@link KernelMeshResult} in world coordinates (a single face group,
+ * no UVs). The TPMS field is the approximate implicit (raw trig), so the surface
+ * is contoured at the zero level without distance normalization (ADR-0013).
+ */
+export declare function latticeInfill(mesh: VoxelMeshInput, opts: LatticeOptions, id?: string): Result<KernelMeshResult>;
+/**
+ * Fill a B-rep shape with a TPMS lattice infill: tessellate the shape, then run
+ * {@link latticeInfill} on the resulting triangle soup. Threads a meshing
+ * failure straight back as an `err(...)`.
+ */
+export declare function latticeInfillShape(shape: AnyShape<Dimension>, opts: LatticeOptions, id?: string): Result<KernelMeshResult>;
+/** Axis-aligned bounds for a clipped TPMS lattice. */
+export interface LatticeBounds {
+    min: [number, number, number];
+    max: [number, number, number];
+}
+/**
+ * Contour the infinite TPMS lattice clipped to an axis-aligned box.
+ *
+ * Returns a {@link KernelMeshResult} in world coordinates (a single face group,
+ * no UVs). The TPMS field is the approximate implicit (raw trig), contoured at
+ * the zero level without distance normalization (ADR-0013).
+ */
+export declare function tpmsLattice(bounds: LatticeBounds, opts: LatticeOptions, id?: string): Result<KernelMeshResult>;

package/dist/voxel/engine.d.ts

@@ -13,6 +13,16 @@ export interface VoxelEngine {
     points_inside(verts: Float32Array, tris: Uint32Array, queries: Float32Array): Uint8Array;
     /** Voxelize-and-contour a mesh into a closed surface (FWN sign keystone). */
     repair_mesh(verts: Float32Array, tris: Uint32Array, resolution: number, padding: number): VoxelRepairResult;
+    /** Fill an FWN-signed solid with a TPMS lattice infill, contoured to a mesh. */
+    lattice_infill(verts: Float32Array, tris: Uint32Array, resolution: number, padding: number, lattice_type: number, period: number, thickness: number): VoxelRepairResult;
+    /** Contour the infinite TPMS lattice clipped to an axis-aligned box. */
+    tpms_box(min_x: number, min_y: number, min_z: number, max_x: number, max_y: number, max_z: number, resolution: number, padding: number, lattice_type: number, period: number, thickness: number): VoxelRepairResult;
+    /** Offset a mesh by a true-SDF iso-level shift (>0 outward, <0 inward). */
+    offset_mesh(verts: Float32Array, tris: Uint32Array, distance: number, resolution: number, padding: number): VoxelRepairResult;
+    /** Hollow a solid mesh into an inward shell of the given thickness (>0). */
+    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;
     /** Engine artifact version, for loader/artifact compatibility checks. */
     version(): string;
 }

package/dist/voxel/index.d.ts

@@ -8,6 +8,9 @@
 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 { 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 { shapeToMeshInput } from './shapeMesh.js';

package/dist/voxel/meshOpsFns.d.ts

@@ -0,0 +1,52 @@
+import { Result } from '../core/result.js';
+import { KernelMeshResult } from '../kernel/types.js';
+import { AnyShape, Dimension } from '../core/shapeTypes.js';
+import { VoxelMeshInput } from './signFns.js';
+/** Voxel mesh-op tuning. `resolution` sizes the longest bbox axis in voxels;
+ *  `padding` is the positive air-margin ring (>= 1) Surface Nets needs. */
+export interface VoxelOpOptions {
+    resolution?: number;
+    padding?: number;
+}
+/**
+ * Offset a mesh by `distance` via a true-SDF iso-level shift: voxelize an
+ * FWN-signed SDF, subtract `distance`, then Surface-Nets contour it back.
+ *
+ * `distance > 0` grows the surface outward, `< 0` shrinks it inward. Returns a
+ * {@link KernelMeshResult} in world coordinates (a single face group, no UVs).
+ */
+export declare function offsetMesh(mesh: VoxelMeshInput, distance: number, opts?: VoxelOpOptions, id?: string): Result<KernelMeshResult>;
+/**
+ * Hollow a solid mesh into a shell of the given inward `thickness`: voxelize an
+ * FWN-signed SDF, take `max(solid, -(solid + thickness))`, then contour it.
+ *
+ * `thickness` must be finite and > 0 (inward-only). Returns a
+ * {@link KernelMeshResult} in world coordinates (a single face group, no UVs).
+ */
+export declare function shellMesh(mesh: VoxelMeshInput, thickness: number, opts?: VoxelOpOptions, id?: string): Result<KernelMeshResult>;
+/**
+ * Voxel-based CSG of two meshes: voxelize both onto a shared grid, combine their
+ * SDFs (union/intersection/difference), then Surface-Nets contour the result.
+ *
+ * `op` is `'difference'` = A − B. Robust on non-watertight input (FWN sign).
+ * Returns a {@link KernelMeshResult} in world coordinates (single group, no UVs).
+ */
+export declare function voxelBoolean(a: VoxelMeshInput, b: VoxelMeshInput, op: 'union' | 'intersection' | 'difference', opts?: VoxelOpOptions, id?: string): Result<KernelMeshResult>;
+/**
+ * Offset a B-rep shape by `distance`: tessellate it, then run {@link offsetMesh}
+ * on the resulting triangle soup. `distance > 0` grows outward, `< 0` shrinks
+ * inward. Threads a meshing failure straight back as an `err(...)`.
+ */
+export declare function offsetShape(shape: AnyShape<Dimension>, distance: number, opts?: VoxelOpOptions, id?: string): Result<KernelMeshResult>;
+/**
+ * Hollow a B-rep shape into a shell of inward `thickness`: tessellate it, then
+ * run {@link shellMesh}. `thickness` must be finite and > 0. Threads a meshing
+ * failure straight back as an `err(...)`.
+ */
+export declare function shellShape(shape: AnyShape<Dimension>, thickness: number, opts?: VoxelOpOptions, id?: string): Result<KernelMeshResult>;
+/**
+ * Voxel CSG of two B-rep shapes: tessellate both, then run {@link voxelBoolean}.
+ * `op` is `'difference'` = A − B. Threads either meshing failure back as an
+ * `err(...)`.
+ */
+export declare function voxelBooleanShapes(a: AnyShape<Dimension>, b: AnyShape<Dimension>, op: 'union' | 'intersection' | 'difference', opts?: VoxelOpOptions, id?: string): Result<KernelMeshResult>;

package/dist/voxel/shapeMesh.d.ts

@@ -0,0 +1,10 @@
+import { AnyShape, Dimension } from '../core/shapeTypes.js';
+import { Result } from '../core/result.js';
+import { VoxelMeshInput } from './signFns.js';
+/**
+ * Mesh a B-rep shape into the flat triangle-soup {@link VoxelMeshInput} the voxel
+ * ops consume. Tessellates via the topology mesh API at `deflection` linear
+ * tolerance and forwards its `{ vertices, triangles }` (already Float32Array /
+ * Uint32Array). Meshing failures surface as an `err(...)` rather than a throw.
+ */
+export declare function shapeToMeshInput(shape: AnyShape<Dimension>, deflection?: number): Result<VoxelMeshInput>;

package/package.json

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