brepjs 18.67.0 → 18.69.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$3 = 48;
-var DEFAULT_PADDING$3 = 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,11 +232,11 @@ 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$3;
-	const padding = opts?.padding ?? DEFAULT_PADDING$3;
+	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 {
@@ -286,16 +286,16 @@ function shapeToMeshInput(shape, deflection = DEFAULT_DEFLECTION) {
 }
 //#endregion
 //#region src/voxel/meshOpsFns.ts
-var DEFAULT_RESOLUTION$2 = 48;
-var DEFAULT_PADDING$2 = 2;
+var DEFAULT_RESOLUTION$3 = 48;
+var DEFAULT_PADDING$3 = 2;
 var BOOLEAN_OP_CODES$1 = {
 	union: 0,
 	intersection: 1,
 	difference: 2
 };
-function resolveGridParams$1(opts) {
-	const resolution = opts?.resolution ?? DEFAULT_RESOLUTION$2;
-	const padding = opts?.padding ?? DEFAULT_PADDING$2;
+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,9 +330,9 @@ 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$1(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 {
@@ -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$1(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 {
@@ -391,9 +391,9 @@ function voxelBoolean(a, b, op, opts, id) {
 	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$1[op];
-	const params = resolveGridParams$1(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 {
@@ -442,16 +442,16 @@ function voxelBooleanShapes(a, b, op, opts, id) {
 }
 //#endregion
 //#region src/voxel/fieldFns.ts
-var DEFAULT_RESOLUTION$1 = 48;
-var DEFAULT_PADDING$1 = 2;
+var DEFAULT_RESOLUTION$2 = 48;
+var DEFAULT_PADDING$2 = 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;
+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({
@@ -501,6 +501,9 @@ function fieldDeletable(raw) {
 		}
 	};
 }
+function makeFieldHandle(raw) {
+	return makeHandle(raw);
+}
 function makeHandle(raw) {
 	const inner = require_shapeTypes.createKernelHandle(fieldDeletable(raw));
 	const handle = {
@@ -557,9 +560,9 @@ 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);
+	const params = resolveGridParams$1(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 {
 		return require_errors.ok(makeHandle(new engine.value.VoxelField(mesh.vertices, mesh.triangles, params.value.resolution, params.value.padding)));
@@ -586,9 +589,9 @@ function voxelBooleanField(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", "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);
+	const params = resolveGridParams$1(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 {
 		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)));
@@ -698,6 +701,302 @@ function voxelBooleanFieldShapes(a, b, op, opts, id) {
 	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();
+		}
+	};
+}
+/** The position-modulated operator methods, split out to keep {@link makeSdfHandle}
+* under the per-function line cap. `this` binds to the owning {@link SdfHandle} when
+* spread into its object literal. */
+var MODULATED_FIELD_METHODS = {
+	offsetField(field) {
+		return makeSdfHandle(this.value.offset_field(field.value));
+	},
+	roundField(field) {
+		return makeSdfHandle(this.value.round_field(field.value));
+	},
+	shellField(field) {
+		return makeSdfHandle(this.value.shell_field(field.value));
+	},
+	smoothUnionField(other, field) {
+		return makeSdfHandle(this.value.smooth_union_field(other.value, field.value));
+	}
+};
+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));
+		},
+		...MODULATED_FIELD_METHODS,
+		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);
+}
+function flattenSpine(spine) {
+	if (spine.length < 2) return require_errors.err(require_errors.validationError("SDF_INVALID_SPINE", "sweep spine needs at least 2 points."));
+	const flat = new Float64Array(spine.length * 3);
+	for (let i = 0; i < spine.length; i++) {
+		const pt = spine[i];
+		if (!pt.every((c) => Number.isFinite(c))) return require_errors.err(require_errors.validationError("SDF_INVALID_SPINE", "sweep spine coordinates must be finite."));
+		flat[i * 3] = pt[0];
+		flat[i * 3 + 1] = pt[1];
+		flat[i * 3 + 2] = pt[2];
+	}
+	return require_errors.ok(flat);
+}
+/**
+* Sweep an in-plane `profile` along a `spine` polyline using rotation-minimizing
+* frames (no 180° flip at inflections). The profile is sampled in its own
+* `(normal, binormal)` plane at every station; `opts.closed` loops the spine and
+* skips the open-end caps. The result is a pseudo-SDF (exact distance only near
+* the swept wall), which contours cleanly. `spine` needs at least 2 finite points.
+*/
+function sweep(spine, profile, opts, id) {
+	const flat = flattenSpine(spine);
+	if (require_errors.isErr(flat)) return flat;
+	const closed = opts?.closed ?? false;
+	return build((e) => e.Sdf.sweep(flat.value, profile.value, closed), id);
+}
+var LATTICE_TAGS$1 = {
+	gyroid: 0,
+	schwarzP: 1,
+	diamond: 2
+};
+/**
+* A graded/conformal TPMS lattice: `|f(p)| − ½·thickness(p)` for the chosen `kind`
+* (negative = strut material), with `period` and `thickness` GRADED per-position via
+* {@link ScalarFieldHandle}. A {@link fieldConst} period/thickness reproduces a
+* uniform lattice. The field is Lipschitz and APPROXIMATE (not a true SDF).
+*
+* The lattice is INFINITE/periodic, so it must be clipped to a bounded region
+* (`lattice.intersection(region)`) before rasterizing — that conformal clip is what
+* frames a finite grid. NOTE: grading the PERIOD is an approximation (a
+* spatially-varying period isn't strictly periodic); grading THICKNESS is the
+* well-behaved primary knob.
+*/
+function lattice(kind, period, thickness, id) {
+	const tag = LATTICE_TAGS$1[kind];
+	if (tag === void 0) return require_errors.err(require_errors.validationError("SDF_INVALID_LATTICE_KIND", `unknown lattice kind: ${kind}`));
+	return build((e) => e.Sdf.lattice(tag, period.value, thickness.value), id);
+}
+/**
+* A cubic beam/strut lattice: axis-aligned cylindrical struts on a `period`-spaced
+* cubic grid, with the strut `radius` GRADED per-position via
+* {@link ScalarFieldHandle}. Periodic/infinite — clip to a bounded region
+* (`strut.intersection(region)`) before rasterizing.
+*/
+function strutLattice(period, radius, id) {
+	return build((e) => e.Sdf.strut_lattice(period, radius.value), id);
+}
+function scalarFieldDeletable(raw) {
+	return {
+		raw,
+		delete() {
+			raw.free();
+		}
+	};
+}
+function makeScalarFieldHandle(raw) {
+	const inner = require_shapeTypes.createKernelHandle(scalarFieldDeletable(raw));
+	return {
+		get value() {
+			return inner.value.raw;
+		},
+		get disposed() {
+			return inner.disposed;
+		},
+		[Symbol.dispose]() {
+			inner[Symbol.dispose]();
+		}
+	};
+}
+function buildField(make, id) {
+	const engine = resolveEngine(id);
+	if (require_errors.isErr(engine)) return engine;
+	try {
+		return require_errors.ok(makeScalarFieldHandle(make(engine.value)));
+	} catch (cause) {
+		return require_errors.err(require_errors.computationError("SDF_FIELD_BUILD_FAILED", cause instanceof Error ? cause.message : "scalar field construction failed.", cause));
+	}
+}
+/** A spatially constant field — reproduces a constant operator parameter exactly. */
+function fieldConst(c, id) {
+	return buildField((e) => e.ScalarField.constant(c), id);
+}
+/**
+* A field that ramps `lo → hi` as `coord[axis]` goes `a → b`, clamped to the
+* endpoint band outside `[a, b]`. `axis` is 0 (x), 1 (y), or 2 (z).
+*/
+function fieldAxialRamp(axis, a, b, lo, hi, id) {
+	return buildField((e) => e.ScalarField.axial_ramp(axis, a, b, lo, hi), id);
+}
+/**
+* A field by radial distance from the line through `center` along `axis`: `lo → hi`
+* as that distance goes `r0 → r1`, clamped. `axis` is 0 (x), 1 (y), or 2 (z).
+*/
+function fieldRadialRamp(center, axis, r0, r1, lo, hi, id) {
+	return buildField((e) => e.ScalarField.radial_ramp(center[0], center[1], center[2], axis, r0, r1, lo, hi), id);
+}
+/**
+* A field from an {@link SdfHandle}'s signed distance, affinely remapped to
+* `sdf.eval(p) * scale + offset`. UNBOUNDED — drive a bounds-affecting op
+* (`offsetField`/`shellField`) with it only via `rasterizeIn` or wrapped in
+* {@link fieldClamp}.
+*/
+function fieldFromSdf(sdf, scale, offset, id) {
+	return buildField((e) => e.ScalarField.from_sdf(sdf.value, scale, offset), id);
+}
+/**
+* Clamp another field's value to `[min, max]` — bounds an otherwise unbounded
+* {@link fieldFromSdf} so it can safely drive offset/shell.
+*/
+function fieldClamp(field, min, max, id) {
+	return buildField((e) => e.ScalarField.clamp(field.value, min, max), id);
+}
+//#endregion
 //#region src/lattice/latticeFns.ts
 var LATTICE_TAGS = {
 	gyroid: 0,
@@ -751,7 +1050,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 {
@@ -792,7 +1091,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;
@@ -4461,7 +4760,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);
@@ -4476,7 +4775,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",
@@ -4485,7 +4784,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 {
@@ -4496,7 +4795,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);
@@ -4511,7 +4810,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 {
@@ -5416,7 +5715,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);
@@ -5435,14 +5734,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"]);
@@ -5451,14 +5750,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"];
@@ -5634,11 +5933,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));
@@ -5796,15 +6095,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,
@@ -5826,9 +6125,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,
@@ -6308,6 +6607,22 @@ 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.sdfFieldAxialRamp = fieldAxialRamp;
+exports.sdfFieldClamp = fieldClamp;
+exports.sdfFieldConst = fieldConst;
+exports.sdfFieldFromSdf = fieldFromSdf;
+exports.sdfFieldRadialRamp = fieldRadialRamp;
+exports.sdfLattice = lattice;
+exports.sdfPlane = plane;
+exports.sdfRoundedBox = roundedBox;
+exports.sdfSphere = sphere;
+exports.sdfStrutLattice = strutLattice;
+exports.sdfSweep = sweep;
+exports.sdfTorus = torus;
 exports.section = section;
 exports.sectionToFace = sectionToFace;
 exports.serializeHistory = require_historyFns.serializeHistory;