brepjs 18.67.0 → 18.69.0

package/dist/implicit/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Field-first implicit CAD domain (ADR-0013, brepjs-implicit Phase 1).
+ *
+ * An analytic SDF expression tree that rasterizes DIRECTLY into the voxel
+ * substrate's dense grid with no input mesh — the field-first twin of the
+ * mesh-first voxel path. Primitives compose through CSG / smooth / domain
+ * combinators into an {@link SdfHandle}, which rasterizes to a banded-SDF
+ * {@link VoxelFieldHandle} for contour / offset / shell.
+ */
+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

@@ -0,0 +1,136 @@
+import { Result } from '../core/result.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 {
+    min: [number, number, number];
+    max: [number, number, number];
+}
+/**
+ * A disposable handle around an analytic SDF expression. Every combinator clones
+ * into a NEW wasm node and returns a NEW handle (the wasm `Sdf` is a value, not a
+ * mutable builder), so an `SdfHandle` is immutable — the receiver stays valid and
+ * must be disposed independently. `rasterize` produces a banded-SDF
+ * {@link VoxelFieldHandle} you can boolean / offset / shell / contour.
+ *
+ * Dispose is mandatory: use `using`, or call `[Symbol.dispose]()`, to free the
+ * WASM expression tree. Intermediate handles in a chain (`a.union(b).shell(t)`)
+ * each own a wasm allocation; bind them to `using` or dispose them explicitly.
+ */
+export interface SdfHandle {
+    /** The wrapped WASM expression. Throws if the handle has been disposed. */
+    readonly value: WasmSdf;
+    /** Whether the backing WASM expression has been freed. */
+    readonly disposed: boolean;
+    [Symbol.dispose](): void;
+    union(other: SdfHandle): SdfHandle;
+    intersection(other: SdfHandle): SdfHandle;
+    difference(other: SdfHandle): SdfHandle;
+    smoothUnion(other: SdfHandle, k: number): SdfHandle;
+    smoothIntersection(other: SdfHandle, k: number): SdfHandle;
+    smoothDifference(other: SdfHandle, k: number): SdfHandle;
+    offset(distance: number): 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;
+    /** Rasterize into a banded-SDF field over the expression's analytic bounds. */
+    rasterize(opts?: VoxelFieldOptions): Result<VoxelFieldHandle>;
+    /** Rasterize over explicit world bounds (clips unbounded primitives). */
+    rasterizeIn(bounds: SdfBounds, opts?: VoxelFieldOptions): Result<VoxelFieldHandle>;
+}
+/** A sphere of radius `r`, centered at the origin. */
+export declare function sphere(r: number, id?: string): Result<SdfHandle>;
+/** An axis-aligned box of half-extents `(hx, hy, hz)`, centered at the origin. */
+export declare function box(hx: number, hy: number, hz: number, id?: string): Result<SdfHandle>;
+/** A box with rounded edges of radius `r`. */
+export declare function roundedBox(hx: number, hy: number, hz: number, r: number, id?: string): Result<SdfHandle>;
+/** A capped cylinder, axis +Z, radius `r`, total height `h`, centered at origin. */
+export declare function cylinder(r: number, h: number, id?: string): Result<SdfHandle>;
+/** A capped cone centered at the origin: base radius `r` at z = −h/2 tapering to an apex at z = +h/2. */
+export declare function cone(r: number, h: number, id?: string): Result<SdfHandle>;
+/** A capsule: a line segment `a`→`b` of radius `r`. */
+export declare function capsule(a: [number, number, number], b: [number, number, number], r: number, id?: string): Result<SdfHandle>;
+/** A torus in the XY plane (axis +Z): a `minor`-radius tube on a `major` circle. */
+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,6 +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, 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

@@ -29,9 +29,113 @@ export interface VoxelEngine {
      * satisfied by the generated `VoxelField` wasm-bindgen class.
      */
     VoxelField: WasmVoxelFieldConstructor;
+    /**
+     * Field-first analytic SDF builder (ADR-0013). Static primitive constructors
+     * and combinator methods compose an opaque expression tree that rasterizes
+     * directly into a {@link WasmVoxelField} with no input mesh. Structurally
+     * 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
+ * {@link WasmSdf}. Structurally satisfied by the generated `Sdf` class.
+ */
+export interface WasmSdfConstructor {
+    sphere(r: number): WasmSdf;
+    box_(hx: number, hy: number, hz: number): WasmSdf;
+    rounded_box(hx: number, hy: number, hz: number, r: number): WasmSdf;
+    cylinder(r: number, h: number): WasmSdf;
+    cone(r: number, h: number): WasmSdf;
+    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
+ * returns a fresh `WasmSdf` (wasm-bindgen has no shared borrow across calls), so an
+ * `Sdf` is a value, not a mutable builder. `rasterize` builds a banded-SDF
+ * {@link WasmVoxelField}; `free()` releases the backing WASM expression tree.
+ * Structurally satisfied by the generated `Sdf` wasm-bindgen class.
+ */
+export interface WasmSdf {
+    union(other: WasmSdf): WasmSdf;
+    intersection(other: WasmSdf): WasmSdf;
+    difference(other: WasmSdf): WasmSdf;
+    smooth_union(other: WasmSdf, k: number): WasmSdf;
+    smooth_intersection(other: WasmSdf, k: number): WasmSdf;
+    smooth_difference(other: WasmSdf, k: number): WasmSdf;
+    offset(d: number): 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;
+    /** Rasterize into a banded-SDF dense field over the expression's analytic bounds. */
+    rasterize(resolution: number, padding: number): WasmVoxelField;
+    /** Rasterize over explicit `[min..max]` bounds (clips unbounded primitives). */
+    rasterize_in(min_x: number, min_y: number, min_z: number, max_x: number, max_y: number, max_z: number, resolution: number, padding: number): WasmVoxelField;
+    /** Release the backing WASM expression-tree allocation (wasm-bindgen lifecycle). */
+    free(): void;
+    [Symbol.dispose](): void;
+}
 /**
  * Constructor of the wasm `VoxelField` class. `new VoxelField(verts, tris, res,
  * padding)` voxelizes a mesh into a persistent dense field. Throws (as a JS

package/dist/voxel/fieldFns.d.ts

@@ -45,6 +45,7 @@ export interface VoxelFieldHandle {
     /** Surface-Nets contour the current field to a mesh (the field stays alive). */
     contour(): KernelMeshResult;
 }
+export declare function makeFieldHandle(raw: WasmVoxelField): VoxelFieldHandle;
 /**
  * Voxelize a mesh into a persistent dense {@link VoxelFieldHandle}: one grid you
  * can boolean / offset / shell / reinit in place, then contour once. The handle

package/package.json

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