The SDK API reference

MeshPayload interface

interface MeshPayload

SolveStats interface

interface SolveStats

LogLine interface

interface LogLine

SolveResult interface

interface SolveResult

SolveStepResult interface

interface SolveStepResult extends SolveResult

SolveOptions interface

interface SolveOptions

solveStep function

Parse STEP text (staged via a temp file) and tessellate all solids.

function solveStep(text: string, opts?: SolveOptions): SolveStepResult;

solveStepFile function

Parse a STEP file on disk and tessellate all solids.

function solveStepFile(filePath: string, opts?: SolveOptions): SolveStepResult;

solveStl function

Parse STL from a Buffer/ArrayBuffer or file path.

function solveStl(input: Buffer | ArrayBuffer | string): SolveResult;

writeStep function

Serialize a (possibly modified) StepParser back to STEP text.

function writeStep(parser: StepParser): string;

PcbImportInput interface

CADSF-1750 (PCB [5/10]): where a PCB layout comes from.

interface PcbImportInput

PcbImportOptions interface

CADSF-1750: ops/pcbImport.js options — ops/pcbSolids.js's build knobs plus the import/reader ones.

interface PcbImportOptions

PcbImportBody interface partly typed

interface PcbImportBody

PcbImportResult interface partly typed

interface PcbImportResult

importPcb function

CADSF-1750: read a .kicad_pcb / Gerber X2 set and build it as tagged 2.5D solids (see ops/pcbImport.js).

function importPcb(input: string | PcbImportInput, opts?: PcbImportOptions): PcbImportResult;

LatticeFillCell type

CADSF-1768 (IMPLICIT [5/8]): lattice_fill's cells — TPMS sheets, then strut cells.

type LatticeFillCell = 'gyroid' | 'schwarzP' | 'schwarzD' | 'sc' | 'bcc' | 'fcc' | 'octet' | 'diamond' | 'kelvin' | 'bccz' | 'fccz';

LatticeFillDensity type

Graded feature size: the VALUES are the local strutRadius / sheetThickness in mm.

type LatticeFillDensity = {
    kind?: 'uniform';
} | {
    kind: 'gradient';
    from: number;
    to: number;
    axis: 'x' | 'y' | 'z' | Vec3;
    span?: [
        number,
        number
    ];
} | {
    kind: 'field';
    grid: {
        origin: Vec3;
        spacing: number | Vec3;
        dims: [
            number,
            number,
            number
        ];
        values: number[];
    };
};

LatticeFillOptions interface partly typed

interface LatticeFillOptions

LatticeFillResult interface partly typed

interface LatticeFillResult

latticeFill function partly typed

CADSF-1768: fill a solid's interior with a strut or TPMS lattice under a solid skin (ops/latticeFill.js). Refusals throw with .code (lattice_fill_*) and .remedy.

function latticeFill(parser: StepParser | any, solidId: number | string, opts: LatticeFillOptions): LatticeFillResult;

StepParser class partly typed

class StepParser

StepWriter class partly typed

class StepWriter

StlParser class partly typed

class StlParser

StlExporter class loose 0.x typing

class StlExporter

SurfaceTessellator class partly typed

class SurfaceTessellator

Topology class loose 0.x typing

class Topology

VolumeMesher class loose 0.x typing

class VolumeMesher

Bvh class loose 0.x typing

class Bvh

topology const loose 0.x typing

const topology: Record<string, any>;

MassProperties namespace

GeometryStats namespace

Queries const loose 0.x typing

const Queries: Record<string, any>;

CaeExporter namespace

Vec2 type

type Vec2 = [
    number,
    number
];

Vec3 type

type Vec3 = [
    number,
    number,
    number
];

Profile2D type

A closed planar polygon: do not repeat the first point.

type Profile2D = Vec2[];

Polygon2d interface

CADSF-1748 ops.polygonBoolean: a 2-D region as one outer loop (CCW) and its holes (CW) - the shape ops.rectUnion also returns.

interface Polygon2d

PolygonInput type

What every polygon operation ACCEPTS: a ring, a polygon-with-holes, or any array of those. {outer,holes} is re-wound on the way in.

type PolygonInput = Vec2[] | Polygon2d | Array<Vec2[] | Polygon2d | PolygonInput>;

PolygonPathSegment type

A stroke path: a polyline, or the reader's own segment chain (a line has start/end, an arc start/mid/end), or several of either.

type PolygonPathSegment = {
    kind: 'line';
    start: Vec2;
    end: Vec2;
} | {
    kind: 'arc';
    start: Vec2;
    mid: Vec2;
    end: Vec2;
};

PolygonPath type

type PolygonPath = Vec2[] | PolygonPathSegment[] | Array<Vec2[] | PolygonPathSegment[]>;

Aperture2d type

A brush/flash outline: a round aperture's diameter, or a named convex shape.

type Aperture2d = number | {
    shape?: 'circle' | 'round' | 'rect' | 'oval' | 'obround' | 'roundrect' | 'regular' | 'polygon';
    r?: number;
    d?: number;
    w?: number;
    h?: number;
    rratio?: number;
    vertices?: number;
    rot?: number;
    points?: Vec2[];
};

PolygonBooleanOptions interface

interface PolygonBooleanOptions

SketchPlane interface

An optional sketch frame for extrude(); omitted = world XY, sweep along +Z.

interface SketchPlane

Mat34 interface

A 3×4 rigid/affine transform: m is the 3×3 linear part, t the translation.

interface Mat34

ImplicitBox interface

CADSF-1764 ops.implicit: an axis-aligned box; components may be +-Infinity.

interface ImplicitBox

ImplicitField interface partly typed

CADSF-1764 ops.implicit: a scalar field whose solid is { p : f(p) <= 0 }. IMPLICIT [2-8] rely on f, bbox and exact only. Every field the module builds is 1-Lipschitz (bound), so |f| never overstates the distance to the surface; exactInside / exactOutside say on which side it IS the distance (union is exact outside, intersect exact inside).

interface ImplicitField

ImplicitLocalEvaluator interface

What {@link ImplicitField.localize} returns: f is exact only inside the block it was built for; candidates is how many items it scans.

interface ImplicitLocalEvaluator

ImplicitStrut interface partly typed

A strut: ops/latticeCell.js's record shape (extra keys are ignored).

interface ImplicitStrut

ImplicitMatrix type

A similarity transform: Mat34, or a nested 4x4 (bottom row 0 0 0 1) / 3x4, row-major.

type ImplicitMatrix = Mat34 | number[][];

ImplicitTpmsOptions interface

interface ImplicitTpmsOptions

ImplicitLatticeField interface

interface ImplicitLatticeField extends ImplicitField

ImplicitLatticeOptions interface

interface ImplicitLatticeOptions

ImplicitGrid interface

mapGrid's dense sample (x fastest: index i + nx (j + ny k)).

interface ImplicitGrid extends Float32Array

ImplicitSparseSampleOptions interface

ops.implicitGrid (CADSF-1765, IMPLICIT [2/8]): sparse narrow-band sampling, face-consistent marching cubes, manifold dual contouring and a mesh census. See ops/implicitGrid.js's header.

interface ImplicitSparseSampleOptions

ImplicitSparseGrid interface

sparseSample's grid: 8^3 tiles of Float32 node values, keyed tx + TX (ty + TY tz).

interface ImplicitSparseGrid

ImplicitExtractOptions interface

Options shared by marchingCubes() and dualContouring().

interface ImplicitExtractOptions

ImplicitMarchingCubesOptions interface

interface ImplicitMarchingCubesOptions extends ImplicitExtractOptions

ImplicitDualContouringOptions interface

interface ImplicitDualContouringOptions extends ImplicitExtractOptions

ImplicitDualContouringStats interface partly typed

dualContouring()'s mesh.stats shape (ImplicitMesh.stats is Record<string, any> for both extractors; this is what kind:'dualContouring' actually carries). Purely instrumentation -- nothing here is a knob.

interface ImplicitDualContouringStats

ImplicitCensusOptions interface

interface ImplicitCensusOptions

ImplicitMeshCensus interface partly typed

census(): measured, never assumed.

interface ImplicitMeshCensus

ImplicitMesh interface partly typed

An extracted mesh: flat buffers plus (unless record:false) ops/meshHeal.js's shape.

interface ImplicitMesh

ImplicitMeasureOptions interface

ops.implicitMeasure (CADSF-1766, IMPLICIT [3/8]): volume / centroid / inertia by a narrow-band octree with exact marching tetrahedra, area from the DC mesh, exact containment. See ops/implicitMeasure.js's header.

interface ImplicitMeasureOptions

ImplicitVolumeResult interface

interface ImplicitVolumeResult

ImplicitRichardsonOptions interface

interface ImplicitRichardsonOptions extends ImplicitMeasureOptions

ImplicitRichardsonResult interface

interface ImplicitRichardsonResult

ImplicitAreaOptions interface partly typed

interface ImplicitAreaOptions

LatticeCellType type

ops.latticeCell / ops.latticeOracle (CADSF-1738, LATTICE [2/9]): periodic unit-cell strut lattices and the Sobol Monte-Carlo oracle that validates them against closed forms. See ops/latticeCell.js and ops/latticeOracle.js's headers for the basis + connectivity-rule engine, the JUNGLEGYM T-joint trim, and the ray-scaled pairwiseSteinmetz correction.

type LatticeCellType = 'SC' | 'BCC' | 'BCCZ' | 'FCC' | 'FCCZ' | 'OCTET' | 'DIAMOND' | 'KELVIN' | 'JUNGLEGYM';

LatticeStrutFamily type

'axis': 1 nonzero displacement component, 'rung': 2, 'diag': 3 -- computed from the generated geometry, not looked up per cell. For JUNGLEGYM the three grid axes (x,y,z) are fixed to 'axis','diag','rung' respectively (JG_FAMILY_BY_AXIS); 'axis' is the convention's "host" (thickest) family.

type LatticeStrutFamily = 'axis' | 'rung' | 'diag';

LatticeRadii type

A flat per-family radius map (with axis as the fallback for any family it does not name) or a function of the strut being resolved.

type LatticeRadii = Partial<Record<LatticeStrutFamily, number>> | ((strut: {
    family: LatticeStrutFamily;
    axis?: number;
    p0: Vec3;
    p1: Vec3;
}) => number);

LatticeStrut interface partly typed

interface LatticeStrut extends ImplicitStrut

LatticeNode interface

interface LatticeNode

LatticeCellOptions interface

interface LatticeCellOptions

LatticeCellResult interface partly typed

interface LatticeCellResult

LatticeOracleSphere interface

A node sphere as ops/latticeOracle.js's internals see it (center c, not p -- distinct from {@link LatticeNode}, which it is built from).

interface LatticeOracleSphere

LatticeOracleOptions interface

interface LatticeOracleOptions

LatticeOracleResult interface

interface LatticeOracleResult

LatticeOracleIndexStats interface

ops.latticeOracle's CADSF-2092 sample index (mc + accel:'bvh' only): a uniform cell grid over the sampling box, one BoxBvh.overlapping() query per cell at build time. perCell is entries / cells; testsPerSample is the measured mean list length actually scanned per Sobol sample (instrumentation, not a knob). bores is the drilled bore list's own grid, same box and dims.

interface LatticeOracleIndexStats

BodyResult interface partly typed

What every body-building op returns: the (fresh or shared) parser that owns the entity graph and the MANIFOLD_SOLID_BREP id inside it. builder is the ops/primitives.js Builder that authored the graph; analytic carries closed-form figures (volume, sweep angle) for cross-checking the mesh.

interface BodyResult

EditResult interface partly typed

Result of an op that edits a body IN PLACE in its parser: the new solid id (the input solid is left intact; callers may retire it).

interface EditResult

EdgeReportEntry interface partly typed

Per-edge outcome of a dress-up op (blend / chamfer routers).

interface EdgeReportEntry

DressUpResult interface

interface DressUpResult extends EditResult

BlendSpec type

Fillet radius law: constant radius, or the symmetric quadratic corner→mid→corner profile along each edge (the dice case).

type BlendSpec = {
    radius: number;
} | {
    corner: number;
    mid: number;
};

ChamferSpec interface partly typed

Chamfer setback: the facet sits distance inside BOTH adjacent faces (a 45° chamfer when they are perpendicular).

interface ChamferSpec

DressUpOptions interface partly typed

interface DressUpOptions

PatternOptions interface partly typed

interface PatternOptions

PatternResult interface

interface PatternResult extends EditResult

HoleSpec interface partly typed

interface HoleSpec

HoleResult interface partly typed

interface HoleResult extends BodyResult

MeshToBrepOrientResult interface

CADSB-1415: ops/meshToBrep.js's own shell-orientation repair -- a route-M (mixed/faceted) solid can sew CLOSED with a shared edge walked the SAME way by both its faces (checkLocal's inconsistent_face_orientation / loop-edge-use-inconsistent); this flips FACE_BOUND orientation flags on whole connected sets of loops (never a single loop) to make every shared edge opposite, or says why it could not. Pure B-rep surgery; never intersects, never adds/removes a face. See ops/meshToBrep.js's header.

interface MeshToBrepOrientResult

MeshToBrepShellSenseCensus interface

ops/meshToBrep.js's raw per-edge orientation reading of one solid's shell: uses maps an edge id to every FACE_BOUND that walks it, with the sense (true/false) it walks it in; an edge used twice with the SAME sense is inconsistent. Pure reading, no mutation.

interface MeshToBrepShellSenseCensus

MeshToBrepLoopWinding interface partly typed

CADSB-1435 / CADSF-2867: how route M decided every loop's direction (summary.loopWinding). mode 'halfEdge' reads the mesh's own winding; 'chart' is the pre-ticket (u,v) area-sign rule.

interface MeshToBrepLoopWinding

MeshToBrepSliver interface partly typed

One degenerate region dropped as a sliver (summary.slivers[]).

interface MeshToBrepSliver

MeshToBrepIslandSplit interface

CADSF-2867: a region split into islands edge-connected pieces (summary.islandSplits[]; region is the pre-split index).

interface MeshToBrepIslandSplit

MeshToBrepRouteMSummary interface partly typed

Route M's report summary (ops/meshToBrep.js graftCandidate), the fields CADSF-2867 surfaces; the rest is read through the index signature.

interface MeshToBrepRouteMSummary

ops namespace

ops.primitives namespace

Analytic primitives on a fresh StepParser. origin is the min-corner (box) or base centre (cylinder / cone / frustum / sphere / torus).

ops.polyhedra namespace

Regular / semi-regular polyhedra of circumradius R, plus a general vertex/face-list constructor.

ops.extrude namespace

Planar sketch profile → prism.

ops.revolve namespace

CADSF-159: solid of revolution from a closed r-z profile about +Z.

ops.loft namespace

Ruled (2-section) and cubic (≥3-section) lofts through closed planar profiles, each in its own z = const plane.

ops.shell namespace

CADSF-160: shell / hollow to a wall thickness, leaving openFaceIds open.

ops.offset namespace

General robust body offset (CADSF-262): uniform (distance) or per-face variable (opts.faceDistances) — see ops/offset.js's header for the sign convention and the local/convexTrim construction paths.

ops.holes namespace

Manufacturing holes (drill / tapped / counterbore / countersink) cut into a body, with the ISO thread, tap-drill and clearance tables.

ops.blend namespace

Edge fillets (rolling-ball blends). The result is a NEW solid in the same parser; every refusal is named (.reasonCode).

ops.chamfer namespace

Edge chamfers — the flat twin of blend, same selection routes.

ops.boolean namespace

Booleans. subtract / union / intersect take the exact pierce fast path where its hypothesis holds and the general classify-and- stitch engine otherwise; the result is a NEW solid, inputs untouched. CADSF-236 adds the ACIS-style selective boolean (cell decomposition).

ops.surgery namespace

Face-level surgery: delete-and-cap, split by plane, push/pull.