brepjs 18.68.0 → 18.69.0

package/dist/brepjs.cjs

@@ -729,6 +729,23 @@ function sdfDeletable(raw) {
 		}
 	};
 }
+/** 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 {
@@ -771,6 +788,7 @@ function makeSdfHandle(raw) {
 		onion(thickness) {
 			return makeSdfHandle(this.value.onion(thickness));
 		},
+		...MODULATED_FIELD_METHODS,
 		translate(x, y, z) {
 			return makeSdfHandle(this.value.translate(x, y, z));
 		},
@@ -857,6 +875,127 @@ function torus(major, minor, id) {
 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 = {
@@ -6472,9 +6611,17 @@ 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;

package/dist/brepjs.js

@@ -25,7 +25,7 @@ import { t as cornerFinder } from "./cornerFinder-B8GvvW0U.js";
 import { a as fuseBlueprints, c as roundedRectangleBlueprint, i as cutBlueprints, n as fuse2D, o as intersectBlueprints, r as intersect2D, s as polysidesBlueprint, t as cut2D } from "./boolean2D-BNWuFXK_.js";
 import { S as reverseCurve, _ as curve2dIsOnCurve, a as isInside2D, b as curve2dSplitAt, c as scale2D, d as stretch2D, f as toSVGPathD, g as curve2dFirstPoint, h as curve2dDistanceFrom, i as getOrientation2D, l as sketchOnFace2D, m as curve2dBoundingBox, n as createCompoundBlueprint, o as mirror2D, p as translate2D, r as getBounds2D, s as rotate2D, t as createBlueprint, u as sketchOnPlane2D, v as curve2dLastPoint, x as curve2dTangentAt, y as curve2dParameter } from "./blueprintFns-BNhsXv6q.js";
 import { a as importSVG, c as blueprintToDXF, d as exportGltf, f as exportOBJ, i as exportSTEPConfigured, l as exportDXF, n as importSTEP, o as importSVGPathD, r as importSTL, s as exportThreeMF, t as importIGES, u as exportGlb } from "./importFns-1SHLSNtG.js";
-import { a as guidedSweep, c as sweep, i as complexExtrude, l as twistExtrude, n as extrudeAll, o as multiSectionSweep, r as revolve$1, s as supportExtrude, t as extrude$1 } from "./extrudeFns-CMr1tf7I.js";
+import { a as guidedSweep, c as sweep$1, i as complexExtrude, l as twistExtrude, n as extrudeAll, o as multiSectionSweep, r as revolve$1, s as supportExtrude, t as extrude$1 } from "./extrudeFns-CMr1tf7I.js";
 import { a as Sketch, b as loftAll, c as compoundSketchLoft, d as sketchFace, f as sketchLoft, h as sketchWires, i as Sketches, l as compoundSketchRevolve, m as sketchSweep, n as getFont, o as compoundSketchExtrude, p as sketchRevolve, r as loadFont, s as compoundSketchFace, t as textBlueprints, u as sketchExtrude, v as CompoundSketch, y as loft$1 } from "./textBlueprints-BXGrW7Ak.js";
 import { a as makeProjectedEdges, i as projectEdges, n as cameraLookAt, r as createCamera, s as isProjectionPlane, t as cameraFromPlane } from "./cameraFns-k787od3u.js";
 import { n as textMetrics, r as sketchText, t as fontMetrics } from "./textMetrics-V7TXOETY.js";
@@ -740,6 +740,23 @@ function sdfDeletable(raw) {
 		}
 	};
 }
+/** 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 = createKernelHandle(sdfDeletable(raw));
 	return {
@@ -782,6 +799,7 @@ function makeSdfHandle(raw) {
 		onion(thickness) {
 			return makeSdfHandle(this.value.onion(thickness));
 		},
+		...MODULATED_FIELD_METHODS,
 		translate(x, y, z) {
 			return makeSdfHandle(this.value.translate(x, y, z));
 		},
@@ -868,6 +886,127 @@ function torus(major, minor, id) {
 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 err(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 err(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 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 (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 err(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 = 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 (isErr(engine)) return engine;
+	try {
+		return ok(makeScalarFieldHandle(make(engine.value)));
+	} catch (cause) {
+		return err(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 = {
@@ -3496,7 +3635,7 @@ function createWrappedCurve(val) {
 		isClosed: () => curveIsClosed(val),
 		sweep(spine, opts) {
 			if (!isWire(val)) throw new Error("sweep requires a Wire");
-			const result = unwrapOrThrow(sweep(asClosedWire(val), resolve(spine), opts));
+			const result = unwrapOrThrow(sweep$1(asClosedWire(val), resolve(spine), opts));
 			return wrap3D(Array.isArray(result) ? result[0] : result);
 		}
 	};
@@ -4309,7 +4448,7 @@ var construction_exports = /* @__PURE__ */ __exportAll({
 	supportExtrude: () => supportExtrude,
 	surfaceFromGrid: () => surfaceFromGrid,
 	surfaceFromImage: () => surfaceFromImage,
-	sweep: () => sweep,
+	sweep: () => sweep$1,
 	twistExtrude: () => twistExtrude
 });
 //#endregion
@@ -6000,4 +6139,4 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	withEvaluator: () => withEvaluator
 });
 //#endregion
-export { BaseSketcher2d, BlueprintSketcher, BrepBugError, BrepErrorCode, BrepWrapperError, BrepkitAdapter, CompoundSketch, DEFAULT_CAPABILITIES, DEG2RAD, DisposalScope, EXACT_BREP_CAPABILITIES, FaceSketcher, HASH_CODE_MAX, OK, OcctWasmAdapter, RAD2DEG, Sketch, Sketcher, Sketches, addChild, addHoles, addMate, addStep, adjacentFaces, all, andThen, applyGlue, applyMatrix, approximateCurve, as2D, as3D, asTopo, assignRoles, autoHeal, bezier, blueprintToDXF, booleanPipeline, booleans_exports as booleans, boss, box, bsplineApprox, bug, cameraFromPlane, cameraLookAt, captureHint, cast, castShape, castShape3D, chamfer, chamferDistAngle as chamferDistAngleShape, chamferWithEvolution, checkAllInterferences, checkBoolean, checkInterference, circle, circularPattern, classifyPointOnFace, clearMeshCache, clone, closedWire, collect, collectShapes, colorFaces, colorShape, complexExtrude, composeTransforms, compound, compoundSketchExtrude, compoundSketchFace, compoundSketchLoft, compoundSketchRevolve, computationError, computeStraightSkeleton, cone, construction_exports as construction, convexHull, cornerFinder, countNodes, createAssembly, createAssemblyNode, createBlueprint, createCamera, createCompound, createCompoundBlueprint, createDistanceQuery, createEdge, createFace, createHandle, createHistory, createKernelHandle, createMeshCache, createNamedPlane, createOperationRegistry, createPlane, createRef, createRegistry, createShell, createSolid, createTaskQueue, createVertex, createWire, createWorkerClient, createWorkerHandler, csg_exports as csg, currentQuality, curve2dBoundingBox, curve2dDistanceFrom, curve2dFirstPoint, curve2dIsOnCurve, curve2dLastPoint, curve2dParameter, curve2dSplitAt, curve2dTangentAt, curveEndPoint, curveIsClosed, curveIsPeriodic, curveLength, curvePeriod, curvePointAt, curveStartPoint, curveTangentAt, cut, cut2D, cutAll, cutAllBisect, cutBlueprints, cutWithEvolution, cylinder, defaultScorer, dequeueTask, describe, deserializeDrawing, deserializeHistory, fromBREP as deserializeShape, downcast, draft, draw, drawCircle, drawEllipse, drawFaceOutline, drawParametricFunction, drawPointsInterpolation, drawPolysides, drawProjection, drawRectangle, drawRoundedRectangle, drawSingleCircle, drawSingleEllipse, drawText, drawingChamfer, drawingCut, drawingFillet, drawingFuse, drawingIntersect, drawingToSketchOnPlane, drill, edgeFinder, edgesOfFace, ellipse, ellipseArc, ellipsoid, enqueueTask, err, exportAssemblySTEP, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, extrude, extrudeAll, face, faceCenter, faceFinder, faceGeomType, faceOrientation, facesOfEdge, fieldBoolean, fieldContour, fieldOffset, fieldReinit, fieldShell, fill, filledFace, fillet, filletWithEvolution, findFacesByTag, findNode, findStep, fixSelfIntersection, fixShape, flatMap, flatten, flipFaceOrientation, flipOrientation, fontMetrics, fromBREP$1 as fromBREP, fromKernelDir, fromKernelPnt, fromKernelVec, fromNullable, fuse, fuse2D, fuseAll, fuseAllBisect, fuseBlueprints, fuseWithEvolution, gearGeometry, getActiveVoxelId, getBounds, getBounds2D, getCompSolids, getCurveType, getDisposalStats, getEdges, getFaceColor, getFaceOrigins, getFaceTags, getFaces, getFont, getHashCode, getShape as getHistoryShape, getKernel, getKernelCapabilities, getKernelTier, getNurbsCurveData, getNurbsSurfaceData, getOrientation, getOrientation2D, getPerformanceStats, getShapeColor, getShapeKind, getShells, getSingleFace, getSolids, getSurfaceType, getTagMetadata, getVertices, getVoxel, getWires, guidedSweep, heal, healFace, healSolid, healWire, helix, hull, importDXF, importGLB, importIGES, importOBJ, importSTEP, importSTL, importSVG, importSVGPathD, importThreeMF, init, initFromManifold, initFromOC, initVoxel, innerWires, interpolateCurve, intersect, intersect2D, intersectBlueprints, intersectWithEvolution, invalidateShapeCache, ioNs_exports as io, ioError, is2D, is3D, isChamferRadius, isClosedWire, isCompSolid, isCompound, isDisposeRequest, isEdge, isEmpty, isEqualShape, isErr, isErrorResponse, isFace, isFilletRadius, isInitRequest, isInside2D, isLive, isManifoldShell, isNumber, isOk, isOperationRequest, isOrientedFace, isPlanarFace, isPlanarWire, isProjectionPlane, isEmpty$1 as isQueueEmpty, isSameShape, isShape1D, isShape3D, isShell, isSolid, isSuccessResponse, isValid, isValidSolid, isVertex, isWire, iterCompSolids, iterEdges, iterFaces, iterShells, iterSolids, iterTopo, iterVertices, iterWires, kernelCall, kernelCallRaw, kernelCallScoped, kernelError, latticeInfill, latticeInfillShape, line, linearPattern, loadFont, loft, loftAll, makeBaseBox, makeExternalGear, makeInternalGear, makePlane, makePlanetaryGear, makeProjectedEdges, manifoldShell, map, mapBoth, mapErr, match, measureArea, measureCurvatureAt, measureCurvatureAtMid, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps, measurement_exports as measurement, mesh, meshEdges, meshMultiLOD, minkowski, mirror, mirror2D, mirrorDrawing, mirrorJoin, modifiers_exports as modifiers, modifyStep, moduleInitError, multiSectionSweep, normalAt, offset, offsetFace, offsetMesh, offsetShape, offsetWire2D, ok, or, orElse, organiseBlueprints, orientedFace, outerWire, patterns_exports as patterns, pendingCount, pipeline, pivotPlane, planarFace, planarWire, planetPlacements, pocket, pointOnSurface, pointsInside, polygon, polyhedron, polysideInnerRadius, polysidesBlueprint, positionOnCurve, prewarm, primitives_exports as primitives, projectEdges, projectPointOnFace, query_exports as query, queryError, rectangularPattern, registerHandler, registerKernel, registerKernelTier, registerOperation, registerShape, registerVoxel, rejectAll, removeChild, removeHolesFromFace, repairMesh, replayFrom, replayHistory, resetDisposalStats, resetPerformanceStats, resize, resolve, resolve3D, resolveDirection, resolvePlane, resolveRef, reverseCurve, revolve, roof, rotate, rotate2D, rotateDrawing, roundedRectangleBlueprint, scale, scale2D, scaleDrawing, box$1 as sdfBox, capsule as sdfCapsule, cone$1 as sdfCone, cylinder$1 as sdfCylinder, plane as sdfPlane, roundedBox as sdfRoundedBox, sphere as sdfSphere, torus as sdfTorus, 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$1 as 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$1 as torus, tpmsLattice, transformCopy, transforms_exports as transforms, translate, translate2D, translateDrawing, translatePlane, tryCatch, tryCatchAsync, twistExtrude, typeCastError, undoLast, unsupportedError, unwrap, unwrapErr, unwrapOr, unwrapOrElse, updateNode, updateRoles, uvBounds, uvCoordinates, validSolid, validatePlanetary, validationError, variableFillet, vecAdd, vecAngle, vecCross, vecDistance, vecDot, vecEquals, vecIsZero, vecLength, vecLengthSq, vecNegate, vecNormalize, vecProjectToPlane, vecRepr, vecRotate, vecScale, vecSub, vertex, vertexFinder, vertexPosition, verticesOfEdge, voxelBoolean, voxelBooleanField, voxelBooleanFieldShapes, voxelBooleanShapes, voxelField, voxelFieldFromShape, walkAssembly, windingNumbers, wire, wireFinder, wireLoop, wiresOfFace, withKernel, withKernelDir, withKernelPnt, withKernelVec, withQuality, withScope, withScopeResult, withScopeResultAsync, withTier, zip as zipResults };
+export { BaseSketcher2d, BlueprintSketcher, BrepBugError, BrepErrorCode, BrepWrapperError, BrepkitAdapter, CompoundSketch, DEFAULT_CAPABILITIES, DEG2RAD, DisposalScope, EXACT_BREP_CAPABILITIES, FaceSketcher, HASH_CODE_MAX, OK, OcctWasmAdapter, RAD2DEG, Sketch, Sketcher, Sketches, addChild, addHoles, addMate, addStep, adjacentFaces, all, andThen, applyGlue, applyMatrix, approximateCurve, as2D, as3D, asTopo, assignRoles, autoHeal, bezier, blueprintToDXF, booleanPipeline, booleans_exports as booleans, boss, box, bsplineApprox, bug, cameraFromPlane, cameraLookAt, captureHint, cast, castShape, castShape3D, chamfer, chamferDistAngle as chamferDistAngleShape, chamferWithEvolution, checkAllInterferences, checkBoolean, checkInterference, circle, circularPattern, classifyPointOnFace, clearMeshCache, clone, closedWire, collect, collectShapes, colorFaces, colorShape, complexExtrude, composeTransforms, compound, compoundSketchExtrude, compoundSketchFace, compoundSketchLoft, compoundSketchRevolve, computationError, computeStraightSkeleton, cone, construction_exports as construction, convexHull, cornerFinder, countNodes, createAssembly, createAssemblyNode, createBlueprint, createCamera, createCompound, createCompoundBlueprint, createDistanceQuery, createEdge, createFace, createHandle, createHistory, createKernelHandle, createMeshCache, createNamedPlane, createOperationRegistry, createPlane, createRef, createRegistry, createShell, createSolid, createTaskQueue, createVertex, createWire, createWorkerClient, createWorkerHandler, csg_exports as csg, currentQuality, curve2dBoundingBox, curve2dDistanceFrom, curve2dFirstPoint, curve2dIsOnCurve, curve2dLastPoint, curve2dParameter, curve2dSplitAt, curve2dTangentAt, curveEndPoint, curveIsClosed, curveIsPeriodic, curveLength, curvePeriod, curvePointAt, curveStartPoint, curveTangentAt, cut, cut2D, cutAll, cutAllBisect, cutBlueprints, cutWithEvolution, cylinder, defaultScorer, dequeueTask, describe, deserializeDrawing, deserializeHistory, fromBREP as deserializeShape, downcast, draft, draw, drawCircle, drawEllipse, drawFaceOutline, drawParametricFunction, drawPointsInterpolation, drawPolysides, drawProjection, drawRectangle, drawRoundedRectangle, drawSingleCircle, drawSingleEllipse, drawText, drawingChamfer, drawingCut, drawingFillet, drawingFuse, drawingIntersect, drawingToSketchOnPlane, drill, edgeFinder, edgesOfFace, ellipse, ellipseArc, ellipsoid, enqueueTask, err, exportAssemblySTEP, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, extrude, extrudeAll, face, faceCenter, faceFinder, faceGeomType, faceOrientation, facesOfEdge, fieldBoolean, fieldContour, fieldOffset, fieldReinit, fieldShell, fill, filledFace, fillet, filletWithEvolution, findFacesByTag, findNode, findStep, fixSelfIntersection, fixShape, flatMap, flatten, flipFaceOrientation, flipOrientation, fontMetrics, fromBREP$1 as fromBREP, fromKernelDir, fromKernelPnt, fromKernelVec, fromNullable, fuse, fuse2D, fuseAll, fuseAllBisect, fuseBlueprints, fuseWithEvolution, gearGeometry, getActiveVoxelId, getBounds, getBounds2D, getCompSolids, getCurveType, getDisposalStats, getEdges, getFaceColor, getFaceOrigins, getFaceTags, getFaces, getFont, getHashCode, getShape as getHistoryShape, getKernel, getKernelCapabilities, getKernelTier, getNurbsCurveData, getNurbsSurfaceData, getOrientation, getOrientation2D, getPerformanceStats, getShapeColor, getShapeKind, getShells, getSingleFace, getSolids, getSurfaceType, getTagMetadata, getVertices, getVoxel, getWires, guidedSweep, heal, healFace, healSolid, healWire, helix, hull, importDXF, importGLB, importIGES, importOBJ, importSTEP, importSTL, importSVG, importSVGPathD, importThreeMF, init, initFromManifold, initFromOC, initVoxel, innerWires, interpolateCurve, intersect, intersect2D, intersectBlueprints, intersectWithEvolution, invalidateShapeCache, ioNs_exports as io, ioError, is2D, is3D, isChamferRadius, isClosedWire, isCompSolid, isCompound, isDisposeRequest, isEdge, isEmpty, isEqualShape, isErr, isErrorResponse, isFace, isFilletRadius, isInitRequest, isInside2D, isLive, isManifoldShell, isNumber, isOk, isOperationRequest, isOrientedFace, isPlanarFace, isPlanarWire, isProjectionPlane, isEmpty$1 as isQueueEmpty, isSameShape, isShape1D, isShape3D, isShell, isSolid, isSuccessResponse, isValid, isValidSolid, isVertex, isWire, iterCompSolids, iterEdges, iterFaces, iterShells, iterSolids, iterTopo, iterVertices, iterWires, kernelCall, kernelCallRaw, kernelCallScoped, kernelError, latticeInfill, latticeInfillShape, line, linearPattern, loadFont, loft, loftAll, makeBaseBox, makeExternalGear, makeInternalGear, makePlane, makePlanetaryGear, makeProjectedEdges, manifoldShell, map, mapBoth, mapErr, match, measureArea, measureCurvatureAt, measureCurvatureAtMid, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps, measurement_exports as measurement, mesh, meshEdges, meshMultiLOD, minkowski, mirror, mirror2D, mirrorDrawing, mirrorJoin, modifiers_exports as modifiers, modifyStep, moduleInitError, multiSectionSweep, normalAt, offset, offsetFace, offsetMesh, offsetShape, offsetWire2D, ok, or, orElse, organiseBlueprints, orientedFace, outerWire, patterns_exports as patterns, pendingCount, pipeline, pivotPlane, planarFace, planarWire, planetPlacements, pocket, pointOnSurface, pointsInside, polygon, polyhedron, polysideInnerRadius, polysidesBlueprint, positionOnCurve, prewarm, primitives_exports as primitives, projectEdges, projectPointOnFace, query_exports as query, queryError, rectangularPattern, registerHandler, registerKernel, registerKernelTier, registerOperation, registerShape, registerVoxel, rejectAll, removeChild, removeHolesFromFace, repairMesh, replayFrom, replayHistory, resetDisposalStats, resetPerformanceStats, resize, resolve, resolve3D, resolveDirection, resolvePlane, resolveRef, reverseCurve, revolve, roof, rotate, rotate2D, rotateDrawing, roundedRectangleBlueprint, scale, scale2D, scaleDrawing, box$1 as sdfBox, capsule as sdfCapsule, cone$1 as sdfCone, cylinder$1 as sdfCylinder, fieldAxialRamp as sdfFieldAxialRamp, fieldClamp as sdfFieldClamp, fieldConst as sdfFieldConst, fieldFromSdf as sdfFieldFromSdf, fieldRadialRamp as sdfFieldRadialRamp, lattice as sdfLattice, plane as sdfPlane, roundedBox as sdfRoundedBox, sphere as sdfSphere, strutLattice as sdfStrutLattice, sweep as sdfSweep, torus as sdfTorus, 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$1 as sphere, split, stepCount, stepsFrom, stretch2D, subFace, supportExtrude, supportsConstraintSketch, supportsProjection, surfaceFromGrid, surfaceFromImage, sweep$1 as sweep, tagFaces, tangentArc, tap, tapErr, textBlueprints, textMetrics, thicken, threePointArc, toBREP, toBufferGeometryData, toGroupedBufferGeometryData, toKernelVec, toLODGeometryData, toLineGeometryData, toSVGPathD, toVec2, toVec3, torus$1 as torus, tpmsLattice, transformCopy, transforms_exports as transforms, translate, translate2D, translateDrawing, translatePlane, tryCatch, tryCatchAsync, twistExtrude, typeCastError, undoLast, unsupportedError, unwrap, unwrapErr, unwrapOr, unwrapOrElse, updateNode, updateRoles, uvBounds, uvCoordinates, validSolid, validatePlanetary, validationError, variableFillet, vecAdd, vecAngle, vecCross, vecDistance, vecDot, vecEquals, vecIsZero, vecLength, vecLengthSq, vecNegate, vecNormalize, vecProjectToPlane, vecRepr, vecRotate, vecScale, vecSub, vertex, vertexFinder, vertexPosition, verticesOfEdge, voxelBoolean, voxelBooleanField, voxelBooleanFieldShapes, voxelBooleanShapes, voxelField, voxelFieldFromShape, walkAssembly, windingNumbers, wire, wireFinder, wireLoop, wiresOfFace, withKernel, withKernelDir, withKernelPnt, withKernelVec, withQuality, withScope, withScopeResult, withScopeResultAsync, withTier, zip as zipResults };

package/dist/implicit/index.d.ts

@@ -7,5 +7,7 @@
  * combinators into an {@link SdfHandle}, which rasterizes to a banded-SDF
  * {@link VoxelFieldHandle} for contour / offset / shell.
  */
-export type { SdfHandle, SdfBounds } from './sdfFns.js';
-export { sphere, box, roundedBox, cylinder, cone, capsule, torus, plane } from './sdfFns.js';
+export type { SdfHandle, SdfBounds, SdfSweepOptions, ScalarFieldHandle, LatticeKind, } from './sdfFns.js';
+export { sphere, box, roundedBox, cylinder, cone, capsule, torus, plane, sweep } from './sdfFns.js';
+export { fieldConst, fieldAxialRamp, fieldRadialRamp, fieldFromSdf, fieldClamp } from './sdfFns.js';
+export { lattice, strutLattice } from './sdfFns.js';

package/dist/implicit/sdfFns.d.ts

@@ -1,5 +1,5 @@
 import { Result } from '../core/result.js';
-import { WasmSdf } from '../voxel/engine.js';
+import { WasmSdf, WasmScalarField } from '../voxel/engine.js';
 import { VoxelFieldHandle, VoxelFieldOptions } from '../voxel/fieldFns.js';
 /** Explicit world bounds `[min..max]` for {@link SdfHandle.rasterizeIn}. */
 export interface SdfBounds {
@@ -33,6 +33,10 @@ export interface SdfHandle {
     round(radius: number): SdfHandle;
     shell(thickness: number): SdfHandle;
     onion(thickness: number): SdfHandle;
+    offsetField(field: ScalarFieldHandle): SdfHandle;
+    roundField(field: ScalarFieldHandle): SdfHandle;
+    shellField(field: ScalarFieldHandle): SdfHandle;
+    smoothUnionField(other: SdfHandle, field: ScalarFieldHandle): SdfHandle;
     translate(x: number, y: number, z: number): SdfHandle;
     rotate(ax: number, ay: number, az: number, angle: number): SdfHandle;
     scale(s: number): SdfHandle;
@@ -57,3 +61,76 @@ export declare function capsule(a: [number, number, number], b: [number, number,
 export declare function torus(major: number, minor: number, id?: string): Result<SdfHandle>;
 /** A half-space: the plane through `h·n` with outward normal `n` (normalized). */
 export declare function plane(n: [number, number, number], h: number, id?: string): Result<SdfHandle>;
+/** Options for {@link sweep}. */
+export interface SdfSweepOptions {
+    /** Close the spine into a loop, skipping the open-end caps. Default `false`. */
+    closed?: boolean;
+}
+/**
+ * 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.
+ */
+export declare function sweep(spine: [number, number, number][], profile: SdfHandle, opts?: SdfSweepOptions, id?: string): Result<SdfHandle>;
+/** TPMS family selector for {@link lattice}. */
+export type LatticeKind = 'gyroid' | 'schwarzP' | 'diamond';
+/**
+ * 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.
+ */
+export declare function lattice(kind: LatticeKind, period: ScalarFieldHandle, thickness: ScalarFieldHandle, id?: string): Result<SdfHandle>;
+/**
+ * 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.
+ */
+export declare function strutLattice(period: number, radius: ScalarFieldHandle, id?: string): Result<SdfHandle>;
+/**
+ * A disposable handle around a position-varying scalar field (brepjs-implicit Phase
+ * 2b). Fed to the {@link SdfHandle} modulated operators (`offsetField`, `shellField`,
+ * …) to vary an operator parameter per voxel. Like {@link SdfHandle} it is a value —
+ * the constructors return fresh fields — and dispose is mandatory (`using`, or
+ * `[Symbol.dispose]()`) to free the WASM allocation.
+ */
+export interface ScalarFieldHandle {
+    /** The wrapped WASM field. Throws if the handle has been disposed. */
+    readonly value: WasmScalarField;
+    /** Whether the backing WASM field has been freed. */
+    readonly disposed: boolean;
+    [Symbol.dispose](): void;
+}
+/** A spatially constant field — reproduces a constant operator parameter exactly. */
+export declare function fieldConst(c: number, id?: string): Result<ScalarFieldHandle>;
+/**
+ * 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).
+ */
+export declare function fieldAxialRamp(axis: number, a: number, b: number, lo: number, hi: number, id?: string): Result<ScalarFieldHandle>;
+/**
+ * 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).
+ */
+export declare function fieldRadialRamp(center: [number, number, number], axis: number, r0: number, r1: number, lo: number, hi: number, id?: string): Result<ScalarFieldHandle>;
+/**
+ * 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}.
+ */
+export declare function fieldFromSdf(sdf: SdfHandle, scale: number, offset: number, id?: string): Result<ScalarFieldHandle>;
+/**
+ * Clamp another field's value to `[min, max]` — bounds an otherwise unbounded
+ * {@link fieldFromSdf} so it can safely drive offset/shell.
+ */
+export declare function fieldClamp(field: ScalarFieldHandle, min: number, max: number, id?: string): Result<ScalarFieldHandle>;

package/dist/index.d.ts

@@ -40,8 +40,8 @@ export { importSVGPathD, importSVG, type SVGImportOptions } from './io/svgImport
 export { exportSTEPConfigured, type StepExportOptions, type StepExportPart, } from './io/stepConfigFns.js';
 export { initVoxel, registerVoxel, getVoxel, getActiveVoxelId, windingNumbers, pointsInside, repairMesh, offsetMesh, shellMesh, voxelBoolean, offsetShape, shellShape, voxelBooleanShapes, voxelField, voxelBooleanField, fieldBoolean, fieldOffset, fieldShell, fieldReinit, fieldContour, voxelFieldFromShape, voxelBooleanFieldShapes, shapeToMeshInput, } from './voxel/index.js';
 export type { VoxelEngine, VoxelMeshInput, VoxelRepairResult, RepairOptions, VoxelOpOptions, VoxelFieldHandle, VoxelFieldOptions, VoxelBooleanOp, } from './voxel/index.js';
-export { sphere as sdfSphere, box as sdfBox, roundedBox as sdfRoundedBox, cylinder as sdfCylinder, cone as sdfCone, capsule as sdfCapsule, torus as sdfTorus, plane as sdfPlane, } from './implicit/index.js';
-export type { SdfHandle, SdfBounds } from './implicit/index.js';
+export { sphere as sdfSphere, box as sdfBox, roundedBox as sdfRoundedBox, cylinder as sdfCylinder, cone as sdfCone, capsule as sdfCapsule, torus as sdfTorus, plane as sdfPlane, sweep as sdfSweep, fieldConst as sdfFieldConst, fieldAxialRamp as sdfFieldAxialRamp, fieldRadialRamp as sdfFieldRadialRamp, fieldFromSdf as sdfFieldFromSdf, fieldClamp as sdfFieldClamp, lattice as sdfLattice, strutLattice as sdfStrutLattice, } from './implicit/index.js';
+export type { SdfHandle, SdfBounds, SdfSweepOptions, ScalarFieldHandle, LatticeKind as SdfLatticeKind, } from './implicit/index.js';
 export { latticeInfill, latticeInfillShape, tpmsLattice } from './lattice/index.js';
 export type { LatticeType, LatticeOptions, LatticeBounds } from './lattice/index.js';
 export { default as Sketcher } from './sketching/sketcher.js';

package/dist/voxel/engine.d.ts

@@ -36,9 +36,40 @@ export interface VoxelEngine {
      * satisfied by the generated `Sdf` wasm-bindgen class.
      */
     Sdf: WasmSdfConstructor;
+    /**
+     * Position-varying scalar fields (brepjs-implicit Phase 2b). Static constructors
+     * compose an opaque field that the `Sdf` modulated operators sample per voxel.
+     * Structurally satisfied by the generated `ScalarField` wasm-bindgen class.
+     */
+    ScalarField: WasmScalarFieldConstructor;
     /** Engine artifact version, for loader/artifact compatibility checks. */
     version(): string;
 }
+/**
+ * Static surface of the wasm `ScalarField` class: the constructors that seed a
+ * position-varying field. Each returns a fresh {@link WasmScalarField}; the ramp
+ * constructors throw (as a JS exception) on an out-of-range axis. Structurally
+ * satisfied by the generated `ScalarField` class.
+ */
+export interface WasmScalarFieldConstructor {
+    constant(c: number): WasmScalarField;
+    axial_ramp(axis: number, a: number, b: number, lo: number, hi: number): WasmScalarField;
+    radial_ramp(cx: number, cy: number, cz: number, axis: number, r0: number, r1: number, lo: number, hi: number): WasmScalarField;
+    from_sdf(sdf: WasmSdf, scale: number, offset: number): WasmScalarField;
+    clamp(field: WasmScalarField, min: number, max: number): WasmScalarField;
+}
+/**
+ * An opaque position-varying scalar field. A value, not a builder (each constructor
+ * returns a fresh field). Fed to the `Sdf` modulated operators
+ * ({@link WasmSdf.offset_field} et al.) to vary an operator parameter per voxel.
+ * `free()` releases the backing WASM allocation. Structurally satisfied by the
+ * generated `ScalarField` wasm-bindgen class.
+ */
+export interface WasmScalarField {
+    /** Release the backing WASM allocation (wasm-bindgen lifecycle). */
+    free(): void;
+    [Symbol.dispose](): void;
+}
 /**
  * Static surface of the wasm `Sdf` class: the primitive constructors that seed an
  * expression tree (centered at the origin unless noted). Each returns a fresh
@@ -53,6 +84,24 @@ export interface WasmSdfConstructor {
     capsule(ax: number, ay: number, az: number, bx: number, by: number, bz: number, r: number): WasmSdf;
     torus(major: number, minor: number): WasmSdf;
     plane(nx: number, ny: number, nz: number, h: number): WasmSdf;
+    /**
+     * Sweep an in-plane `profile` along `spine` (flat xyz, length 3·N, N >= 2)
+     * using rotation-minimizing frames. `closed` skips the end caps. Throws (as a
+     * JS exception) on fewer than two stations or a degenerate spine.
+     */
+    sweep(spine: Float64Array, profile: WasmSdf, closed: boolean): WasmSdf;
+    /**
+     * A graded/conformal TPMS lattice node (`kind_tag`: 0=Gyroid, 1=SchwarzP,
+     * 2=Diamond) with per-position `period`/`thickness`. Periodic/infinite — clip via
+     * `intersection` before rasterize. Throws (as a JS exception) on a bad `kind_tag`.
+     */
+    lattice(kind_tag: number, period: WasmScalarField, thickness: WasmScalarField): WasmSdf;
+    /**
+     * A cubic beam/strut lattice node with per-position `radius`. Periodic/infinite —
+     * clip via `intersection` before rasterize. Throws (as a JS exception) on a
+     * non-positive `period`.
+     */
+    strut_lattice(period: number, radius: WasmScalarField): WasmSdf;
 }
 /**
  * An opaque analytic SDF expression. Every combinator CLONES into a new node and
@@ -72,6 +121,10 @@ export interface WasmSdf {
     round(r: number): WasmSdf;
     shell(t: number): WasmSdf;
     onion(t: number): WasmSdf;
+    offset_field(f: WasmScalarField): WasmSdf;
+    round_field(f: WasmScalarField): WasmSdf;
+    shell_field(f: WasmScalarField): WasmSdf;
+    smooth_union_field(other: WasmSdf, k: WasmScalarField): WasmSdf;
     translate(x: number, y: number, z: number): WasmSdf;
     rotate(ax: number, ay: number, az: number, angle: number): WasmSdf;
     scale(s: number): WasmSdf;

package/package.json

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